cerevox 3.9.3 → 3.10.0

package/dist/mcp/servers/zerocut.js

@@ -329,7 +329,7 @@ let session = null;
 let projectLocalDir = process.env.ZEROCUT_PROJECT_CWD || process.cwd() || '.';
 let checkStoryboardFlag = false;
 let checkAudioVideoDurationFlag = false;
-let checkStoryboardSubtitlesFlag = false;
+// let checkStoryboardSubtitlesFlag = false;
 let closeSessionTimerId = null;
 // 注册 ZeroCut 指导规范 Prompt
 server.registerPrompt('zerocut-guideline', {
@@ -585,7 +585,7 @@ server.registerTool('retrieve-rules-context', {
         // 当 projectRulesFile 不存在时，设置 checkAudioVideoDurationFlag 为 false
         checkAudioVideoDurationFlag = false;
         // 当 projectRulesFile 不存在时，设置 checkStoryboardSubtitlesFlag 为 false
-        checkStoryboardSubtitlesFlag = false;
+        // checkStoryboardSubtitlesFlag = false;
     }
     if (type === 'switch') {
         (0, node_fs_1.rmSync)(projectRulesFile, { force: true });
@@ -667,6 +667,178 @@ ${JSON.stringify(rulesList, null, 2)}
         return createErrorResponse(`Failed to load rules context prompt for ${prompt}: ${error}`, 'retrieve-rules-context');
     }
 });
+server.registerTool('upload-custom-material', {
+    title: 'Upload Custom Material',
+    description: 'Upload material files (images: jpeg/png, videos: mp4, audio: mp3) from the local filesystem to the materials directory. For video and audio files, duration information will be included in the response.',
+    inputSchema: {
+        localFileName: zod_1.z
+            .string()
+            .describe('The file name of the file to upload. Supported formats: jpeg, png, mp4, mp3'),
+    },
+}, async ({ localFileName }) => {
+    try {
+        // 验证session状态
+        const currentSession = await validateSession('upload-custom-material');
+        // 构建本地文件路径，使用 ZEROCUT_PROJECT_CWD 环境变量
+        const validatedPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'materials', localFileName.trim());
+        // 验证本地文件存在性
+        if (!(0, node_fs_1.existsSync)(validatedPath)) {
+            throw new Error(`File not found: ${validatedPath}`);
+        }
+        const fileName = (0, node_path_1.basename)(validatedPath);
+        const validatedFileName = validateFileName(fileName);
+        // 检查文件格式
+        const fileExtension = fileName.toLowerCase().split('.').pop();
+        const allowedFormats = ['jpeg', 'jpg', 'png', 'mp4', 'mp3'];
+        if (!fileExtension || !allowedFormats.includes(fileExtension)) {
+            throw new Error(`Unsupported file format: ${fileExtension}. Allowed formats: ${allowedFormats.join(', ')}`);
+        }
+        console.log(`Uploading material: ${validatedPath} -> ${validatedFileName}`);
+        const files = currentSession.files;
+        // 直接上传到 sandbox 的 cerevox-zerocut 项目 materials 目录
+        const terminal = currentSession.terminal;
+        const materialsDir = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials`;
+        await files.upload(validatedPath, `${materialsDir}/${validatedFileName}`);
+        // 通过 getMaterialUri 获取材料 URI
+        const materialUri = getMaterialUri(currentSession, validatedFileName);
+        // 检测媒体文件时长
+        let durationMs;
+        const isVideoOrAudio = ['mp4', 'mp3'].includes(fileExtension);
+        if (isVideoOrAudio) {
+            try {
+                // 使用现有的 getMediaDuration 函数获取时长（秒）
+                let durationSeconds = null;
+                if (fileExtension === 'mp4') {
+                    durationSeconds = await (0, videokit_1.getMediaDuration)(validatedPath);
+                }
+                else if (fileExtension === 'mp3') {
+                    durationSeconds = await (0, mp3_duration_1.default)(validatedPath);
+                }
+                if (durationSeconds !== null) {
+                    durationMs = Math.round(durationSeconds * 1000); // 转换为毫秒
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to get duration for ${validatedFileName}:`, error);
+                // 时长检测失败不影响上传，继续处理
+            }
+        }
+        const result = {
+            success: true,
+            uri: materialUri,
+            filename: validatedFileName,
+            timestamp: new Date().toISOString(),
+        };
+        // 如果是视频或音频文件且成功获取时长，添加到结果中
+        if (durationMs !== undefined) {
+            result.durationMs = durationMs;
+        }
+        console.log('Material uploaded successfully:', result);
+        try {
+            await updateMediaLogs(currentSession, validatedFileName, result);
+        }
+        catch (error) {
+            console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return createErrorResponse(error, 'upload-custom-material');
+    }
+});
+server.registerTool('wait-for-task-finish', {
+    title: 'Wait Workflow or VideoTask Done；只有正在运行Coze工作流或者有异步生成视频任务时才需要执行这个工具;⚠️ 如果执行这个工具未失败只是超时，你应立即再次重新调用，以继续等待直到任务完成或失败',
+    description: 'Wait for a workflow to complete.',
+    inputSchema: {
+        taskUrl: zod_1.z
+            .string()
+            .describe('The taskUrl of the task to wait for. 一般是Coze工作流任务或视频、图片生成工具调用时返回的taskUrl'),
+        saveToFileName: zod_1.z
+            .string()
+            .describe('The file name to save the media to.  根据任务是图片或视频，应该是mp4或png文件'),
+    },
+}, async ({ taskUrl, saveToFileName }, context) => {
+    try {
+        const currentSession = await validateSession('wait-for-task-finish');
+        const ai = currentSession.ai;
+        const validatedFileName = validateFileName(saveToFileName);
+        let progress = 0;
+        const keySet = new Set();
+        const res = await ai.waitForTaskComplete({
+            taskUrl,
+            onProgress: async (metaData) => {
+                try {
+                    // 保存输出节点的内容
+                    const data = metaData.data;
+                    if (data) {
+                        const ext = (0, node_path_1.extname)(validatedFileName);
+                        const baseName = validatedFileName.slice(0, -ext.length);
+                        for (const [key, value] of Object.entries(data)) {
+                            if (keySet.has(value)) {
+                                continue;
+                            }
+                            if (key.startsWith('Materials_')) {
+                                keySet.add(value);
+                                const materials = JSON.parse(value);
+                                for (const { url, filename } of materials) {
+                                    await saveMaterial(currentSession, url, `${baseName}-parts-${filename}`);
+                                }
+                            }
+                        }
+                    }
+                    await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
+                }
+                catch (progressError) {
+                    console.warn('Failed to send progress update:', progressError);
+                }
+            },
+            timeout: 300000,
+        });
+        if (res.url) {
+            const uri = await saveMaterial(currentSession, res.url, validatedFileName);
+            // Update media_logs.json
+            try {
+                await updateMediaLogs(currentSession, validatedFileName, res, 'audio');
+            }
+            catch (error) {
+                console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            uri,
+                            source: res.url,
+                            duration: res.duration,
+                            resolution: res.resolution,
+                            ratio: res.ratio,
+                        }),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(res),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return createErrorResponse(error, 'wait-for-task-finish');
+    }
+});
 server.registerTool('generate-character-image', {
     title: 'Generate Character Image',
     description: 'Generate a turnaround image or portrait for any character.',
@@ -873,92 +1045,6 @@ ${roleDescriptionPrompt}
         return createErrorResponse(error, 'generate-character-image');
     }
 });
-server.registerTool('upload-custom-material', {
-    title: 'Upload Custom Material',
-    description: 'Upload material files (images: jpeg/png, videos: mp4, audio: mp3) from the local filesystem to the materials directory. For video and audio files, duration information will be included in the response.',
-    inputSchema: {
-        localFileName: zod_1.z
-            .string()
-            .describe('The file name of the file to upload. Supported formats: jpeg, png, mp4, mp3'),
-    },
-}, async ({ localFileName }) => {
-    try {
-        // 验证session状态
-        const currentSession = await validateSession('upload-custom-material');
-        // 构建本地文件路径，使用 ZEROCUT_PROJECT_CWD 环境变量
-        const validatedPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'materials', localFileName.trim());
-        // 验证本地文件存在性
-        if (!(0, node_fs_1.existsSync)(validatedPath)) {
-            throw new Error(`File not found: ${validatedPath}`);
-        }
-        const fileName = (0, node_path_1.basename)(validatedPath);
-        const validatedFileName = validateFileName(fileName);
-        // 检查文件格式
-        const fileExtension = fileName.toLowerCase().split('.').pop();
-        const allowedFormats = ['jpeg', 'jpg', 'png', 'mp4', 'mp3'];
-        if (!fileExtension || !allowedFormats.includes(fileExtension)) {
-            throw new Error(`Unsupported file format: ${fileExtension}. Allowed formats: ${allowedFormats.join(', ')}`);
-        }
-        console.log(`Uploading material: ${validatedPath} -> ${validatedFileName}`);
-        const files = currentSession.files;
-        // 直接上传到 sandbox 的 cerevox-zerocut 项目 materials 目录
-        const terminal = currentSession.terminal;
-        const materialsDir = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials`;
-        await files.upload(validatedPath, `${materialsDir}/${validatedFileName}`);
-        // 通过 getMaterialUri 获取材料 URI
-        const materialUri = getMaterialUri(currentSession, validatedFileName);
-        // 检测媒体文件时长
-        let durationMs;
-        const isVideoOrAudio = ['mp4', 'mp3'].includes(fileExtension);
-        if (isVideoOrAudio) {
-            try {
-                // 使用现有的 getMediaDuration 函数获取时长（秒）
-                let durationSeconds = null;
-                if (fileExtension === 'mp4') {
-                    durationSeconds = await (0, videokit_1.getMediaDuration)(validatedPath);
-                }
-                else if (fileExtension === 'mp3') {
-                    durationSeconds = await (0, mp3_duration_1.default)(validatedPath);
-                }
-                if (durationSeconds !== null) {
-                    durationMs = Math.round(durationSeconds * 1000); // 转换为毫秒
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to get duration for ${validatedFileName}:`, error);
-                // 时长检测失败不影响上传，继续处理
-            }
-        }
-        const result = {
-            success: true,
-            uri: materialUri,
-            filename: validatedFileName,
-            timestamp: new Date().toISOString(),
-        };
-        // 如果是视频或音频文件且成功获取时长，添加到结果中
-        if (durationMs !== undefined) {
-            result.durationMs = durationMs;
-        }
-        console.log('Material uploaded successfully:', result);
-        try {
-            await updateMediaLogs(currentSession, validatedFileName, result);
-        }
-        catch (error) {
-            console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error, 'upload-custom-material');
-    }
-});
 server.registerTool('generate-image', {
     title: 'Generate Image',
     description: `生成图片，支持批量生成1-9张图，若用户要求生成关联图片或组图，请一次生成，不要分几次生成`,
@@ -1590,6 +1676,7 @@ server.registerTool('generate-short-video-outlines', {
             language,
             images,
             videoModel: model,
+            aspectRatio: orientation === 'portrait' ? '9:16' : '16:9',
         });
         if (!res) {
             throw new Error('Failed to generate short video outlines: no response from AI service');
@@ -1671,508 +1758,137 @@ server.registerTool('generate-short-video-outlines', {
         return createErrorResponse(error, 'generate-short-video-outlines');
     }
 });
-let lastEffect = '';
-server.registerTool('generate-video', {
-    title: 'Generate Video',
-    description: `图生视频和首尾帧生视频工具`,
+server.registerTool('generate-music-or-mv', {
+    title: '创作音乐（Music）或音乐视频（Music Video）',
+    description: '生成音乐，包括MV（music video）、BGM 或 歌曲',
     inputSchema: {
-        prompt: zod_1.z
+        prompt: zod_1.z.string().describe('The prompt to generate.'),
+        singerPhoto: zod_1.z
             .string()
-            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前场景的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
-        sceneIndex: zod_1.z
-            .number()
-            .min(1)
             .optional()
-            .describe('场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'),
-        storyBoardFile: zod_1.z
+            .describe('The singer photo to use. 只有type为music_video的时候才生效，也可以不传，模型会自动生成'),
+        mvOrientation: zod_1.z
+            .enum(['portrait', 'landscape'])
+            .optional()
+            .describe('The orientation of the music video. Defaults to portrait.')
+            .default('portrait'),
+        mvOriginalSong: zod_1.z
             .string()
             .optional()
-            .default('storyboard.json')
-            .describe('故事板文件路径'),
-        skipConsistencyCheck: zod_1.z
+            .describe('用于生成mv的音乐. 只有type为music_video的时候才生效，也可以不传，模型会自动创作'),
+        mvGenSubtitles: zod_1.z
             .boolean()
             .optional()
             .default(false)
-            .describe('是否跳过一致性检查，默认为false（即默认进行一致性检查）'),
-        skipCheckWithSceneReason: zod_1.z
-            .string()
-            .optional()
-            .describe('跳过校验的理由，如果skipConsistencyCheck设为true，必须要传这个参数'),
+            .describe('是否生成mv的字幕. 默认为false，只有type为music_video的时候才生效'),
         type: zod_1.z
-            .enum([
-            'pro',
-            'hailuo',
-            'hailuo-fast',
-            'vidu',
-            'vidu-turbo',
-            'vidu-pro',
-            'vidu-uc',
-            'vidu-uc-pro',
-            'kling',
-            'pixv',
-            'veo3.1',
-            'veo3.1-pro',
-            'kenburns',
-            'zero',
-            'zero-fast',
-        ])
-            .default('vidu')
-            .describe('除非用户明确提出使用其他模型，否则默认用vidu模型；zero 系列模型适合创作8-24秒带故事情节的短片'),
-        mute: zod_1.z
-            .boolean()
-            .optional()
-            .default(true)
-            .describe('Whether to mute the video (effective for vidu,sora2 and veo3.1). 除非用户明确要求，否则默认静音；非静音模式下模型会自己配音，不需要再使用tts工具！'),
-        seed: zod_1.z
-            .number()
-            .optional()
-            .describe('The seed to use for random number generation. 用户可以指定一个固定值来获得可重复的结果'),
-        saveToFileName: zod_1.z
-            .string()
-            .describe('The filename to save. 应该是mp4文件'),
-        start_frame: zod_1.z
-            .string()
+            .enum(['bgm', 'song', 'music_video'])
+            .describe('The type of music. Defaults to BGM. ⚠️ 如果 type 是 music_video，会直接生成音频和视频，**不需要**额外专门生成歌曲')
+            .default('bgm'),
+        model: zod_1.z
+            .enum(['doubao', 'minimax'])
             .optional()
-            .describe('The image file name of the start frame.'),
+            .describe('The model to use. Defaults to doubao.')
+            .default('doubao'),
         duration: zod_1.z
             .number()
-            .min(0)
-            .max(30)
-            .describe('The duration of the video. 可以传0，此时会根据视频提示词内容自动确定时长'),
-        end_frame: zod_1.z
-            .string()
-            .optional()
-            .describe('The image file name of the end frame (for non-zero models) or highlight frame (for zero models).'),
-        saveLastFrameAs: zod_1.z
-            .string()
-            .optional()
-            .describe('The filename to save the last frame. 只有用户要求使用镜头自然延伸时，才需要这个参数，默认不传'),
-        resolution: zod_1.z
-            .enum(['720p', '1080p'])
-            .optional()
-            .default('720p')
-            .describe('除非用户明确提出使用其他分辨率，否则一律用720p'),
-        optimizePrompt: zod_1.z
+            .min(30)
+            .max(240)
+            .describe('The duration of the bgm or music.'),
+        skipCopyCheck: zod_1.z
             .boolean()
-            .optional()
             .default(false)
-            .describe('Whether to optimize the prompt.'),
+            .describe('Whether to skip copyright check.'),
+        saveToFileName: zod_1.z
+            .string()
+            .describe('The filename to save. 如果type是music video，应该是mp4文件，否则应该是mp3文件'),
     },
-}, async ({ prompt, sceneIndex, storyBoardFile = 'storyboard.json', skipConsistencyCheck = false, saveToFileName, start_frame, end_frame, duration, resolution, type = 'vidu', optimizePrompt, saveLastFrameAs, mute = true, seed, }, context) => {
+}, async ({ prompt, singerPhoto, mvOrientation, mvOriginalSong, mvGenSubtitles, type, model, duration, skipCopyCheck, saveToFileName, }, context) => {
     try {
         // 验证session状态
-        const currentSession = await validateSession('generate-video');
-        const isZeroModel = type.startsWith('zero');
-        if (!start_frame && !isZeroModel) {
-            return createErrorResponse('start_frame 不能为空', 'generate-video');
-        }
-        if (!isZeroModel && duration > 16) {
-            return createErrorResponse('非 zero 系列模型的视频仅支持 16 秒以下时长', 'generate-video');
-        }
-        else if (isZeroModel && duration < 8) {
-            return createErrorResponse('zero 系列模型的视频仅支持 8 秒以上时长', 'generate-video');
-        }
-        if (type === 'zero-fast' && duration > 24) {
-            return createErrorResponse('zero-fast 模型的视频仅支持 24 秒以下时长', 'generate-video');
-        }
-        if (type === 'zero' && resolution !== '1080p') {
-            console.warn(`zero 模型的视频仅支持 1080p 分辨率，用户指定的分辨率为 %s，已自动将 ${resolution} 转换为 1080p`, resolution);
-            resolution = '1080p';
+        const currentSession = await validateSession('generate-music');
+        const validatedFileName = validateFileName(saveToFileName);
+        console.log(`Generating Music with prompt: ${prompt.substring(0, 100)}... (${duration}s)`);
+        const ai = currentSession.ai;
+        let progress = 0;
+        if (type === 'bgm' && duration > 120) {
+            throw new Error('BGM duration must be at most 120 seconds.');
         }
-        // 校验 prompt 与 storyboard.json 中场景设定的一致性以及视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
-        if (sceneIndex && !skipConsistencyCheck) {
-            try {
-                const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
-                if ((0, node_fs_1.existsSync)(storyBoardPath)) {
-                    const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
-                    // 检查 storyBoard JSON 语法合法性
-                    let storyBoard;
+        let res;
+        if (type === 'music_video') {
+            const singer_photo = singerPhoto
+                ? await getMaterialUri(currentSession, singerPhoto)
+                : undefined;
+            const original_song = mvOriginalSong
+                ? await getMaterialUri(currentSession, mvOriginalSong)
+                : undefined;
+            res = await ai.generateZeroCutMusicVideo({
+                // prompt: `${prompt.trim()} 音乐时长${duration}秒`,
+                prompt,
+                singerPhoto: singer_photo,
+                orientation: mvOrientation,
+                genSubtitles: mvGenSubtitles,
+                originalSong: original_song,
+                duration,
+                resolution: '720p',
+                onProgress: async (metaData) => {
                     try {
-                        storyBoard = JSON.parse(storyBoardContent);
+                        await sendProgress(context, metaData.Result?.Progress ?? ++progress, metaData.Result?.Progress ? 100 : undefined, JSON.stringify(metaData));
                     }
-                    catch (jsonError) {
-                        return createErrorResponse(`storyBoard 文件 ${storyBoardFile} 存在 JSON 语法错误，请修复后重试。错误详情: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`, 'generate-video');
+                    catch (progressError) {
+                        console.warn('Failed to send progress update:', progressError);
                     }
-                    if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
-                        const scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-                        if (scene) {
-                            const videoPrompt = scene.video_prompt;
-                            if (videoPrompt && prompt !== videoPrompt) {
-                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
-                            }
-                            if (scene.is_continuous && !end_frame) {
-                                return createErrorResponse('连续场景必须指定end_frame参数，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
-                            }
-                            if (scene.video_duration != null &&
-                                duration !== scene.video_duration) {
-                                return createErrorResponse(`视频时长必须严格遵照storyboard的设定，用户指定的时长为 ${duration} 秒，而 storyboard 中建议的时长为 ${scene.video_duration} 秒。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用`, 'generate-video');
-                            }
-                            if (storyBoard.voice_type &&
-                                storyBoard.voice_type !== 'slient') {
-                                if (mute) {
-                                    return createErrorResponse('有对话和旁白的场景不能静音，请将mute设为false再重新使用工具。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
-                                }
-                            }
-                            // 检查 use_video_model 与 type 参数的一致性
-                            if (scene.use_video_model &&
-                                type &&
-                                scene.use_video_model !== type) {
-                                return createErrorResponse(`场景建议的视频模型(${scene.use_video_model})与传入的type参数(${type})不一致。请确保use_video_model与type参数值相同，或将skipConsistencyCheck设置为true后再次调用`, 'generate-video');
-                            }
-                        }
-                        else {
-                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
-                        }
+                },
+                waitForFinish: false,
+            });
+        }
+        else {
+            const finalPrompt = `${prompt.trim()} ${type === 'bgm' ? `纯音乐无歌词，时长${duration}秒` : `时长${duration}秒，使用${model}模型`}`;
+            res = await ai.generateMusic({
+                prompt: finalPrompt,
+                skipCopyCheck,
+                onProgress: async (metaData) => {
+                    try {
+                        await sendProgress(context, metaData.Result?.Progress ?? ++progress, metaData.Result?.Progress ? 100 : undefined, JSON.stringify(metaData));
                     }
-                }
-                else {
-                    console.warn(`Story board file not found: ${storyBoardPath}`);
-                }
+                    catch (progressError) {
+                        console.warn('Failed to send progress update:', progressError);
+                    }
+                },
+            });
+        }
+        if (!res) {
+            throw new Error('Failed to generate Music: no response from AI service');
+        }
+        if (res.url) {
+            console.log('Music generated successfully, saving to materials...');
+            const uri = await saveMaterial(currentSession, res.url, validatedFileName);
+            const { url, duration: bgmDuration, captions, ...opts } = res;
+            // 保存captions到本地
+            if (captions) {
+                const captionsText = JSON.stringify(captions, null, 2);
+                // 本地路径
+                const localPath = node_path_1.default.resolve(projectLocalDir, 'materials', `${validatedFileName}.captions.json`);
+                // 保存到本地
+                await (0, promises_1.writeFile)(localPath, captionsText);
+            }
+            const result = {
+                success: true,
+                // source: url,
+                uri,
+                durationMs: Math.floor((bgmDuration || duration) * 1000),
+                prompt,
+                captions,
+                requestedDuration: duration,
+                timestamp: new Date().toISOString(),
+                ...opts,
+            };
+            // Update media_logs.json
+            try {
+                await updateMediaLogs(currentSession, validatedFileName, result, 'audio');
             }
             catch (error) {
-                console.error('Failed to validate prompt with story board:', error);
-                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
-            }
-            // 校验视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
-            try {
-                const timelineAnalysisPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'timeline_analysis.json');
-                if ((0, node_fs_1.existsSync)(timelineAnalysisPath)) {
-                    const timelineAnalysisContent = await (0, promises_1.readFile)(timelineAnalysisPath, 'utf8');
-                    const timelineAnalysis = JSON.parse(timelineAnalysisContent);
-                    if (timelineAnalysis.proposed_video_scenes &&
-                        Array.isArray(timelineAnalysis.proposed_video_scenes)) {
-                        const videoScene = timelineAnalysis.proposed_video_scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-                        if (videoScene && videoScene.video_duration_s) {
-                            const expectedDuration = videoScene.video_duration_s;
-                            if (duration !== expectedDuration) {
-                                return createErrorResponse(`视频时长必须与timeline_analysis中的设定匹配。当前场景${videoScene.scene_id}要求时长为${expectedDuration}秒，但传入的duration为${duration}秒。请调整duration参数为${expectedDuration}秒后重试。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用。`, 'generate-video');
-                            }
-                        }
-                        else {
-                            console.warn(`Scene ${sceneIndex} (scene_${sceneIndex.toString().padStart(2, '0')}) not found in timeline_analysis.json proposed_video_scenes`);
-                        }
-                    }
-                }
-                else {
-                    // 检查音频时长标志
-                    try {
-                        const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
-                        if ((0, node_fs_1.existsSync)(storyBoardPath)) {
-                            const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
-                            const storyBoard = JSON.parse(storyBoardContent);
-                            if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
-                                const scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-                                if (scene &&
-                                    ((scene.script && scene.script.trim() !== '') ||
-                                        scene.dialog)) {
-                                    if (!checkAudioVideoDurationFlag) {
-                                        checkAudioVideoDurationFlag = true;
-                                        if (scene.audio_mode === 'vo_sync') {
-                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长为音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
-                                        }
-                                        else if (scene.audio_mode === 'dialogue') {
-                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长**不小于**音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        console.error('Failed to check audio duration flag:', error);
-                    }
-                }
-            }
-            catch (error) {
-                console.error('Failed to validate duration with timeline analysis:', error);
-                // 如果读取或解析 timeline_analysis.json 失败，继续执行但记录警告
-            }
-        }
-        const validatedFileName = validateFileName(saveToFileName);
-        console.log(`Generating video with prompt: ${prompt.substring(0, 100)}...`);
-        const ai = currentSession.ai;
-        let progress = 0;
-        const startFrameUri = start_frame
-            ? getMaterialUri(currentSession, start_frame)
-            : undefined;
-        const endFrameUri = end_frame
-            ? getMaterialUri(currentSession, end_frame)
-            : undefined;
-        if (optimizePrompt) {
-            try {
-                const promptOptimizer = await (0, promises_1.readFile)((0, node_path_1.resolve)(__dirname, './prompts/video-prompt-optimizer.md'), 'utf8');
-                const completion = await ai.getCompletions({
-                    messages: [
-                        {
-                            role: 'system',
-                            content: promptOptimizer,
-                        },
-                        {
-                            role: 'user',
-                            content: prompt.trim(),
-                        },
-                    ],
-                });
-                const optimizedPrompt = completion.choices[0]?.message?.content;
-                if (optimizedPrompt) {
-                    prompt = optimizedPrompt;
-                }
-            }
-            catch (error) {
-                console.error('Failed to optimize prompt:', error);
-            }
-        }
-        if (type === 'kenburns') {
-            // 实现 getImageSize 函数
-            async function getImageSize(imageUri) {
-                // imageUri 是一个可以 http 访问的图片
-                // eslint-disable-next-line custom/no-fetch-in-src
-                const response = await fetch(imageUri);
-                const arrayBuffer = await response.arrayBuffer();
-                const buffer = Buffer.from(arrayBuffer);
-                const image = (0, image_size_1.default)(buffer);
-                return [image.width, image.height];
-            }
-            const [imageWidth, imageHeight] = await getImageSize(startFrameUri);
-            const kenburnsPrompt = `根据用户描述和配置，生成适合的 kenburns 动画参数。
-
-## 配置信息
-- 视频时长：${duration}秒
-- 分辨率：${resolution}
-- 保存最后一帧：${saveLastFrameAs ? '是' : '否'}
-- 图片宽高：${imageWidth}x${imageHeight}
-- 上一次选择的特效：${lastEffect || '无'}
-
-## camera_motion 可选特效
-- zoom_in
-- zoom_out
-- zoom_in_left_top
-- zoom_out_left_top
-- zoom_in_right_top
-- zoom_out_right_top
-- zoom_in_left_bottom
-- zoom_out_left_bottom
-- zoom_in_right_bottom
-- zoom_out_right_bottom
-- pan_up
-- pan_down
-- pan_left
-- pan_right
-- static
-
-## 特效选用规则
-- 视频时长6秒内：优先选择zoom类型(zoom_in, zoom_out)
-- 视频时长6秒以上：优先选择pan类型(pan_left, pan_right, pan_up, pan_down)
-- 除非用户指定，否则不要主动使用 static 效果
-- 除非用户指定，否则不要和上一次选择的效果重复
-`;
-            const schema = {
-                name: 'kenburns_effect',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        camera_motion: {
-                            type: 'string',
-                            description: 'kenburns 特效类型',
-                            enum: [
-                                'zoom_in',
-                                'zoom_out',
-                                'zoom_in_left_top',
-                                'zoom_out_left_top',
-                                'zoom_in_right_top',
-                                'zoom_out_right_top',
-                                'zoom_in_left_bottom',
-                                'zoom_out_left_bottom',
-                                'zoom_in_right_bottom',
-                                'zoom_out_right_bottom',
-                                'pan_up',
-                                'pan_down',
-                                'pan_left',
-                                'pan_right',
-                                'static',
-                            ],
-                        },
-                        size: {
-                            type: 'string',
-                            description: 'kenburns 视频 宽x高',
-                        },
-                        duration: {
-                            type: 'number',
-                            description: 'kenburns 视频 时长',
-                        },
-                    },
-                    required: ['camera_motion', 'size', 'duration'],
-                },
-            };
-            const analysisPayload = {
-                model: 'Doubao-Seed-1.6-flash',
-                messages: [
-                    {
-                        role: 'system',
-                        content: kenburnsPrompt,
-                    },
-                    {
-                        role: 'user',
-                        content: prompt.trim(),
-                    },
-                ],
-                response_format: {
-                    type: 'json_schema',
-                    json_schema: schema,
-                },
-            };
-            console.log(JSON.stringify(analysisPayload, null, 2));
-            const completion = await ai.getCompletions(analysisPayload);
-            const analysisResult = completion.choices[0]?.message?.content;
-            if (!analysisResult) {
-                throw new Error('Failed to generate kenburns effect');
-            }
-            try {
-                const kenburnsEffect = JSON.parse(analysisResult);
-                const { camera_motion, size, duration } = kenburnsEffect;
-                if (!camera_motion || !size || !duration) {
-                    throw new Error('Invalid kenburns effect parameters');
-                }
-                lastEffect = camera_motion;
-                const files = currentSession.files;
-                const terminal = currentSession.terminal;
-                start_frame = (0, node_path_1.resolve)('/home/user/cerevox-zerocut/projects', terminal.id, 'materials', (0, node_path_1.basename)(start_frame));
-                const saveToPath = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials/${validatedFileName}`;
-                const saveLocalPath = (0, node_path_1.resolve)(projectLocalDir, 'materials', validatedFileName);
-                // 解析尺寸参数
-                const sizeArray = size.split('x');
-                if (sizeArray.length !== 2) {
-                    throw new Error(`Invalid size format: ${size}. Expected format: WIDTHxHEIGHT`);
-                }
-                const [widthStr, heightStr] = sizeArray;
-                const width = Number(widthStr);
-                const height = Number(heightStr);
-                if (isNaN(width) || isNaN(height) || width <= 0 || height <= 0) {
-                    throw new Error(`Invalid dimensions: ${width}x${height}. Both width and height must be positive numbers`);
-                }
-                console.log(`Compiling Ken Burns motion command...`);
-                let command;
-                try {
-                    command = await (0, videokit_1.compileKenBurnsMotion)(start_frame, duration, camera_motion, {
-                        output: saveToPath,
-                        width,
-                        height,
-                    });
-                }
-                catch (compileError) {
-                    console.error('Failed to compile Ken Burns motion command:', compileError);
-                    throw new Error(`Failed to compile Ken Burns motion: ${compileError}`);
-                }
-                console.log(`Executing FFmpeg command: ${command.substring(0, 100)}...`);
-                const res = await terminal.run(command);
-                const result = await res.json();
-                if (result.exitCode !== 0) {
-                    console.error('FFmpeg command failed:', result);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    error: 'Ken Burns motion generation failed',
-                                    exitCode: result.exitCode,
-                                    stderr: result.stderr,
-                                    command,
-                                    timestamp: new Date().toISOString(),
-                                }),
-                            },
-                        ],
-                    };
-                }
-                console.log('Ken Burns motion generated successfully, downloading file...');
-                try {
-                    await files.download(saveToPath, saveLocalPath);
-                }
-                catch (downloadError) {
-                    console.warn('Failed to download file to local:', downloadError);
-                    // 继续执行，因为远程文件已生成成功
-                }
-                const resultData = {
-                    success: true,
-                    uri: saveToPath,
-                    durationMs: Math.floor(duration * 1000),
-                    cameraMotion: camera_motion,
-                    imagePath: start_frame,
-                    size,
-                    dimensions: { width, height },
-                    timestamp: new Date().toISOString(),
-                    systemPrompt: kenburnsPrompt,
-                };
-                console.log(`Ken Burns motion completed: ${saveToPath}`);
-                currentSession.track('KenBurns Video Generated', {
-                    durationMs: Math.floor(duration * 1000).toString(),
-                    cameraMotion: camera_motion,
-                    imagePath: start_frame,
-                    size,
-                    dimensions: size,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(resultData),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                throw new Error('Failed to parse kenburns effect parameters');
-            }
-        }
-        const res = await ai.framesToVideo({
-            prompt: prompt.trim(),
-            start_frame: startFrameUri,
-            end_frame: endFrameUri,
-            duration,
-            resolution,
-            type,
-            return_last_frame: Boolean(saveLastFrameAs),
-            onProgress: async (metaData) => {
-                try {
-                    await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
-                }
-                catch (progressError) {
-                    console.warn('Failed to send progress update:', progressError);
-                }
-            },
-            waitForFinish: type !== 'zero',
-            mute,
-            seed,
-        });
-        if (!res) {
-            throw new Error('Failed to generate video: no response from AI service');
-        }
-        if (res.url) {
-            console.log('Video generated successfully, saving to materials...');
-            const uri = await saveMaterial(currentSession, res.url, validatedFileName);
-            let lastFrameUri;
-            if (saveLastFrameAs && res.last_frame_url) {
-                lastFrameUri = await saveMaterial(currentSession, res.last_frame_url, validateFileName(saveLastFrameAs));
-            }
-            const { url, duration: videoDuration, ...opts } = res;
-            const result = {
-                success: true,
-                // source: url,
-                uri,
-                lastFrameUri,
-                durationMs: Math.floor((videoDuration || duration) * 1000),
-                prompt,
-                timestamp: new Date().toISOString(),
-                startFrame: start_frame,
-                endFrame: end_frame,
-                ...opts,
-            };
-            // Update media_logs.json
-            try {
-                await updateMediaLogs(currentSession, validatedFileName, result);
-            }
-            catch (error) {
-                console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
+                console.warn('Failed to update media_logs.json:', error);
             }
             return {
                 content: [
@@ -2190,7 +1906,7 @@ server.registerTool('generate-video', {
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
-                            message: '该视频生成任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
+                            message: '该视频生成任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
                             taskUrl: res.taskUrl,
                         }),
                     },
@@ -2198,16 +1914,15 @@ server.registerTool('generate-video', {
             };
         }
         else {
-            console.warn('Video generation completed but no URL returned');
+            console.warn('Music generation completed but no URL returned');
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: 'No video URL returned from AI service',
+                            error: 'No Music URL returned from AI service',
                             response: res,
-                            startFrameUri,
                             timestamp: new Date().toISOString(),
                         }),
                     },
@@ -2216,607 +1931,1197 @@ server.registerTool('generate-video', {
         }
     }
     catch (error) {
-        return createErrorResponse(error, 'generate-video');
-    }
-});
-server.registerTool('wait-for-task-finish', {
-    title: 'Wait Workflow or VideoTask Done；只有正在运行Coze工作流或者有异步生成视频任务时才需要执行这个工具;⚠️ 如果执行这个工具未失败只是超时，你应立即再次重新调用，以继续等待直到任务完成或失败',
-    description: 'Wait for a workflow to complete.',
-    inputSchema: {
-        taskUrl: zod_1.z
-            .string()
-            .describe('The taskUrl of the video task to wait for.'),
-        saveToFileName: zod_1.z
-            .string()
-            .describe('The file name to save the video to. 应该是mp4文件'),
-    },
-}, async ({ taskUrl, saveToFileName }, context) => {
-    try {
-        const currentSession = await validateSession('wait-for-task-finish');
-        const ai = currentSession.ai;
-        const validatedFileName = validateFileName(saveToFileName);
-        let progress = 0;
-        const keySet = new Set();
-        const res = await ai.waitForTaskComplete({
-            taskUrl,
-            onProgress: async (metaData) => {
-                try {
-                    // 保存输出节点的内容
-                    const data = metaData.data;
-                    if (data) {
-                        const ext = (0, node_path_1.extname)(validatedFileName);
-                        const baseName = validatedFileName.slice(0, -ext.length);
-                        for (const [key, value] of Object.entries(data)) {
-                            if (keySet.has(value)) {
-                                continue;
-                            }
-                            if (key.startsWith('Materials_')) {
-                                keySet.add(value);
-                                const materials = JSON.parse(value);
-                                for (const { url, filename } of materials) {
-                                    await saveMaterial(currentSession, url, `${baseName}-parts-${filename}`);
-                                }
-                            }
-                        }
-                    }
-                    await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
-                }
-                catch (progressError) {
-                    console.warn('Failed to send progress update:', progressError);
-                }
-            },
-            timeout: 300000,
-        });
-        if (res.url) {
-            const uri = await saveMaterial(currentSession, res.url, validatedFileName);
-            // Update media_logs.json
-            try {
-                await updateMediaLogs(currentSession, validatedFileName, res, 'audio');
-            }
-            catch (error) {
-                console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            uri,
-                            source: res.url,
-                            duration: res.duration,
-                            resolution: res.resolution,
-                            ratio: res.ratio,
-                        }),
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(res),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error, 'wait-for-task-finish');
+        return createErrorResponse(error, 'generate-music');
     }
 });
-server.registerTool('generate-sound-effect', {
-    title: 'Generate Sound Effect',
-    description: 'Generate sound effect with text prompt.',
+// server.registerTool(
+//   'generate-scene-tts',
+//   {
+//     title: 'Generate Scene TTS',
+//     description: `生成场景配音`,
+//     inputSchema: {
+//       text: z.string().describe('The text to generate.'),
+//       sceneIndex: z
+//         .number()
+//         .min(1)
+//         .optional()
+//         .describe(
+//           '场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'
+//         ),
+//       storyBoardFile: z
+//         .string()
+//         .optional()
+//         .default('storyboard.json')
+//         .describe('故事板文件路径'),
+//       skipConsistencyCheck: z
+//         .boolean()
+//         .optional()
+//         .default(false)
+//         .describe('是否跳过一致性检查，默认为false（即默认进行一致性检查）'),
+//       skipCheckWithSceneReason: z
+//         .string()
+//         .optional()
+//         .describe(
+//           '跳过校验的理由，如果skipConsistencyCheck设为true，必须要传这个参数'
+//         ),
+//       saveToFileName: z
+//         .string()
+//         .describe('The filename to save. 应该是mp3文件'),
+//       speed: z
+//         .number()
+//         .min(0.5)
+//         .max(2)
+//         .optional()
+//         .default(1)
+//         .describe('The speed of the tts.'),
+//       pitch: z
+//         .number()
+//         .min(-12)
+//         .max(12)
+//         .optional()
+//         .default(0)
+//         .describe('The pitch of the tts.'),
+//       volume: z
+//         .number()
+//         .min(0)
+//         .max(10)
+//         .optional()
+//         .default(1.0)
+//         .describe('The volume of the tts.'),
+//       voiceID: z
+//         .string()
+//         .describe(
+//           `适合作为视频配音的音色ID，除非用户指定，否则你必须确保已通过 pick-voice 工具挑选出真实存在的音色。`
+//         ),
+//       context_texts: z
+//         .array(z.string())
+//         .default([])
+//         .describe(
+//           `语音合成的辅助信息，用于模型对话式合成，能更好的体现语音情感
+// 可以探索，比如常见示例有以下几种：
+// 1. 语速调整
+//   - context_texts: ["你可以说慢一点吗？"]
+// 2. 情绪/语气调整
+//   - context_texts=["你可以用特别特别痛心的语气说话吗?"]
+//   - context_texts=["嗯，你的语气再欢乐一点"]
+// 3. 音量调整
+//   - context_texts=["你嗓门再小点。"]
+// 4. 音感调整
+//   - context_texts=["你能用骄傲的语气来说话吗？"]
+// `
+//         ),
+//       explicit_language: z.enum(['zh', 'en', 'ja']).optional().default('zh'),
+//     },
+//   },
+//   async ({
+//     text,
+//     sceneIndex,
+//     storyBoardFile,
+//     skipConsistencyCheck,
+//     voiceID,
+//     saveToFileName,
+//     speed,
+//     pitch,
+//     volume,
+//     context_texts,
+//     explicit_language,
+//   }) => {
+//     try {
+//       // 验证session状态
+//       const currentSession = await validateSession('generate-scene-tts');
+//       const validatedFileName = validateFileName(saveToFileName);
+//       const finalSpeed = speed ?? 1;
+//       volume = volume ?? 1;
+//       const ai = currentSession.ai;
+//       let scene = null;
+//       // 校验 text 与 storyboard.json 中场景设定的一致性
+//       if (sceneIndex && !skipConsistencyCheck) {
+//         try {
+//           const voice = (await ai.listVoices()).find(v => v.id === voiceID);
+//           if (!voice) {
+//             return createErrorResponse(
+//               `Voice ${voiceID} not found in voice-list. Use pick-voice tool to pick an available voice. 若用户坚持要使用该音色，需跳过一致性检查。`,
+//               'generate-scene-tts'
+//             );
+//           }
+//           const storyBoardPath = resolve(
+//             process.env.ZEROCUT_PROJECT_CWD || process.cwd(),
+//             projectLocalDir,
+//             storyBoardFile
+//           );
+//           if (existsSync(storyBoardPath)) {
+//             const storyBoardContent = await readFile(storyBoardPath, 'utf8');
+//             // 检查 storyBoard JSON 语法合法性
+//             let storyBoard;
+//             try {
+//               storyBoard = JSON.parse(storyBoardContent);
+//             } catch (jsonError) {
+//               return createErrorResponse(
+//                 `storyBoard 文件 ${storyBoardFile} 存在 JSON 语法错误，请修复后重试。错误详情: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
+//                 'generate-scene-tts'
+//               );
+//             }
+//             if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
+//               scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
+//               if (scene) {
+//                 const script = scene.script;
+//                 let isValidText = false;
+//                 // 检查 text 是否严格等于 script
+//                 if (script && text === script) {
+//                   isValidText = true;
+//                 }
+//                 // 检查 text 是否严格等于 dialog 数组中某个元素的 script
+//                 if (
+//                   !isValidText &&
+//                   scene.dialog &&
+//                   Array.isArray(scene.dialog)
+//                 ) {
+//                   for (const dialogItem of scene.dialog) {
+//                     if (dialogItem.script && text === dialogItem.script) {
+//                       isValidText = true;
+//                       break;
+//                     }
+//                   }
+//                 }
+//                 if (!isValidText) {
+//                   return createErrorResponse(
+//                     '配音文本必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用',
+//                     'generate-scene-tts'
+//                   );
+//                 }
+//               } else {
+//                 console.warn(
+//                   `Scene index ${sceneIndex} not found in storyboard.json`
+//                 );
+//               }
+//             }
+//           } else {
+//             console.warn(`Story board file not found: ${storyBoardPath}`);
+//           }
+//         } catch (error) {
+//           console.error('Failed to validate text with story board:', error);
+//           // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
+//         }
+//       }
+//       console.log(
+//         `Generating TTS with voice: ${voiceID}, speed: ${finalSpeed}, text: ${text.substring(0, 100)}...`
+//       );
+//       if (voiceID.startsWith('BV0')) {
+//         throw new Error(
+//           `BV0* 系列音色已弃用，你必须通过 pick-voice 工具挑选一个真实存在的音色。`
+//         );
+//       }
+//       const type =
+//         voiceID.startsWith('zh_') ||
+//         voiceID.startsWith('en_') ||
+//         voiceID.startsWith('multi_') ||
+//         voiceID.startsWith('saturn_') ||
+//         voiceID.startsWith('ICL_')
+//           ? 'volcano'
+//           : 'minimax';
+//       let res;
+//       let emotion = 'auto';
+//       if (type === 'volcano') {
+//         volume = Math.max(Math.min(volume, 2.0), 0.5);
+//         res = await ai.textToSpeechVolc({
+//           text: text.trim(),
+//           speaker: voiceID,
+//           speed: Math.floor(100 * (finalSpeed - 1)),
+//           volume: Math.floor(100 * (volume - 1)),
+//           context_texts,
+//           explicit_language,
+//           voice_to_caption:
+//             explicit_language === 'zh' || explicit_language === 'en',
+//         });
+//       } else {
+//         emotion = 'neutral';
+//         if (context_texts.length > 0) {
+//           const prompt = `根据用户输入语音内容和上下文内容，从文字判断语音合理的情感，然后选择以下情感**之一**返回结果：
+// "happy", "sad", "angry", "fearful", "disgusted", "surprised", "calm", "fluent", "whisper", "neutral"
+// ## 要求
+// 输出 JSON 格式，包含一个 emotion 字段，值为以上情感之一。
+// `;
+//           const schema = {
+//             name: 'emotion_schema',
+//             schema: {
+//               type: 'object',
+//               properties: {
+//                 emotion: {
+//                   type: 'string',
+//                   enum: [
+//                     'neutral',
+//                     'happy',
+//                     'sad',
+//                     'angry',
+//                     'fearful',
+//                     'disgusted',
+//                     'surprised',
+//                     'calm',
+//                     'fluent',
+//                     'whisper',
+//                   ],
+//                   description: '用户输入语音的情感',
+//                 },
+//               },
+//               required: ['emotion'],
+//             },
+//           };
+//           const payload: any = {
+//             model: 'Doubao-Seed-1.6',
+//             messages: [
+//               {
+//                 role: 'system',
+//                 content: prompt,
+//               },
+//               {
+//                 role: 'user',
+//                 content: `## 语音内容：
+// ${text.trim()}
+// ## 语音上下文
+// ${context_texts.join('\n')}
+// `,
+//               },
+//             ],
+//             response_format: {
+//               type: 'json_schema',
+//               json_schema: schema,
+//             },
+//           };
+//           const completion = await ai.getCompletions(payload);
+//           const emotionObj = JSON.parse(
+//             completion.choices[0]?.message?.content ?? '{}'
+//           );
+//           emotion = emotionObj.emotion ?? 'neutral';
+//         }
+//         res = await ai.textToSpeech({
+//           text: text.trim(),
+//           voiceName: voiceID,
+//           speed: finalSpeed,
+//           pitch,
+//           volume,
+//           emotion,
+//           voice_to_caption:
+//             explicit_language === 'zh' || explicit_language === 'en',
+//         });
+//       }
+//       if (!res) {
+//         throw new Error('Failed to generate TTS: no response from AI service');
+//       }
+//       if (res.url) {
+//         console.log('TTS generated successfully, saving to materials...');
+//         const { url, duration, ...opts } = res;
+//         if (!skipConsistencyCheck && duration > 16) {
+//           return createErrorResponse(
+//             'TTS duration exceeds 16 seconds, 建议调整文本长度、提升语速或拆分场景...，⚠️如简化文本内容或拆分文本，需要立即更新 storyboard 以保持内容同步！如仍要生成，可设置 skipConsistencyCheck 为 true，跳过一致性检查。',
+//             'generate-scene-tts'
+//           );
+//         }
+//         if (!duration) {
+//           return createErrorResponse(
+//             'TTS duration not returned from AI service',
+//             'generate-scene-tts'
+//           );
+//         }
+//         const uri = await saveMaterial(currentSession, url, validatedFileName);
+//         let warn = '';
+//         if (scene) {
+//           const minDur = Math.ceil(duration);
+//           if (scene.audio_mode === 'vo_sync' && scene.duration !== minDur) {
+//             warn = `场景${sceneIndex}设定的时长${scene.duration}秒与实际生成的语音时长${minDur}秒不一致，音画同步将有问题，建议修改场景时长为${minDur}秒`;
+//           } else if (scene.duration < minDur) {
+//             warn = `场景${sceneIndex}设定的时长${scene.duration}秒小于实际生成的语音时长${duration}秒，可能会导致场景结束时音频未播放完成，建议修改场景时长为${minDur}秒`;
+//           }
+//         }
+//         const result = {
+//           success: true,
+//           warn,
+//           source: url, // 方便调试
+//           uri,
+//           durationMs: Math.floor((duration || 0) * 1000),
+//           text,
+//           emotion,
+//           context_texts,
+//           voiceName: voiceID,
+//           speed: finalSpeed,
+//           timestamp: new Date().toISOString(),
+//           ...opts,
+//         };
+//         // Update media_logs.json
+//         try {
+//           await updateMediaLogs(
+//             currentSession,
+//             validatedFileName,
+//             result,
+//             'audio'
+//           );
+//         } catch (error) {
+//           console.warn(
+//             `Failed to update media_logs.json for ${validatedFileName}:`,
+//             error
+//           );
+//         }
+//         return {
+//           content: [
+//             {
+//               type: 'text' as const,
+//               text: JSON.stringify(result),
+//             },
+//           ],
+//         };
+//       } else {
+//         console.warn('TTS generation completed but no URL returned');
+//         return {
+//           content: [
+//             {
+//               type: 'text' as const,
+//               text: JSON.stringify({
+//                 success: false,
+//                 error:
+//                   'No TTS URL returned from AI service. You should use pick-voice tool to pick an available voice.',
+//                 response: res,
+//                 timestamp: new Date().toISOString(),
+//               }),
+//             },
+//           ],
+//         };
+//       }
+//     } catch (error) {
+//       return createErrorResponse(error, 'generate-scene-tts');
+//     }
+//   }
+// );
+// server.registerTool(
+//   'compile-and-run',
+//   {
+//     title: 'Compile And Run',
+//     description: 'Compile project to ffmpeg command and run it.',
+//     inputSchema: {
+//       projectFileName: z
+//         .string()
+//         .describe('The VideoProject configuration object.'),
+//       outputFileName: z
+//         .string()
+//         .optional()
+//         .describe('Output video filename (optional, defaults to output.mp4).'),
+//     },
+//   },
+//   async ({ projectFileName, outputFileName }) => {
+//     try {
+//       // 验证session状态
+//       const currentSession = await validateSession('compile-and-run');
+//       // 检查字幕内容匹配标记
+//       if (!checkStoryboardSubtitlesFlag) {
+//         checkStoryboardSubtitlesFlag = true;
+//         return createErrorResponse(
+//           `请先对 draft_content 进行以下一致性检查：
+// 1. 检查字幕文字内容是否与 storyboard 中各个场景的 script 或 dialog 内容完全一致（⚠️ 允许字幕分段展示，只要最终文本保持一致就行）
+// 2. 检查视频 resolution 设定是否与 storyboard 的 orientation 设置一致，默认 720p 情况下视频尺寸应为横屏 1280x720，竖屏 720x1280，若视频为 1080p 则尺寸应分别为横屏 1920x1080 和竖屏 1080x1920，切勿设反
+// 3. 除非用户明确表示不要背景音乐，否则应检查是否有生成并配置了 BGM，若无，则生成 BGM 并将其加入素材和轨道配置
+// 以上检查任何一项有问题，先修复 draft_content 使其符合要求后再进行合成`,
+//           'compile-and-run'
+//         );
+//       }
+//       console.log('Starting video compilation and rendering...');
+//       // 验证terminal可用性
+//       const terminal = currentSession.terminal;
+//       if (!terminal) {
+//         throw new Error('Terminal not available in current session');
+//       }
+//       const localProjectFile = resolve(
+//         projectLocalDir,
+//         basename(projectFileName)
+//       );
+//       const project = JSON.parse(await readFile(localProjectFile, 'utf-8'));
+//       // 验证输出文件名安全性
+//       const outFile = outputFileName || project.export.outFile || 'output.mp4';
+//       const validatedFileName = validateFileName(outFile);
+//       console.log(`Output file: ${validatedFileName}`);
+//       // 构建工作目录路径
+//       const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}`;
+//       const outputDir = `${workDir}/output`;
+//       const outputPath = `${outputDir}/${validatedFileName}`;
+//       // Project已经通过zVideoProject schema验证
+//       const validated = { ...project };
+//       // 更新导出配置
+//       validated.export = {
+//         ...validated.export,
+//         outFile: outputPath,
+//       };
+//       console.log('Compiling VideoProject to FFmpeg command...');
+//       // 编译为FFmpeg命令
+//       let compiled: CompileResult;
+//       try {
+//         compiled = await compileToFfmpeg(validated, {
+//           workingDir: outputDir,
+//           subtitleStrategy: 'ass',
+//           subtitlesFileName: `${outFile.replace(/\.mp4$/, '')}.subtitles.ass`,
+//         });
+//       } catch (compileError) {
+//         console.error('Failed to compile VideoProject:', compileError);
+//         throw new Error(`Failed to compile VideoProject: ${compileError}`);
+//       }
+//       console.log(`FFmpeg command generated (${compiled.cmd.length} chars)`);
+//       console.log('FFmpeg Command:', compiled.cmd.substring(0, 200) + '...');
+//       // 执行FFmpeg命令
+//       console.log('Executing FFmpeg command...');
+//       const result = await runFfmpeg(currentSession, compiled);
+//       if (result.exitCode === 0) {
+//         console.log('Video compilation completed successfully');
+//         // 自动下载输出文件
+//         console.log('Starting automatic download of output files...');
+//         let downloadResult = null;
+//         try {
+//           const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}/output`;
+//           let outputs: string[] = [];
+//           try {
+//             outputs = (await currentSession.files.listFiles(workDir)) || [];
+//           } catch (listError) {
+//             console.warn('Failed to list output files:', listError);
+//             outputs = [];
+//           }
+//           if (outputs.length > 0) {
+//             const outputDir = resolve(
+//               process.env.ZEROCUT_PROJECT_CWD || process.cwd(),
+//               projectLocalDir,
+//               'output'
+//             );
+//             await mkdir(outputDir, { recursive: true });
+//             const downloadErrors: string[] = [];
+//             const successfulDownloads: string[] = [];
+//             const promises = outputs.map(async output => {
+//               try {
+//                 await currentSession.files.download(
+//                   `${workDir}/${output}`,
+//                   `${outputDir}/${output}`
+//                 );
+//                 successfulDownloads.push(output);
+//                 return output;
+//               } catch (downloadError) {
+//                 const errorMsg = `Failed to download ${output}: ${downloadError}`;
+//                 console.error(errorMsg);
+//                 downloadErrors.push(errorMsg);
+//                 return null;
+//               }
+//             });
+//             const results = await Promise.all(promises);
+//             const sources = results.filter(
+//               output => output !== null
+//             ) as string[];
+//             downloadResult = {
+//               totalFiles: outputs.length,
+//               successfulDownloads: sources.length,
+//               failedDownloads: downloadErrors.length,
+//               downloadErrors:
+//                 downloadErrors.length > 0 ? downloadErrors : undefined,
+//               downloadPath: outputDir,
+//               sources,
+//             };
+//             console.log(
+//               `Download completed: ${sources.length}/${outputs.length} files successful`
+//             );
+//           } else {
+//             console.log('No output files found to download');
+//             downloadResult = {
+//               totalFiles: 0,
+//               successfulDownloads: 0,
+//               failedDownloads: 0,
+//               message: 'No output files found to download',
+//             };
+//           }
+//         } catch (downloadError) {
+//           console.error('Download process failed:', downloadError);
+//           downloadResult = {
+//             error: `Download failed: ${downloadError}`,
+//             totalFiles: 0,
+//             successfulDownloads: 0,
+//             failedDownloads: 1,
+//           };
+//         }
+//         const successResult = {
+//           success: true,
+//           outputPath,
+//           outputFileName: validatedFileName,
+//           command: compiled.cmd,
+//           message: 'Video compilation and download completed successfully',
+//           download: downloadResult,
+//           timestamp: new Date().toISOString(),
+//         };
+//         return {
+//           content: [
+//             {
+//               type: 'text' as const,
+//               text: JSON.stringify(successResult),
+//             },
+//           ],
+//         };
+//       } else {
+//         console.error(`FFmpeg failed with exit code: ${result.exitCode}`);
+//         const failureResult = {
+//           success: false,
+//           exitCode: result.exitCode,
+//           outputPath,
+//           // command: compiled.cmd,
+//           stderr: result.stderr,
+//           message: `FFmpeg exited with code ${result.exitCode}`,
+//           timestamp: new Date().toISOString(),
+//         };
+//         if (result.exitCode === 254) {
+//           failureResult.message =
+//             'FFmpeg failed with code 254. Close current session immediately (inMinutes = 0) and re-open a new session to try again.';
+//         }
+//         return {
+//           content: [
+//             {
+//               type: 'text' as const,
+//               text: JSON.stringify(failureResult),
+//             },
+//           ],
+//         };
+//       }
+//     } catch (error) {
+//       return createErrorResponse(error, 'compile-and-run');
+//     }
+//   }
+// );
+// server.registerTool(
+//   'get-schema',
+//   {
+//     title: 'Get Storyboard Schema or Draft Content Schema',
+//     description:
+//       'Get the complete Storyboard or Draft Content JSON Schema definition. Use this schema to validate storyboard.json or draft_content.json files.',
+//     inputSchema: {
+//       type: z
+//         .enum(['storyboard', 'draft_content'])
+//         .describe(
+//           'The type of schema to retrieve. Must be either "storyboard" or "draft_content". 用 type: storyboard 的 schema 生成 storyboard.json；用 type: draft_content 的 schema 生成 draft_content.json'
+//         ),
+//     },
+//   },
+//   async ({ type }) => {
+//     try {
+//       const schemaPath = resolve(__dirname, `./prompts/${type}-schema.json`);
+//       const schemaContent = await readFile(schemaPath, 'utf-8');
+//       const schema = JSON.parse(schemaContent);
+//       let important_guidelines = '';
+//       if (type === 'draft_content') {
+//         important_guidelines = `⚠️ 生成文件时请严格遵守输出规范，字幕文本内容必须与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致。
+// ** 字幕优化 **
+//   * 在保证字幕文本内容与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致的前提下，可根据 tts 返回的 \`captions.utterances\` 字段对字幕的显示进行优化，将过长的字幕分段显示，在 draft_content.json 中使用分段字幕，captions 的内容在 media_logs.json 中可查询到。
+//   * 如用户未特殊指定，字幕样式（字体及大小）务必遵守输出规范
+// `;
+//       }
+//       return {
+//         content: [
+//           {
+//             type: 'text' as const,
+//             text: JSON.stringify({
+//               success: true,
+//               schema,
+//               important_guidelines,
+//               timestamp: new Date().toISOString(),
+//             }),
+//           },
+//         ],
+//       };
+//     } catch (error) {
+//       return createErrorResponse(error, 'get-schema');
+//     }
+//   }
+// );
+// server.registerTool(
+//   'pick-voice',
+//   {
+//     title: 'Pick Voice',
+//     description:
+//       '根据用户需求，选择尽可能符合要求的语音，在合适的情况下，优先采用 volcano_tts_2 类型的语音',
+//     inputSchema: {
+//       prompt: z
+//         .string()
+//         .describe('用户需求描述，例如：一个有亲和力的，适合给孩子讲故事的语音'),
+//       custom_design: z
+//         .boolean()
+//         .optional()
+//         .describe(
+//           '是否自定义语音，由于要消耗较多积分，因此**只有用户明确要求自己设计语音**，才将该参数设为true'
+//         ),
+//       custom_design_preview: z
+//         .string()
+//         .optional()
+//         .describe(
+//           '用户自定义语音的预览文本，用于展示自定义语音的效果，只有 custom_design 为 true 时才需要'
+//         ),
+//       custom_design_save_to: z
+//         .string()
+//         .optional()
+//         .describe(
+//           '自定义语音的保存路径，例如：custom_voice.mp3 custom_voice_{id}.mp3'
+//         ),
+//     },
+//   },
+//   async ({
+//     prompt,
+//     custom_design,
+//     custom_design_preview,
+//     custom_design_save_to,
+//   }) => {
+//     try {
+//       // 验证session状态
+//       const currentSession = await validateSession('pick-voice');
+//       const ai = currentSession.ai;
+//       if (custom_design) {
+//         if (!custom_design_preview) {
+//           throw new Error(
+//             'custom_design_preview is required when custom_design is true'
+//           );
+//         }
+//         const data = await currentSession.ai.voiceDesign({
+//           prompt,
+//           previewText: custom_design_preview,
+//         });
+//         if (data.voice_id) {
+//           const trial_audio = data.trial_audio;
+//           let uri = '';
+//           if (trial_audio) {
+//             uri = await saveMaterial(
+//               currentSession,
+//               trial_audio,
+//               custom_design_save_to || `custom_voice_${data.voice_id}.mp3`
+//             );
+//           }
+//           return {
+//             content: [
+//               {
+//                 type: 'text' as const,
+//                 text: JSON.stringify({
+//                   success: true,
+//                   ...data,
+//                   uri,
+//                   timestamp: new Date().toISOString(),
+//                 }),
+//               },
+//             ],
+//           };
+//         } else {
+//           throw new Error(`Voice design failed, ${JSON.stringify(data)}`);
+//         }
+//       }
+//       const data = await ai.pickVoice({ prompt });
+//       return {
+//         content: [
+//           {
+//             type: 'text' as const,
+//             text: JSON.stringify({
+//               success: true,
+//               ...data,
+//               timestamp: new Date().toISOString(),
+//             }),
+//           },
+//         ],
+//       };
+//     } catch (error) {
+//       return createErrorResponse(error, 'pick-voice');
+//     }
+//   }
+// );
+let lastEffect = '';
+server.registerTool('generate-video', {
+    title: 'Generate Video',
+    description: `图生视频和首尾帧生视频工具`,
     inputSchema: {
-        prompt_in_english: zod_1.z
+        prompt: zod_1.z
             .string()
-            .describe('The text prompt to generate sound effect. Must written in English.'),
-        loop: zod_1.z
-            .boolean()
-            .describe('Whether to create a sound effect that loops smoothly. '),
-        duration_seconds: zod_1.z
+            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前场景的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
+        sceneIndex: zod_1.z
             .number()
-            .min(0.5)
-            .max(30)
+            .min(1)
             .optional()
-            .describe('The duration of the sound which will be generated in seconds. Must be at least 0.5 and at most 30. If set to None we will guess the optimal duration using the prompt. Defaults to None.'),
-        saveToFileName: zod_1.z
-            .string()
-            .describe('The filename to save. 应该是mp3文件'),
-    },
-}, async ({ prompt_in_english, loop, saveToFileName, duration_seconds }) => {
-    try {
-        const currentSession = await validateSession('generate-sound-effect');
-        const ai = currentSession.ai;
-        const res = await ai.generateSoundEffect({
-            prompt: prompt_in_english,
-            loop,
-            duration_seconds,
-        });
-        if (res.url) {
-            const uri = await saveMaterial(currentSession, res.url, saveToFileName);
-            // Update media_logs.json
-            try {
-                await updateMediaLogs(currentSession, saveToFileName, res, 'audio');
-            }
-            catch (error) {
-                console.warn(`Failed to update media_logs.json for ${saveToFileName}:`, error);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            uri,
-                            source: res.url,
-                            duration: res.duration,
-                        }),
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(res),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error, 'generate-sound-effect');
-    }
-});
-server.registerTool('generate-music-or-mv', {
-    title: '创作音乐（Music）或音乐视频（Music Video）',
-    description: '生成音乐，包括MV（music video）、BGM 或 歌曲',
-    inputSchema: {
-        prompt: zod_1.z.string().describe('The prompt to generate.'),
-        singerPhoto: zod_1.z
+            .describe('场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'),
+        storyBoardFile: zod_1.z
             .string()
             .optional()
-            .describe('The singer photo to use. 只有type为music_video的时候才生效，也可以不传，模型会自动生成'),
-        mvOrientation: zod_1.z
-            .enum(['portrait', 'landscape'])
+            .default('storyboard.json')
+            .describe('故事板文件路径'),
+        skipConsistencyCheck: zod_1.z
+            .boolean()
             .optional()
-            .describe('The orientation of the music video. Defaults to portrait.')
-            .default('portrait'),
-        mvOriginalSong: zod_1.z
+            .default(false)
+            .describe('是否跳过一致性检查，默认为false（即默认进行一致性检查）'),
+        skipCheckWithSceneReason: zod_1.z
             .string()
             .optional()
-            .describe('用于生成mv的音乐. 只有type为music_video的时候才生效，也可以不传，模型会自动创作'),
-        mvGenSubtitles: zod_1.z
+            .describe('跳过校验的理由，如果skipConsistencyCheck设为true，必须要传这个参数'),
+        type: zod_1.z
+            .enum([
+            'pro',
+            'hailuo',
+            'hailuo-fast',
+            'vidu',
+            'vidu-turbo',
+            'vidu-pro',
+            'vidu-uc',
+            'vidu-uc-pro',
+            'kling',
+            'pixv',
+            'veo3.1',
+            'veo3.1-pro',
+            'kenburns',
+            'zero',
+            'zero-fast',
+        ])
+            .default('vidu')
+            .describe('除非用户明确提出使用其他模型，否则默认用vidu模型；zero 系列模型适合创作8-24秒带故事情节的短片'),
+        mute: zod_1.z
             .boolean()
             .optional()
-            .default(false)
-            .describe('是否生成mv的字幕. 默认为false，只有type为music_video的时候才生效'),
-        type: zod_1.z
-            .enum(['bgm', 'song', 'music_video'])
-            .describe('The type of music. Defaults to BGM. ⚠️ 如果 type 是 music_video，会直接生成音频和视频，**不需要**额外专门生成歌曲')
-            .default('bgm'),
-        model: zod_1.z
-            .enum(['doubao', 'minimax'])
+            .default(true)
+            .describe('Whether to mute the video (effective for vidu,sora2 and veo3.1). 除非用户明确要求，否则默认静音；非静音模式下模型会自己配音，不需要再使用tts工具！'),
+        seed: zod_1.z
+            .number()
             .optional()
-            .describe('The model to use. Defaults to doubao.')
-            .default('doubao'),
+            .describe('The seed to use for random number generation. 用户可以指定一个固定值来获得可重复的结果'),
+        saveToFileName: zod_1.z
+            .string()
+            .describe('The filename to save. 应该是mp4文件'),
+        start_frame: zod_1.z
+            .string()
+            .optional()
+            .describe('The image file name of the start frame.'),
         duration: zod_1.z
             .number()
-            .min(30)
-            .max(240)
-            .describe('The duration of the bgm or music.'),
-        skipCopyCheck: zod_1.z
+            .min(0)
+            .max(30)
+            .describe('The duration of the video. 可以传0，此时会根据视频提示词内容自动确定时长'),
+        end_frame: zod_1.z
+            .string()
+            .optional()
+            .describe('The image file name of the end frame (for non-zero models) or highlight frame (for zero models).'),
+        saveLastFrameAs: zod_1.z
+            .string()
+            .optional()
+            .describe('The filename to save the last frame. 只有用户要求使用镜头自然延伸时，才需要这个参数，默认不传'),
+        resolution: zod_1.z
+            .enum(['720p', '1080p'])
+            .optional()
+            .default('720p')
+            .describe('除非用户明确提出使用其他分辨率，否则一律用720p'),
+        optimizePrompt: zod_1.z
             .boolean()
+            .optional()
             .default(false)
-            .describe('Whether to skip copyright check.'),
-        saveToFileName: zod_1.z
-            .string()
-            .describe('The filename to save. 如果type是music video，应该是mp4文件，否则应该是mp3文件'),
+            .describe('Whether to optimize the prompt.'),
     },
-}, async ({ prompt, singerPhoto, mvOrientation, mvOriginalSong, mvGenSubtitles, type, model, duration, skipCopyCheck, saveToFileName, }, context) => {
+}, async ({ prompt, sceneIndex, storyBoardFile = 'storyboard.json', skipConsistencyCheck = false, saveToFileName, start_frame, end_frame, duration, resolution, type = 'vidu', optimizePrompt, saveLastFrameAs, mute = true, seed, }, context) => {
     try {
         // 验证session状态
-        const currentSession = await validateSession('generate-music');
-        const validatedFileName = validateFileName(saveToFileName);
-        console.log(`Generating Music with prompt: ${prompt.substring(0, 100)}... (${duration}s)`);
-        const ai = currentSession.ai;
-        let progress = 0;
-        if (type === 'bgm' && duration > 120) {
-            throw new Error('BGM duration must be at most 120 seconds.');
+        const currentSession = await validateSession('generate-video');
+        const isZeroModel = type.startsWith('zero');
+        if (!start_frame && !isZeroModel) {
+            return createErrorResponse('start_frame 不能为空', 'generate-video');
         }
-        let res;
-        if (type === 'music_video') {
-            const singer_photo = singerPhoto
-                ? await getMaterialUri(currentSession, singerPhoto)
-                : undefined;
-            const original_song = mvOriginalSong
-                ? await getMaterialUri(currentSession, mvOriginalSong)
-                : undefined;
-            res = await ai.generateZeroCutMusicVideo({
-                // prompt: `${prompt.trim()} 音乐时长${duration}秒`,
-                prompt,
-                singerPhoto: singer_photo,
-                orientation: mvOrientation,
-                genSubtitles: mvGenSubtitles,
-                originalSong: original_song,
-                duration,
-                resolution: '720p',
-                onProgress: async (metaData) => {
+        if (!isZeroModel && duration > 16) {
+            return createErrorResponse('非 zero 系列模型的视频仅支持 16 秒以下时长', 'generate-video');
+        }
+        else if (isZeroModel && duration < 8) {
+            return createErrorResponse('zero 系列模型的视频仅支持 8 秒以上时长', 'generate-video');
+        }
+        if (type === 'zero-fast' && duration > 24) {
+            return createErrorResponse('zero-fast 模型的视频仅支持 24 秒以下时长', 'generate-video');
+        }
+        if (type === 'zero' && resolution !== '1080p') {
+            console.warn(`zero 模型的视频仅支持 1080p 分辨率，用户指定的分辨率为 %s，已自动将 ${resolution} 转换为 1080p`, resolution);
+            resolution = '1080p';
+        }
+        // 校验 prompt 与 storyboard.json 中场景设定的一致性以及视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
+        if (sceneIndex && !skipConsistencyCheck) {
+            try {
+                const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
+                if ((0, node_fs_1.existsSync)(storyBoardPath)) {
+                    const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
+                    // 检查 storyBoard JSON 语法合法性
+                    let storyBoard;
                     try {
-                        await sendProgress(context, metaData.Result?.Progress ?? ++progress, metaData.Result?.Progress ? 100 : undefined, JSON.stringify(metaData));
+                        storyBoard = JSON.parse(storyBoardContent);
+                    }
+                    catch (jsonError) {
+                        return createErrorResponse(`storyBoard 文件 ${storyBoardFile} 存在 JSON 语法错误，请修复后重试。错误详情: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`, 'generate-video');
+                    }
+                    if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
+                        const scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
+                        if (scene) {
+                            const videoPrompt = scene.video_prompt;
+                            if (videoPrompt && prompt !== videoPrompt) {
+                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                            }
+                            if (scene.is_continuous && !end_frame) {
+                                return createErrorResponse('连续场景必须指定end_frame参数，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                            }
+                            if (scene.video_duration != null &&
+                                duration !== scene.video_duration) {
+                                return createErrorResponse(`视频时长必须严格遵照storyboard的设定，用户指定的时长为 ${duration} 秒，而 storyboard 中建议的时长为 ${scene.video_duration} 秒。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用`, 'generate-video');
+                            }
+                            if (storyBoard.voice_type &&
+                                storyBoard.voice_type !== 'slient') {
+                                if (mute) {
+                                    return createErrorResponse('有对话和旁白的场景不能静音，请将mute设为false再重新使用工具。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                                }
+                            }
+                            // 检查 use_video_model 与 type 参数的一致性
+                            if (scene.use_video_model &&
+                                type &&
+                                scene.use_video_model !== type) {
+                                return createErrorResponse(`场景建议的视频模型(${scene.use_video_model})与传入的type参数(${type})不一致。请确保use_video_model与type参数值相同，或将skipConsistencyCheck设置为true后再次调用`, 'generate-video');
+                            }
+                        }
+                        else {
+                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
+                        }
                     }
-                    catch (progressError) {
-                        console.warn('Failed to send progress update:', progressError);
+                }
+                else {
+                    console.warn(`Story board file not found: ${storyBoardPath}`);
+                }
+            }
+            catch (error) {
+                console.error('Failed to validate prompt with story board:', error);
+                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
+            }
+            // 校验视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
+            try {
+                const timelineAnalysisPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'timeline_analysis.json');
+                if ((0, node_fs_1.existsSync)(timelineAnalysisPath)) {
+                    const timelineAnalysisContent = await (0, promises_1.readFile)(timelineAnalysisPath, 'utf8');
+                    const timelineAnalysis = JSON.parse(timelineAnalysisContent);
+                    if (timelineAnalysis.proposed_video_scenes &&
+                        Array.isArray(timelineAnalysis.proposed_video_scenes)) {
+                        const videoScene = timelineAnalysis.proposed_video_scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
+                        if (videoScene && videoScene.video_duration_s) {
+                            const expectedDuration = videoScene.video_duration_s;
+                            if (duration !== expectedDuration) {
+                                return createErrorResponse(`视频时长必须与timeline_analysis中的设定匹配。当前场景${videoScene.scene_id}要求时长为${expectedDuration}秒，但传入的duration为${duration}秒。请调整duration参数为${expectedDuration}秒后重试。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用。`, 'generate-video');
+                            }
+                        }
+                        else {
+                            console.warn(`Scene ${sceneIndex} (scene_${sceneIndex.toString().padStart(2, '0')}) not found in timeline_analysis.json proposed_video_scenes`);
+                        }
                     }
-                },
-                waitForFinish: false,
-            });
-        }
-        else {
-            const finalPrompt = `${prompt.trim()} ${type === 'bgm' ? `纯音乐无歌词，时长${duration}秒` : `时长${duration}秒，使用${model}模型`}`;
-            res = await ai.generateMusic({
-                prompt: finalPrompt,
-                skipCopyCheck,
-                onProgress: async (metaData) => {
+                }
+                else {
+                    // 检查音频时长标志
                     try {
-                        await sendProgress(context, metaData.Result?.Progress ?? ++progress, metaData.Result?.Progress ? 100 : undefined, JSON.stringify(metaData));
+                        const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
+                        if ((0, node_fs_1.existsSync)(storyBoardPath)) {
+                            const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
+                            const storyBoard = JSON.parse(storyBoardContent);
+                            if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
+                                const scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
+                                if (scene &&
+                                    ((scene.script && scene.script.trim() !== '') ||
+                                        scene.dialog)) {
+                                    if (!checkAudioVideoDurationFlag) {
+                                        checkAudioVideoDurationFlag = true;
+                                        if (scene.audio_mode === 'vo_sync') {
+                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长为音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
+                                        }
+                                        else if (scene.audio_mode === 'dialogue') {
+                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长**不小于**音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
-                    catch (progressError) {
-                        console.warn('Failed to send progress update:', progressError);
+                    catch (error) {
+                        console.error('Failed to check audio duration flag:', error);
                     }
-                },
-            });
-        }
-        if (!res) {
-            throw new Error('Failed to generate Music: no response from AI service');
-        }
-        if (res.url) {
-            console.log('Music generated successfully, saving to materials...');
-            const uri = await saveMaterial(currentSession, res.url, validatedFileName);
-            const { url, duration: bgmDuration, captions, ...opts } = res;
-            // 保存captions到本地
-            if (captions) {
-                const captionsText = JSON.stringify(captions, null, 2);
-                // 本地路径
-                const localPath = node_path_1.default.resolve(projectLocalDir, 'materials', `${validatedFileName}.captions.json`);
-                // 保存到本地
-                await (0, promises_1.writeFile)(localPath, captionsText);
+                }
             }
-            const result = {
-                success: true,
-                // source: url,
-                uri,
-                durationMs: Math.floor((bgmDuration || duration) * 1000),
-                prompt,
-                captions,
-                requestedDuration: duration,
-                timestamp: new Date().toISOString(),
-                ...opts,
-            };
-            // Update media_logs.json
+            catch (error) {
+                console.error('Failed to validate duration with timeline analysis:', error);
+                // 如果读取或解析 timeline_analysis.json 失败，继续执行但记录警告
+            }
+        }
+        const validatedFileName = validateFileName(saveToFileName);
+        console.log(`Generating video with prompt: ${prompt.substring(0, 100)}...`);
+        const ai = currentSession.ai;
+        let progress = 0;
+        const startFrameUri = start_frame
+            ? getMaterialUri(currentSession, start_frame)
+            : undefined;
+        const endFrameUri = end_frame
+            ? getMaterialUri(currentSession, end_frame)
+            : undefined;
+        if (optimizePrompt) {
             try {
-                await updateMediaLogs(currentSession, validatedFileName, result, 'audio');
+                const promptOptimizer = await (0, promises_1.readFile)((0, node_path_1.resolve)(__dirname, './prompts/video-prompt-optimizer.md'), 'utf8');
+                const completion = await ai.getCompletions({
+                    messages: [
+                        {
+                            role: 'system',
+                            content: promptOptimizer,
+                        },
+                        {
+                            role: 'user',
+                            content: prompt.trim(),
+                        },
+                    ],
+                });
+                const optimizedPrompt = completion.choices[0]?.message?.content;
+                if (optimizedPrompt) {
+                    prompt = optimizedPrompt;
+                }
             }
             catch (error) {
-                console.warn('Failed to update media_logs.json:', error);
+                console.error('Failed to optimize prompt:', error);
             }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result),
-                    },
-                ],
-            };
         }
-        else if (res.taskUrl) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: '该视频生成任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
-                            taskUrl: res.taskUrl,
-                        }),
+        if (type === 'kenburns') {
+            // 实现 getImageSize 函数
+            async function getImageSize(imageUri) {
+                // imageUri 是一个可以 http 访问的图片
+                // eslint-disable-next-line custom/no-fetch-in-src
+                const response = await fetch(imageUri);
+                const arrayBuffer = await response.arrayBuffer();
+                const buffer = Buffer.from(arrayBuffer);
+                const image = (0, image_size_1.default)(buffer);
+                return [image.width, image.height];
+            }
+            const [imageWidth, imageHeight] = await getImageSize(startFrameUri);
+            const kenburnsPrompt = `根据用户描述和配置，生成适合的 kenburns 动画参数。
+
+## 配置信息
+- 视频时长：${duration}秒
+- 分辨率：${resolution}
+- 保存最后一帧：${saveLastFrameAs ? '是' : '否'}
+- 图片宽高：${imageWidth}x${imageHeight}
+- 上一次选择的特效：${lastEffect || '无'}
+
+## camera_motion 可选特效
+- zoom_in
+- zoom_out
+- zoom_in_left_top
+- zoom_out_left_top
+- zoom_in_right_top
+- zoom_out_right_top
+- zoom_in_left_bottom
+- zoom_out_left_bottom
+- zoom_in_right_bottom
+- zoom_out_right_bottom
+- pan_up
+- pan_down
+- pan_left
+- pan_right
+- static
+
+## 特效选用规则
+- 视频时长6秒内：优先选择zoom类型(zoom_in, zoom_out)
+- 视频时长6秒以上：优先选择pan类型(pan_left, pan_right, pan_up, pan_down)
+- 除非用户指定，否则不要主动使用 static 效果
+- 除非用户指定，否则不要和上一次选择的效果重复
+`;
+            const schema = {
+                name: 'kenburns_effect',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        camera_motion: {
+                            type: 'string',
+                            description: 'kenburns 特效类型',
+                            enum: [
+                                'zoom_in',
+                                'zoom_out',
+                                'zoom_in_left_top',
+                                'zoom_out_left_top',
+                                'zoom_in_right_top',
+                                'zoom_out_right_top',
+                                'zoom_in_left_bottom',
+                                'zoom_out_left_bottom',
+                                'zoom_in_right_bottom',
+                                'zoom_out_right_bottom',
+                                'pan_up',
+                                'pan_down',
+                                'pan_left',
+                                'pan_right',
+                                'static',
+                            ],
+                        },
+                        size: {
+                            type: 'string',
+                            description: 'kenburns 视频 宽x高',
+                        },
+                        duration: {
+                            type: 'number',
+                            description: 'kenburns 视频 时长',
+                        },
                     },
-                ],
+                    required: ['camera_motion', 'size', 'duration'],
+                },
             };
-        }
-        else {
-            console.warn('Music generation completed but no URL returned');
-            return {
-                content: [
+            const analysisPayload = {
+                model: 'Doubao-Seed-1.6-flash',
+                messages: [
                     {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: 'No Music URL returned from AI service',
-                            response: res,
-                            timestamp: new Date().toISOString(),
-                        }),
+                        role: 'system',
+                        content: kenburnsPrompt,
+                    },
+                    {
+                        role: 'user',
+                        content: prompt.trim(),
                     },
                 ],
+                response_format: {
+                    type: 'json_schema',
+                    json_schema: schema,
+                },
             };
-        }
-    }
-    catch (error) {
-        return createErrorResponse(error, 'generate-music');
-    }
-});
-server.registerTool('generate-scene-tts', {
-    title: 'Generate Scene TTS',
-    description: `生成场景配音`,
-    inputSchema: {
-        text: zod_1.z.string().describe('The text to generate.'),
-        sceneIndex: zod_1.z
-            .number()
-            .min(1)
-            .optional()
-            .describe('场景索引，从1开始的下标，如果非场景对应素材，则可不传，场景素材必传'),
-        storyBoardFile: zod_1.z
-            .string()
-            .optional()
-            .default('storyboard.json')
-            .describe('故事板文件路径'),
-        skipConsistencyCheck: zod_1.z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe('是否跳过一致性检查，默认为false（即默认进行一致性检查）'),
-        skipCheckWithSceneReason: zod_1.z
-            .string()
-            .optional()
-            .describe('跳过校验的理由，如果skipConsistencyCheck设为true，必须要传这个参数'),
-        saveToFileName: zod_1.z
-            .string()
-            .describe('The filename to save. 应该是mp3文件'),
-        speed: zod_1.z
-            .number()
-            .min(0.5)
-            .max(2)
-            .optional()
-            .default(1)
-            .describe('The speed of the tts.'),
-        pitch: zod_1.z
-            .number()
-            .min(-12)
-            .max(12)
-            .optional()
-            .default(0)
-            .describe('The pitch of the tts.'),
-        volume: zod_1.z
-            .number()
-            .min(0)
-            .max(10)
-            .optional()
-            .default(1.0)
-            .describe('The volume of the tts.'),
-        voiceID: zod_1.z
-            .string()
-            .describe(`适合作为视频配音的音色ID，除非用户指定，否则你必须确保已通过 pick-voice 工具挑选出真实存在的音色。`),
-        context_texts: zod_1.z
-            .array(zod_1.z.string())
-            .default([])
-            .describe(`语音合成的辅助信息，用于模型对话式合成，能更好的体现语音情感
-
-可以探索，比如常见示例有以下几种：
-
-1. 语速调整
-  - context_texts: ["你可以说慢一点吗？"]
-2. 情绪/语气调整
-  - context_texts=["你可以用特别特别痛心的语气说话吗?"]
-  - context_texts=["嗯，你的语气再欢乐一点"]
-3. 音量调整
-  - context_texts=["你嗓门再小点。"]
-4. 音感调整
-  - context_texts=["你能用骄傲的语气来说话吗？"]
-`),
-        explicit_language: zod_1.z.enum(['zh', 'en', 'ja']).optional().default('zh'),
-    },
-}, async ({ text, sceneIndex, storyBoardFile, skipConsistencyCheck, voiceID, saveToFileName, speed, pitch, volume, context_texts, explicit_language, }) => {
-    try {
-        // 验证session状态
-        const currentSession = await validateSession('generate-scene-tts');
-        const validatedFileName = validateFileName(saveToFileName);
-        const finalSpeed = speed ?? 1;
-        volume = volume ?? 1;
-        const ai = currentSession.ai;
-        let scene = null;
-        // 校验 text 与 storyboard.json 中场景设定的一致性
-        if (sceneIndex && !skipConsistencyCheck) {
+            console.log(JSON.stringify(analysisPayload, null, 2));
+            const completion = await ai.getCompletions(analysisPayload);
+            const analysisResult = completion.choices[0]?.message?.content;
+            if (!analysisResult) {
+                throw new Error('Failed to generate kenburns effect');
+            }
             try {
-                const voice = (await ai.listVoices()).find(v => v.id === voiceID);
-                if (!voice) {
-                    return createErrorResponse(`Voice ${voiceID} not found in voice-list. Use pick-voice tool to pick an available voice. 若用户坚持要使用该音色，需跳过一致性检查。`, 'generate-scene-tts');
+                const kenburnsEffect = JSON.parse(analysisResult);
+                const { camera_motion, size, duration } = kenburnsEffect;
+                if (!camera_motion || !size || !duration) {
+                    throw new Error('Invalid kenburns effect parameters');
                 }
-                const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
-                if ((0, node_fs_1.existsSync)(storyBoardPath)) {
-                    const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
-                    // 检查 storyBoard JSON 语法合法性
-                    let storyBoard;
-                    try {
-                        storyBoard = JSON.parse(storyBoardContent);
-                    }
-                    catch (jsonError) {
-                        return createErrorResponse(`storyBoard 文件 ${storyBoardFile} 存在 JSON 语法错误，请修复后重试。错误详情: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`, 'generate-scene-tts');
-                    }
-                    if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
-                        scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-                        if (scene) {
-                            const script = scene.script;
-                            let isValidText = false;
-                            // 检查 text 是否严格等于 script
-                            if (script && text === script) {
-                                isValidText = true;
-                            }
-                            // 检查 text 是否严格等于 dialog 数组中某个元素的 script
-                            if (!isValidText &&
-                                scene.dialog &&
-                                Array.isArray(scene.dialog)) {
-                                for (const dialogItem of scene.dialog) {
-                                    if (dialogItem.script && text === dialogItem.script) {
-                                        isValidText = true;
-                                        break;
-                                    }
-                                }
-                            }
-                            if (!isValidText) {
-                                return createErrorResponse('配音文本必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-scene-tts');
-                            }
-                        }
-                        else {
-                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
-                        }
-                    }
+                lastEffect = camera_motion;
+                const files = currentSession.files;
+                const terminal = currentSession.terminal;
+                start_frame = (0, node_path_1.resolve)('/home/user/cerevox-zerocut/projects', terminal.id, 'materials', (0, node_path_1.basename)(start_frame));
+                const saveToPath = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials/${validatedFileName}`;
+                const saveLocalPath = (0, node_path_1.resolve)(projectLocalDir, 'materials', validatedFileName);
+                // 解析尺寸参数
+                const sizeArray = size.split('x');
+                if (sizeArray.length !== 2) {
+                    throw new Error(`Invalid size format: ${size}. Expected format: WIDTHxHEIGHT`);
                 }
-                else {
-                    console.warn(`Story board file not found: ${storyBoardPath}`);
+                const [widthStr, heightStr] = sizeArray;
+                const width = Number(widthStr);
+                const height = Number(heightStr);
+                if (isNaN(width) || isNaN(height) || width <= 0 || height <= 0) {
+                    throw new Error(`Invalid dimensions: ${width}x${height}. Both width and height must be positive numbers`);
                 }
-            }
-            catch (error) {
-                console.error('Failed to validate text with story board:', error);
-                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
-            }
-        }
-        console.log(`Generating TTS with voice: ${voiceID}, speed: ${finalSpeed}, text: ${text.substring(0, 100)}...`);
-        if (voiceID.startsWith('BV0')) {
-            throw new Error(`BV0* 系列音色已弃用，你必须通过 pick-voice 工具挑选一个真实存在的音色。`);
-        }
-        const type = voiceID.startsWith('zh_') ||
-            voiceID.startsWith('en_') ||
-            voiceID.startsWith('multi_') ||
-            voiceID.startsWith('saturn_') ||
-            voiceID.startsWith('ICL_')
-            ? 'volcano'
-            : 'minimax';
-        let res;
-        let emotion = 'auto';
-        if (type === 'volcano') {
-            volume = Math.max(Math.min(volume, 2.0), 0.5);
-            res = await ai.textToSpeechVolc({
-                text: text.trim(),
-                speaker: voiceID,
-                speed: Math.floor(100 * (finalSpeed - 1)),
-                volume: Math.floor(100 * (volume - 1)),
-                context_texts,
-                explicit_language,
-                voice_to_caption: explicit_language === 'zh' || explicit_language === 'en',
-            });
-        }
-        else {
-            emotion = 'neutral';
-            if (context_texts.length > 0) {
-                const prompt = `根据用户输入语音内容和上下文内容，从文字判断语音合理的情感，然后选择以下情感**之一**返回结果：
-
-"happy", "sad", "angry", "fearful", "disgusted", "surprised", "calm", "fluent", "whisper", "neutral"
-
-## 要求
-输出 JSON 格式，包含一个 emotion 字段，值为以上情感之一。
-`;
-                const schema = {
-                    name: 'emotion_schema',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            emotion: {
-                                type: 'string',
-                                enum: [
-                                    'neutral',
-                                    'happy',
-                                    'sad',
-                                    'angry',
-                                    'fearful',
-                                    'disgusted',
-                                    'surprised',
-                                    'calm',
-                                    'fluent',
-                                    'whisper',
-                                ],
-                                description: '用户输入语音的情感',
+                console.log(`Compiling Ken Burns motion command...`);
+                let command;
+                try {
+                    command = await (0, videokit_1.compileKenBurnsMotion)(start_frame, duration, camera_motion, {
+                        output: saveToPath,
+                        width,
+                        height,
+                    });
+                }
+                catch (compileError) {
+                    console.error('Failed to compile Ken Burns motion command:', compileError);
+                    throw new Error(`Failed to compile Ken Burns motion: ${compileError}`);
+                }
+                console.log(`Executing FFmpeg command: ${command.substring(0, 100)}...`);
+                const res = await terminal.run(command);
+                const result = await res.json();
+                if (result.exitCode !== 0) {
+                    console.error('FFmpeg command failed:', result);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: 'Ken Burns motion generation failed',
+                                    exitCode: result.exitCode,
+                                    stderr: result.stderr,
+                                    command,
+                                    timestamp: new Date().toISOString(),
+                                }),
                             },
-                        },
-                        required: ['emotion'],
-                    },
+                        ],
+                    };
+                }
+                console.log('Ken Burns motion generated successfully, downloading file...');
+                try {
+                    await files.download(saveToPath, saveLocalPath);
+                }
+                catch (downloadError) {
+                    console.warn('Failed to download file to local:', downloadError);
+                    // 继续执行，因为远程文件已生成成功
+                }
+                const resultData = {
+                    success: true,
+                    uri: saveToPath,
+                    durationMs: Math.floor(duration * 1000),
+                    cameraMotion: camera_motion,
+                    imagePath: start_frame,
+                    size,
+                    dimensions: { width, height },
+                    timestamp: new Date().toISOString(),
+                    systemPrompt: kenburnsPrompt,
                 };
-                const payload = {
-                    model: 'Doubao-Seed-1.6',
-                    messages: [
-                        {
-                            role: 'system',
-                            content: prompt,
-                        },
+                console.log(`Ken Burns motion completed: ${saveToPath}`);
+                currentSession.track('KenBurns Video Generated', {
+                    durationMs: Math.floor(duration * 1000).toString(),
+                    cameraMotion: camera_motion,
+                    imagePath: start_frame,
+                    size,
+                    dimensions: size,
+                });
+                return {
+                    content: [
                         {
-                            role: 'user',
-                            content: `## 语音内容：
-${text.trim()}
-
-## 语音上下文
-${context_texts.join('\n')}
-`,
+                            type: 'text',
+                            text: JSON.stringify(resultData),
                         },
                     ],
-                    response_format: {
-                        type: 'json_schema',
-                        json_schema: schema,
-                    },
                 };
-                const completion = await ai.getCompletions(payload);
-                const emotionObj = JSON.parse(completion.choices[0]?.message?.content ?? '{}');
-                emotion = emotionObj.emotion ?? 'neutral';
             }
-            res = await ai.textToSpeech({
-                text: text.trim(),
-                voiceName: voiceID,
-                speed: finalSpeed,
-                pitch,
-                volume,
-                emotion,
-                voice_to_caption: explicit_language === 'zh' || explicit_language === 'en',
-            });
+            catch (error) {
+                throw new Error('Failed to parse kenburns effect parameters');
+            }
         }
+        const res = await ai.framesToVideo({
+            prompt: prompt.trim(),
+            start_frame: startFrameUri,
+            end_frame: endFrameUri,
+            duration,
+            resolution,
+            type,
+            return_last_frame: Boolean(saveLastFrameAs),
+            onProgress: async (metaData) => {
+                try {
+                    await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
+                }
+                catch (progressError) {
+                    console.warn('Failed to send progress update:', progressError);
+                }
+            },
+            waitForFinish: type !== 'zero',
+            mute,
+            seed,
+        });
         if (!res) {
-            throw new Error('Failed to generate TTS: no response from AI service');
+            throw new Error('Failed to generate video: no response from AI service');
         }
         if (res.url) {
-            console.log('TTS generated successfully, saving to materials...');
-            const { url, duration, ...opts } = res;
-            if (!skipConsistencyCheck && duration > 16) {
-                return createErrorResponse('TTS duration exceeds 16 seconds, 建议调整文本长度、提升语速或拆分场景...，⚠️如简化文本内容或拆分文本，需要立即更新 storyboard 以保持内容同步！如仍要生成，可设置 skipConsistencyCheck 为 true，跳过一致性检查。', 'generate-scene-tts');
-            }
-            if (!duration) {
-                return createErrorResponse('TTS duration not returned from AI service', 'generate-scene-tts');
-            }
-            const uri = await saveMaterial(currentSession, url, validatedFileName);
-            let warn = '';
-            if (scene) {
-                const minDur = Math.ceil(duration);
-                if (scene.audio_mode === 'vo_sync' && scene.duration !== minDur) {
-                    warn = `场景${sceneIndex}设定的时长${scene.duration}秒与实际生成的语音时长${minDur}秒不一致，音画同步将有问题，建议修改场景时长为${minDur}秒`;
-                }
-                else if (scene.duration < minDur) {
-                    warn = `场景${sceneIndex}设定的时长${scene.duration}秒小于实际生成的语音时长${duration}秒，可能会导致场景结束时音频未播放完成，建议修改场景时长为${minDur}秒`;
-                }
+            console.log('Video generated successfully, saving to materials...');
+            const uri = await saveMaterial(currentSession, res.url, validatedFileName);
+            let lastFrameUri;
+            if (saveLastFrameAs && res.last_frame_url) {
+                lastFrameUri = await saveMaterial(currentSession, res.last_frame_url, validateFileName(saveLastFrameAs));
             }
+            const { url, duration: videoDuration, ...opts } = res;
             const result = {
                 success: true,
-                warn,
-                source: url, // 方便调试
+                // source: url,
                 uri,
-                durationMs: Math.floor((duration || 0) * 1000),
-                text,
-                emotion,
-                context_texts,
-                voiceName: voiceID,
-                speed: finalSpeed,
+                lastFrameUri,
+                durationMs: Math.floor((videoDuration || duration) * 1000),
+                prompt,
                 timestamp: new Date().toISOString(),
+                startFrame: start_frame,
+                endFrame: end_frame,
                 ...opts,
             };
             // Update media_logs.json
             try {
-                await updateMediaLogs(currentSession, validatedFileName, result, 'audio');
+                await updateMediaLogs(currentSession, validatedFileName, result);
             }
             catch (error) {
                 console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
@@ -2825,21 +3130,36 @@ ${context_texts.join('\n')}
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify(result),
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        else if (res.taskUrl) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: '该视频生成任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
+                            taskUrl: res.taskUrl,
+                        }),
                     },
                 ],
             };
         }
         else {
-            console.warn('TTS generation completed but no URL returned');
+            console.warn('Video generation completed but no URL returned');
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: 'No TTS URL returned from AI service. You should use pick-voice tool to pick an available voice.',
+                            error: 'No video URL returned from AI service',
                             response: res,
+                            startFrameUri,
                             timestamp: new Date().toISOString(),
                         }),
                     },
@@ -2848,294 +3168,139 @@ ${context_texts.join('\n')}
         }
     }
     catch (error) {
-        return createErrorResponse(error, 'generate-scene-tts');
+        return createErrorResponse(error, 'generate-video');
     }
 });
-server.registerTool('compile-and-run', {
-    title: 'Compile And Run',
-    description: 'Compile project to ffmpeg command and run it.',
+server.registerTool('edit-video', {
+    title: 'Edit Video',
+    description: `Edit video using Coze workflow，可以做以下事情：
+
+- 替换视频内容，type 为 replace
+- 视频对口型，type 为 lipsync
+- 视频动作模仿，type 为 imitate
+`,
     inputSchema: {
-        projectFileName: zod_1.z
-            .string()
-            .describe('The VideoProject configuration object.'),
-        outputFileName: zod_1.z
+        type: zod_1.z
+            .enum(['replace', 'lipsync', 'imitate'])
+            .describe('The editing type'),
+        video: zod_1.z.string().describe(`The video to edit
+
+- type 为 replace 时，video 为要替换内容的视频
+- type 为 lipsync 时，video 为要对口型的视频 
+- type 为 imitate 时，video 为模仿动作参考视频
+`),
+        prompt: zod_1.z.string().optional().describe(`The editing prompt
+
+- type 为 replace 时，prompt 为要替换的内容
+- type 为 lipsync 时，prompt 为空
+- type 为 imitate 时，prompt 为要模仿动作的内容，和 referenceImageUrl 二选一
+`),
+        referenceImage: zod_1.z.string().optional()
+            .describe(`The reference image File for editing
+- type 为 replace 时，referenceImage 为参考图片
+- type 为 lipsync 时，referenceImage 为空
+- type 为 imitate 时，referenceImage 为要模仿动作的画面，和 prompt 二选一
+`),
+        saveToFileName: zod_1.z
             .string()
-            .optional()
-            .describe('Output video filename (optional, defaults to output.mp4).'),
+            .describe(`The file name to save the edited video to. 应该是mp4文件`),
     },
-}, async ({ projectFileName, outputFileName }) => {
+}, async ({ type, video, prompt, referenceImage, saveToFileName }, context) => {
     try {
-        // 验证session状态
-        const currentSession = await validateSession('compile-and-run');
-        // 检查字幕内容匹配标记
-        if (!checkStoryboardSubtitlesFlag) {
-            checkStoryboardSubtitlesFlag = true;
-            return createErrorResponse(`请先对 draft_content 进行以下一致性检查：
-          
-1. 检查字幕文字内容是否与 storyboard 中各个场景的 script 或 dialog 内容完全一致（⚠️ 允许字幕分段展示，只要最终文本保持一致就行）
-2. 检查视频 resolution 设定是否与 storyboard 的 orientation 设置一致，默认 720p 情况下视频尺寸应为横屏 1280x720，竖屏 720x1280，若视频为 1080p 则尺寸应分别为横屏 1920x1080 和竖屏 1080x1920，切勿设反
-3. 除非用户明确表示不要背景音乐，否则应检查是否有生成并配置了 BGM，若无，则生成 BGM 并将其加入素材和轨道配置
-
-以上检查任何一项有问题，先修复 draft_content 使其符合要求后再进行合成`, 'compile-and-run');
-        }
-        console.log('Starting video compilation and rendering...');
-        // 验证terminal可用性
-        const terminal = currentSession.terminal;
-        if (!terminal) {
-            throw new Error('Terminal not available in current session');
-        }
-        const localProjectFile = (0, node_path_1.resolve)(projectLocalDir, (0, node_path_1.basename)(projectFileName));
-        const project = JSON.parse(await (0, promises_1.readFile)(localProjectFile, 'utf-8'));
-        // 验证输出文件名安全性
-        const outFile = outputFileName || project.export.outFile || 'output.mp4';
-        const validatedFileName = validateFileName(outFile);
-        console.log(`Output file: ${validatedFileName}`);
-        // 构建工作目录路径
-        const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}`;
-        const outputDir = `${workDir}/output`;
-        const outputPath = `${outputDir}/${validatedFileName}`;
-        // Project已经通过zVideoProject schema验证
-        const validated = { ...project };
-        // 更新导出配置
-        validated.export = {
-            ...validated.export,
-            outFile: outputPath,
+        const currentSession = await validateSession('edit-video');
+        const ai = currentSession.ai;
+        const validatedFileName = validateFileName(saveToFileName);
+        let res = {};
+        let progress = 0;
+        const onProgress = async (metaData) => {
+            console.log('Replace video progress:', metaData);
+            try {
+                await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
+            }
+            catch (progressError) {
+                console.warn('Failed to send progress update:', progressError);
+            }
         };
-        console.log('Compiling VideoProject to FFmpeg command...');
-        // 编译为FFmpeg命令
-        let compiled;
-        try {
-            compiled = await (0, videokit_1.compileToFfmpeg)(validated, {
-                workingDir: outputDir,
-                subtitleStrategy: 'ass',
-                subtitlesFileName: `${outFile.replace(/\.mp4$/, '')}.subtitles.ass`,
+        let referenceImageUrl = undefined;
+        if (referenceImage) {
+            referenceImageUrl = getMaterialUri(currentSession, referenceImage);
+        }
+        const videoUrl = getMaterialUri(currentSession, video);
+        if (type === 'replace') {
+            if (!prompt) {
+                throw new Error('prompt is required for replace type');
+            }
+            res = await ai.editVideo({
+                videoUrl,
+                prompt,
+                referenceImageUrl,
+                onProgress,
             });
         }
-        catch (compileError) {
-            console.error('Failed to compile VideoProject:', compileError);
-            throw new Error(`Failed to compile VideoProject: ${compileError}`);
+        else if (type === 'lipsync') {
+            // 调用AI的lipSync方法，使用处理后的音频
+            const { audio: audioUrl } = await ai.splitVideoAndAudio({
+                videoUrl,
+            });
+            res = await ai.lipSync({
+                type: 'pixv',
+                videoUrl,
+                audioUrl,
+                audioInMs: 0,
+                pad_audio: false,
+                onProgress,
+            });
         }
-        console.log(`FFmpeg command generated (${compiled.cmd.length} chars)`);
-        console.log('FFmpeg Command:', compiled.cmd.substring(0, 200) + '...');
-        // 执行FFmpeg命令
-        console.log('Executing FFmpeg command...');
-        const result = await runFfmpeg(currentSession, compiled);
-        if (result.exitCode === 0) {
-            console.log('Video compilation completed successfully');
-            // 自动下载输出文件
-            console.log('Starting automatic download of output files...');
-            let downloadResult = null;
-            try {
-                const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}/output`;
-                let outputs = [];
-                try {
-                    outputs = (await currentSession.files.listFiles(workDir)) || [];
-                }
-                catch (listError) {
-                    console.warn('Failed to list output files:', listError);
-                    outputs = [];
-                }
-                if (outputs.length > 0) {
-                    const outputDir = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'output');
-                    await (0, promises_1.mkdir)(outputDir, { recursive: true });
-                    const downloadErrors = [];
-                    const successfulDownloads = [];
-                    const promises = outputs.map(async (output) => {
-                        try {
-                            await currentSession.files.download(`${workDir}/${output}`, `${outputDir}/${output}`);
-                            successfulDownloads.push(output);
-                            return output;
-                        }
-                        catch (downloadError) {
-                            const errorMsg = `Failed to download ${output}: ${downloadError}`;
-                            console.error(errorMsg);
-                            downloadErrors.push(errorMsg);
-                            return null;
-                        }
-                    });
-                    const results = await Promise.all(promises);
-                    const sources = results.filter(output => output !== null);
-                    downloadResult = {
-                        totalFiles: outputs.length,
-                        successfulDownloads: sources.length,
-                        failedDownloads: downloadErrors.length,
-                        downloadErrors: downloadErrors.length > 0 ? downloadErrors : undefined,
-                        downloadPath: outputDir,
-                        sources,
-                    };
-                    console.log(`Download completed: ${sources.length}/${outputs.length} files successful`);
-                }
-                else {
-                    console.log('No output files found to download');
-                    downloadResult = {
-                        totalFiles: 0,
-                        successfulDownloads: 0,
-                        failedDownloads: 0,
-                        message: 'No output files found to download',
-                    };
-                }
+        else if (type === 'imitate') {
+            if (!prompt && !referenceImageUrl) {
+                throw new Error('prompt or referenceImageUrl is required for imitate type');
             }
-            catch (downloadError) {
-                console.error('Download process failed:', downloadError);
-                downloadResult = {
-                    error: `Download failed: ${downloadError}`,
-                    totalFiles: 0,
-                    successfulDownloads: 0,
-                    failedDownloads: 1,
-                };
+            if (prompt) {
+                referenceImageUrl = (await ai.generateImage({
+                    prompt,
+                    type: 'banana',
+                    image: referenceImageUrl ? [referenceImageUrl] : undefined,
+                })).url;
             }
-            const successResult = {
-                success: true,
-                outputPath,
-                outputFileName: validatedFileName,
-                command: compiled.cmd,
-                message: 'Video compilation and download completed successfully',
-                download: downloadResult,
-                timestamp: new Date().toISOString(),
-            };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(successResult),
-                    },
-                ],
-            };
+            res = await ai.actionImitation({
+                videoUrl,
+                imageUrl: referenceImageUrl,
+                onProgress,
+            });
         }
-        else {
-            console.error(`FFmpeg failed with exit code: ${result.exitCode}`);
-            const failureResult = {
-                success: false,
-                exitCode: result.exitCode,
-                outputPath,
-                // command: compiled.cmd,
-                stderr: result.stderr,
-                message: `FFmpeg exited with code ${result.exitCode}`,
+        if (res.url) {
+            const uri = await saveMaterial(currentSession, res.url, validatedFileName);
+            const result = {
+                success: true,
+                // source: url,
+                uri,
+                prompt,
                 timestamp: new Date().toISOString(),
             };
-            if (result.exitCode === 254) {
-                failureResult.message =
-                    'FFmpeg failed with code 254. Close current session immediately (inMinutes = 0) and re-open a new session to try again.';
+            // Update media_logs.json
+            try {
+                await updateMediaLogs(currentSession, validatedFileName, result);
+            }
+            catch (error) {
+                console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
             }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify(failureResult),
+                        text: JSON.stringify(result),
                     },
                 ],
             };
         }
-    }
-    catch (error) {
-        return createErrorResponse(error, 'compile-and-run');
-    }
-});
-server.registerTool('get-schema', {
-    title: 'Get Storyboard Schema or Draft Content Schema',
-    description: 'Get the complete Storyboard or Draft Content JSON Schema definition. Use this schema to validate storyboard.json or draft_content.json files.',
-    inputSchema: {
-        type: zod_1.z
-            .enum(['storyboard', 'draft_content'])
-            .describe('The type of schema to retrieve. Must be either "storyboard" or "draft_content". 用 type: storyboard 的 schema 生成 storyboard.json；用 type: draft_content 的 schema 生成 draft_content.json'),
-    },
-}, async ({ type }) => {
-    try {
-        const schemaPath = (0, node_path_1.resolve)(__dirname, `./prompts/${type}-schema.json`);
-        const schemaContent = await (0, promises_1.readFile)(schemaPath, 'utf-8');
-        const schema = JSON.parse(schemaContent);
-        let important_guidelines = '';
-        if (type === 'draft_content') {
-            important_guidelines = `⚠️ 生成文件时请严格遵守输出规范，字幕文本内容必须与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致。
-
-** 字幕优化 **
-  * 在保证字幕文本内容与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致的前提下，可根据 tts 返回的 \`captions.utterances\` 字段对字幕的显示进行优化，将过长的字幕分段显示，在 draft_content.json 中使用分段字幕，captions 的内容在 media_logs.json 中可查询到。
-  * 如用户未特殊指定，字幕样式（字体及大小）务必遵守输出规范
-`;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        schema,
-                        important_guidelines,
-                        timestamp: new Date().toISOString(),
-                    }),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error, 'get-schema');
-    }
-});
-server.registerTool('pick-voice', {
-    title: 'Pick Voice',
-    description: '根据用户需求，选择尽可能符合要求的语音，在合适的情况下，优先采用 volcano_tts_2 类型的语音',
-    inputSchema: {
-        prompt: zod_1.z
-            .string()
-            .describe('用户需求描述，例如：一个有亲和力的，适合给孩子讲故事的语音'),
-        custom_design: zod_1.z
-            .boolean()
-            .optional()
-            .describe('是否自定义语音，由于要消耗较多积分，因此**只有用户明确要求自己设计语音**，才将该参数设为true'),
-        custom_design_preview: zod_1.z
-            .string()
-            .optional()
-            .describe('用户自定义语音的预览文本，用于展示自定义语音的效果，只有 custom_design 为 true 时才需要'),
-        custom_design_save_to: zod_1.z
-            .string()
-            .optional()
-            .describe('自定义语音的保存路径，例如：custom_voice.mp3 custom_voice_{id}.mp3'),
-    },
-}, async ({ prompt, custom_design, custom_design_preview, custom_design_save_to, }) => {
-    try {
-        // 验证session状态
-        const currentSession = await validateSession('pick-voice');
-        const ai = currentSession.ai;
-        if (custom_design) {
-            if (!custom_design_preview) {
-                throw new Error('custom_design_preview is required when custom_design is true');
-            }
-            const data = await currentSession.ai.voiceDesign({
-                prompt,
-                previewText: custom_design_preview,
-            });
-            if (data.voice_id) {
-                const trial_audio = data.trial_audio;
-                let uri = '';
-                if (trial_audio) {
-                    uri = await saveMaterial(currentSession, trial_audio, custom_design_save_to || `custom_voice_${data.voice_id}.mp3`);
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                ...data,
-                                uri,
-                                timestamp: new Date().toISOString(),
-                            }),
-                        },
-                    ],
-                };
-            }
-            else {
-                throw new Error(`Voice design failed, ${JSON.stringify(data)}`);
-            }
-        }
-        const data = await ai.pickVoice({ prompt });
         return {
             content: [
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        success: true,
-                        ...data,
+                        success: false,
+                        error: 'No video URL returned from AI service',
+                        response: res,
                         timestamp: new Date().toISOString(),
                     }),
                 },
@@ -3143,7 +3308,7 @@ server.registerTool('pick-voice', {
         };
     }
     catch (error) {
-        return createErrorResponse(error, 'pick-voice');
+        return createErrorResponse(error, 'edit-video');
     }
 });
 server.registerTool('media-analyzer', {
@@ -3363,16 +3528,6 @@ server.registerTool('audio-video-sync', {
     title: 'Audio Video Sync',
     description: 'Generate audio-video-synced video by matching video with audio or lip sync.',
     inputSchema: {
-        lipSync: zod_1.z
-            .object({
-            type: zod_1.z
-                .enum(['pixv', 'vidu', 'basic', 'lite'])
-                .optional()
-                .default('pixv'),
-            padAudio: zod_1.z.boolean().optional().default(true),
-        })
-            .optional()
-            .describe('默认不用对口型，除非用户明确指定需要对口型。'),
         videos: zod_1.z
             .array(zod_1.z.string())
             .describe('The video file names in materials directory. 如果多个视频，将会按顺序拼接'),
@@ -3399,7 +3554,7 @@ server.registerTool('audio-video-sync', {
             .string()
             .describe('The filename to save the audio-video-synced video. 应该是mp4文件'),
     },
-}, async ({ lipSync, videos, audio, audioInMs, audioFadeOutMs, audioVolume, videoAudioVolume, saveToFileName, loopAudio, addSubtitles, }, context) => {
+}, async ({ videos, audio, audioInMs, audioFadeOutMs, audioVolume, videoAudioVolume, saveToFileName, loopAudio, addSubtitles, }, context) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('audio-video-sync');
@@ -3423,81 +3578,19 @@ server.registerTool('audio-video-sync', {
                 mediaUrls: videoUrls,
             })).url;
         }
-        if (!lipSync) {
-            // 不需要对口型
-            const result = await ai.voSync({
-                videoUrl,
-                audioUrl,
-                audioInMs,
-                audioFadeOutMs,
-                keepVideoAudio: true,
-                audioVolume,
-                videoAudioVolume,
-                loopAudio,
-                subtitles: addSubtitles,
-            });
-            if (result.url) {
-                console.log('Audio sync completed successfully');
-                // 保存到项目材料目录
-                const uri = await saveMaterial(currentSession, result.url, validatedFileName);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                uri,
-                                durationMs: Math.floor(result.duration * 1000),
-                                filename: validatedFileName,
-                                timestamp: new Date().toISOString(),
-                            }),
-                        },
-                    ],
-                };
-            }
-            else {
-                console.warn('Audio sync completed but no URL returned');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: 'No video URL returned from lip sync service',
-                                response: result,
-                                timestamp: new Date().toISOString(),
-                            }),
-                        },
-                    ],
-                };
-            }
-        }
-        // 调用AI的lipSync方法，使用处理后的音频
-        let progress = 0;
-        const result = await ai.lipSync({
-            type: lipSync.type,
+        const result = await ai.voSync({
             videoUrl,
             audioUrl,
             audioInMs,
-            pad_audio: lipSync.padAudio,
-            onProgress: async (metaData) => {
-                console.log('Lip sync progress:', metaData);
-                try {
-                    await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
-                }
-                catch (progressError) {
-                    console.warn('Failed to send progress update:', progressError);
-                }
-            },
+            audioFadeOutMs,
+            keepVideoAudio: true,
+            audioVolume,
+            videoAudioVolume,
+            loopAudio,
+            subtitles: addSubtitles,
         });
         if (result.url) {
-            console.log('Lip sync completed successfully');
-            if (addSubtitles) {
-                const addSubtitlesRes = await ai.addVideoSubtitles({
-                    videoUrl: result.url,
-                });
-                result.url = addSubtitlesRes.url || result.url;
-            }
+            console.log('Audio sync completed successfully');
             // 保存到项目材料目录
             const uri = await saveMaterial(currentSession, result.url, validatedFileName);
             return {
@@ -3508,8 +3601,6 @@ server.registerTool('audio-video-sync', {
                             success: true,
                             uri,
                             durationMs: Math.floor(result.duration * 1000),
-                            resolution: result.resolution,
-                            ratio: result.ratio,
                             filename: validatedFileName,
                             timestamp: new Date().toISOString(),
                         }),
@@ -3518,7 +3609,7 @@ server.registerTool('audio-video-sync', {
             };
         }
         else {
-            console.warn('Lip sync completed but no URL returned');
+            console.warn('Audio sync completed but no URL returned');
             return {
                 content: [
                     {
@@ -4268,44 +4359,6 @@ server.registerTool('run-ffmpeg-command', {
         return createErrorResponse(error, 'run-ffmpeg-command');
     }
 });
-// server.registerTool(
-//   'do-storyboard-optimization',
-//   {
-//     title: 'Do Storyboard Optimization',
-//     description:
-//       'Get storyboard optimization guidelines and action instructions.',
-//     inputSchema: {},
-//   },
-//   async () => {
-//     try {
-//       // 调用 do-storyboard-optimization 工具时，设置 checkStoryboardFlag 为 true
-//       checkStoryboardFlag = true;
-//       const guidelinePath = resolve(
-//         __dirname,
-//         './prompts/actions/storyboard_optimization.md'
-//       );
-//       const storyboardOptimizationGuidelines = await readFile(
-//         guidelinePath,
-//         'utf-8'
-//       );
-//       return {
-//         content: [
-//           {
-//             type: 'text' as const,
-//             text: JSON.stringify({
-//               content: {
-//                 guideline: storyboardOptimizationGuidelines,
-//                 action: '你应当根据guideline优化storyboard.json',
-//               },
-//             }),
-//           },
-//         ],
-//       };
-//     } catch (error) {
-//       return createErrorResponse(error, 'do-storyboard-optimization');
-//     }
-//   }
-// );
 server.registerTool('search-context', {
     title: 'Search Context',
     description: 'Search the context.',
@@ -4397,146 +4450,6 @@ server.registerTool('list-project-files', {
         return createErrorResponse(error, 'list-project-files');
     }
 });
-// server.registerTool(
-//   'build-capcat-draft',
-//   {
-//     title: 'Build CapCut Draft',
-//     description:
-//       'Read draft_content.json file, parse JSON and generate URIs for all assets in timeline tracks, then output the processed JSON string.',
-//     inputSchema: {
-//       draftContentFile: z
-//         .string()
-//         .optional()
-//         .default('draft_content.json')
-//         .describe(
-//           'The draft content file name to read (defaults to draft_content.json).'
-//         ),
-//     },
-//   },
-//   async ({ draftContentFile }) => {
-//     try {
-//       await validateSession('build-capcat-draft');
-//       if (!session) {
-//         throw new Error('No active session');
-//       }
-//       // 读取 draft_content.json 文件
-//       const draftContentPath = join(projectLocalDir, draftContentFile);
-//       if (!existsSync(draftContentPath)) {
-//         throw new Error(
-//           `${draftContentFile} file not found in project directory`
-//         );
-//       }
-//       const draftContentRaw = await readFile(draftContentPath, 'utf-8');
-//       const draftContent = JSON.parse(draftContentRaw);
-//       const videoInfos: any[] = [];
-//       const audioInfos: any[] = [];
-//       // 为 timeline 中的所有视频资源生成 URI 和视频信息
-//       if (draftContent.timeline && draftContent.timeline.tracks) {
-//         for (const track of draftContent.timeline.tracks) {
-//           if (track.type === 'video' && track.clips) {
-//             for (const clip of track.clips) {
-//               if (clip.assetId) {
-//                 // 在 assets 中找到对应的资源
-//                 const asset = draftContent.assets?.find(
-//                   (a: any) => a.id === clip.assetId
-//                 );
-//                 if (asset && asset.uri && asset.type === 'video') {
-//                   // 获取本地文件路径并上传到 coze
-//                   const localPath = join(
-//                     projectLocalDir,
-//                     'materials',
-//                     basename(asset.uri)
-//                   );
-//                   const uploadResult = await uploadFile(localPath);
-//                   const videoUrl = uploadResult.url;
-//                   // 构建视频信息对象
-//                   const videoInfo = {
-//                     video_url: videoUrl,
-//                     duration: clip.durationMs
-//                       ? clip.durationMs * 1000
-//                       : asset.durationMs
-//                         ? asset.durationMs * 1000
-//                         : 0, // 转换为微秒
-//                     width: draftContent.settings?.resolution?.width || 1920,
-//                     height: draftContent.settings?.resolution?.height || 1080,
-//                     start: clip.startMs ? clip.startMs * 1000 : 0, // 转换为微秒
-//                     end: ((clip.startMs ?? 0) + (clip.durationMs ?? 0)) * 1000,
-//                   };
-//                   videoInfos.push(videoInfo);
-//                 }
-//               }
-//             }
-//           } else if (track.type === 'audio' && track.clips) {
-//             for (const clip of track.clips) {
-//               if (clip.assetId) {
-//                 // 在 assets 中找到对应的资源
-//                 const asset = draftContent.assets?.find(
-//                   (a: any) => a.id === clip.assetId
-//                 );
-//                 if (asset && asset.uri && asset.type === 'audio') {
-//                   // 获取本地文件路径并上传到 coze
-//                   const localPath = join(
-//                     projectLocalDir,
-//                     'materials',
-//                     basename(asset.uri)
-//                   );
-//                   const uploadResult = await uploadFile(localPath);
-//                   const audioUrl = uploadResult.url;
-//                   // 构建音频信息对象
-//                   const audioInfo = {
-//                     audio_url: audioUrl,
-//                     duration: clip.durationMs
-//                       ? Math.round(clip.durationMs / 1000)
-//                       : asset.durationMs
-//                         ? Math.round(asset.durationMs / 1000)
-//                         : 0, // 转换为秒
-//                     start: clip.startMs ? clip.startMs * 1000 : 0, // 转换为微秒
-//                     end: ((clip.startMs ?? 0) + (clip.durationMs ?? 0)) * 1000,
-//                     audio_effect: '',
-//                   };
-//                   audioInfos.push(audioInfo);
-//                 }
-//               }
-//             }
-//           }
-//         }
-//       }
-//       // 处理字幕信息
-//       const captionInfos: any[] = [];
-//       if (draftContent.subtitles && Array.isArray(draftContent.subtitles)) {
-//         for (const subtitle of draftContent.subtitles) {
-//           captionInfos.push({
-//             text: subtitle.text || '',
-//             start: (subtitle.startMs || 0) * 1000, // 转换为微秒
-//             end: (subtitle.endMs || 0) * 1000, // 转换为微秒
-//             keyword: '',
-//           });
-//         }
-//       }
-//       const parameters = {
-//         video_infos: JSON.stringify(videoInfos),
-//         audio_infos: JSON.stringify(audioInfos),
-//         caption_infos: JSON.stringify(captionInfos),
-//         width: draftContent.settings?.resolution?.width || 720,
-//         height: draftContent.settings?.resolution?.height || 1280,
-//       };
-//       const workflow_id = '7559885633272758313';
-//       const result = await runWorkflow(workflow_id, parameters);
-//       // 返回 video_infos、audio_infos、captions、width 和 height 对象
-//       return {
-//         content: [
-//           {
-//             type: 'text',
-//             text: JSON.stringify(result, null, 2),
-//           },
-//         ],
-//       };
-//     } catch (error) {
-//       console.error('Error building CapCut draft:', error);
-//       return createErrorResponse(error, 'build-capcat-draft');
-//     }
-//   }
-// );
 async function run() {
     // Start receiving messages on stdin and sending messages on stdout
     const transport = new stdio_js_1.StdioServerTransport();