cerevox 2.43.1 → 3.0.0-alpha.10

package/dist/mcp/servers/zerocut.js

@@ -53,86 +53,9 @@ const node_path_1 = __importStar(require("node:path"));
 const doubao_voices_full_1 = require("./helper/doubao_voices_full");
 const node_fs_1 = require("node:fs");
 const coze_1 = require("../../utils/coze");
-const node_child_process_1 = require("node:child_process");
-const node_util_1 = require("node:util");
-const os = __importStar(require("node:os"));
 const mp3_duration_1 = __importDefault(require("mp3-duration"));
 const image_size_1 = __importDefault(require("image-size"));
-const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
-// 错误处理工具函数
-const handleError = (error) => {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-};
-// 检查端口是否被占用 - 跨平台版本
-const isPortInUse = async (port) => {
-    try {
-        const platform = os.platform();
-        let command;
-        if (platform === 'win32') {
-            // Windows 使用 netstat
-            command = `netstat -ano | findstr :${port}`;
-        }
-        else {
-            // Unix/Linux/macOS 使用 lsof
-            command = `lsof -ti:${port}`;
-        }
-        const { stdout } = await execAsync(command);
-        return stdout.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-};
-// 停止占用端口的进程 - 跨平台版本
-const killPortProcess = async (port) => {
-    try {
-        const platform = os.platform();
-        if (platform === 'win32') {
-            // Windows 版本
-            const { stdout } = await execAsync(`netstat -ano | findstr :${port}`);
-            const lines = stdout.trim().split('\n');
-            for (const line of lines) {
-                const parts = line.trim().split(/\s+/);
-                const pid = parts[parts.length - 1];
-                if (pid && /^\d+$/.test(pid)) {
-                    try {
-                        await execAsync(`taskkill /F /PID ${pid}`);
-                        console.log(`Killed process ${pid} on port ${port}`);
-                    }
-                    catch (error) {
-                        console.warn(`Failed to kill process ${pid}:`, error);
-                    }
-                }
-            }
-        }
-        else {
-            // Unix/Linux/macOS 版本
-            const { stdout } = await execAsync(`lsof -ti:${port}`);
-            const pids = stdout
-                .trim()
-                .split('\n')
-                .filter(pid => pid);
-            for (const pid of pids) {
-                try {
-                    await execAsync(`kill -9 ${pid}`);
-                    console.log(`Killed process ${pid} on port ${port}`);
-                }
-                catch (error) {
-                    console.warn(`Failed to kill process ${pid}:`, error);
-                }
-            }
-        }
-        // 等待一下确保进程被杀死
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    }
-    catch (error) {
-        console.warn(`Failed to kill processes on port ${port}:`, error);
-    }
-};
-function createErrorResponse(error, operation) {
+function createErrorResponse(error, operation, details) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error(`[${operation}] Error:`, error);
     return {
@@ -144,6 +67,7 @@ function createErrorResponse(error, operation) {
                     error: errorMessage,
                     operation,
                     timestamp: new Date().toISOString(),
+                    details,
                 }),
             },
         ],
@@ -159,6 +83,10 @@ async function validateSession(operation) {
         session = null;
         throw new Error(`Session not initialized. Please call 'project-open' first before using ${operation}.`);
     }
+    const projectRulesFile = (0, node_path_1.resolve)(projectLocalDir, '.trae', 'rules', `project_rules.md`);
+    if (!(0, node_fs_1.existsSync)(projectRulesFile)) {
+        throw new Error(`Project rules file not found: ${projectRulesFile}. Please call 'retrieve-rules-context' first.`);
+    }
     return session;
 }
 // 文件名验证
@@ -173,20 +101,6 @@ function validateFileName(fileName) {
     }
     return fileName.trim();
 }
-// 图片文件验证
-function validateImageFile(localPath) {
-    if (!localPath || localPath.trim() === '') {
-        throw new Error('Local path cannot be empty');
-    }
-    const allowedExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp'];
-    const extension = localPath
-        .toLowerCase()
-        .substring(localPath.lastIndexOf('.'));
-    if (!allowedExtensions.includes(extension)) {
-        throw new Error(`Unsupported image format: ${extension}. Allowed formats: ${allowedExtensions.join(', ')}`);
-    }
-    return localPath.trim();
-}
 function getMaterialUri(session, fileName) {
     return session.sandbox.getUrl(`/zerocut/${session.terminal.id}/materials/${(0, node_path_1.basename)(fileName)}`);
 }
@@ -211,7 +125,7 @@ async function initProject(session) {
     // 创建素材目录和成品目录 materials、output
     await (await terminal.run('mkdir materials output')).end();
     // 文件包括（大部分不需要此时创建）
-    // story_board.json 故事版
+    // storyboard.json 故事版
     // draft_content.json 草稿内容，Agent在创作过程中，会根据项目规范，自动生成和修改该文件
     return workDir;
 }
@@ -692,6 +606,7 @@ server.registerTool('project-open', {
         }
         const result = {
             success: true,
+            nextActionSuggest: '检查规则上下文是否已召回，若未召回，调用 retrieve_rules 工具召回规则上下文',
             sessionId: session.id,
             workDir,
             projectLocalDir,
@@ -825,7 +740,10 @@ server.registerTool('generate-character-image', {
     title: 'Generate Character Image',
     description: 'Generate a turnaround image or portrait for any character.',
     inputSchema: {
-        type: zod_1.z.enum(['banana', 'seedream']).optional().default('banana'),
+        type: zod_1.z
+            .enum(['banana', 'banana-pro', 'seedream'])
+            .optional()
+            .default('banana'),
         name: zod_1.z.string().describe('The name of the character.'),
         gender: zod_1.z
             .enum(['male', 'female'])
@@ -1155,10 +1073,13 @@ server.registerTool('generate-image', {
     title: 'Generate Image',
     description: `生成图片`,
     inputSchema: {
-        type: zod_1.z.enum(['banana', 'seedream']).optional().default('seedream'),
+        type: zod_1.z
+            .enum(['banana', 'banana-pro', 'seedream'])
+            .optional()
+            .default('seedream'),
         prompt: zod_1.z
             .string()
-            .describe('The prompt to generate. 一般要严格对应 story_board 中当前场景的 start_frame 或 end_frame 中的字段描述'),
+            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前场景的 start_frame 或 end_frame 中的字段描述'),
         sceneIndex: zod_1.z
             .number()
             .min(1)
@@ -1167,7 +1088,7 @@ server.registerTool('generate-image', {
         storyBoardFile: zod_1.z
             .string()
             .optional()
-            .default('story_board.json')
+            .default('storyboard.json')
             .describe('故事板文件路径'),
         skipConsistencyCheck: zod_1.z
             .boolean()
@@ -1252,7 +1173,7 @@ server.registerTool('generate-image', {
 \`\`\`
           `),
     },
-}, async ({ type = 'seedream', prompt, sceneIndex, storyBoardFile = 'story_board.json', skipConsistencyCheck = false, size = '720x1280', saveToFileName, watermark, referenceImages, optimizePrompt, }) => {
+}, async ({ type = 'seedream', prompt, sceneIndex, storyBoardFile = 'storyboard.json', skipConsistencyCheck = false, size = '720x1280', saveToFileName, watermark, referenceImages, optimizePrompt, }) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('generate-image');
@@ -1260,10 +1181,10 @@ server.registerTool('generate-image', {
         // 检查 storyboard 标志
         if (!checkStoryboardFlag && (0, node_fs_1.existsSync)(storyBoardPath)) {
             checkStoryboardFlag = true;
-            return createErrorResponse('必须先审查生成的 story_board.json 内容，确保每个场景中的stage_atmosphere内容按照规则被正确融合到start_frame和video_prompt中，不得遗漏，检查完成后先汇报，如果有问题，应当先修改 story_board.json 内容，然后再调用 generate-image 生成图片。注意修改 story_board 内容时，仅修改相应字段的字符串值，不要破坏JSON格式！', 'generate-image');
+            return createErrorResponse('必须先审查生成的 storyboard.json 内容，确保每个场景中的stage_atmosphere内容按照规则被正确融合到start_frame和video_prompt中，不得遗漏，检查完成后先汇报，如果有问题，应当先修改 storyboard.json 内容，然后再调用 generate-image 生成图片。注意修改 storyboard 内容时，仅修改相应字段的字符串值，不要破坏JSON格式！', 'generate-image');
         }
         const validatedFileName = validateFileName(saveToFileName);
-        // 校验 prompt 与 story_board.json 中场景设定的一致性
+        // 校验 prompt 与 storyboard.json 中场景设定的一致性
         if (sceneIndex && !skipConsistencyCheck) {
             try {
                 if ((0, node_fs_1.existsSync)(storyBoardPath)) {
@@ -1283,9 +1204,9 @@ server.registerTool('generate-image', {
                             const endFrame = scene.end_frame;
                             // 检查 prompt 是否严格等于 start_frame 或 end_frame
                             if (prompt !== startFrame && prompt !== endFrame) {
-                                return createErrorResponse('图片提示词必须严格遵照story_board的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-image');
+                                return createErrorResponse('图片提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-image');
                             }
-                            // 校验 size 参数与 story_board 的 orientation 属性一致性
+                            // 校验 size 参数与 storyboard 的 orientation 属性一致性
                             if (size && storyBoard.orientation) {
                                 const isLandscapeSize = [
                                     '1152x864',
@@ -1330,7 +1251,7 @@ server.registerTool('generate-image', {
                             }
                         }
                         else {
-                            console.warn(`Scene index ${sceneIndex} not found in story_board.json`);
+                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
                         }
                     }
                 }
@@ -1340,7 +1261,7 @@ server.registerTool('generate-image', {
             }
             catch (error) {
                 console.error('Failed to validate prompt with story board:', error);
-                // 如果读取或解析 story_board.json 失败，继续执行但记录警告
+                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
             }
         }
         // 检查并替换英文单引号包裹的中文内容为中文双引号
@@ -1520,6 +1441,11 @@ server.registerTool('edit-image', {
     description: 'Edit the image.',
     inputSchema: {
         prompt: zod_1.z.string().describe('要编辑图片的中文提示词'),
+        type: zod_1.z
+            .enum(['banana-pro', 'banana', 'seedream'])
+            .optional()
+            .default('seedream')
+            .describe('The type of image model to use.'),
         sourceImageFileName: zod_1.z.string().describe('The source image file name.'),
         saveToFileName: zod_1.z.string().describe('The filename to save.'),
         size: zod_1.z
@@ -1563,7 +1489,7 @@ server.registerTool('edit-image', {
             .default(false)
             .describe('Whether to add watermark to the image.'),
     },
-}, async ({ prompt, sourceImageFileName, saveToFileName, size, watermark }) => {
+}, async ({ prompt, type, sourceImageFileName, saveToFileName, size, watermark, }) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('edit-image');
@@ -1589,8 +1515,9 @@ server.registerTool('edit-image', {
         const base64String = `data:${mimeType};base64,${imageBuffer.toString('base64')}`;
         imageBase64Array.push(base64String);
         const ai = currentSession.ai;
-        const processedPrompt = `转绘参考图片，${prompt}`;
+        const processedPrompt = `转绘我提供的参考图片，${prompt}`;
         const res = await ai.generateImage({
+            type,
             prompt: processedPrompt,
             size,
             watermark,
@@ -1647,7 +1574,7 @@ server.registerTool('generate-video', {
     inputSchema: {
         prompt: zod_1.z
             .string()
-            .describe('The prompt to generate. 一般要严格对应 story_board 中当前场景的 video_prompt 字段描述'),
+            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前场景的 video_prompt 字段描述'),
         sceneIndex: zod_1.z
             .number()
             .min(1)
@@ -1656,7 +1583,7 @@ server.registerTool('generate-video', {
         storyBoardFile: zod_1.z
             .string()
             .optional()
-            .default('story_board.json')
+            .default('storyboard.json')
             .describe('故事板文件路径'),
         skipConsistencyCheck: zod_1.z
             .boolean()
@@ -1691,7 +1618,7 @@ server.registerTool('generate-video', {
             .describe('The image file name of the start frame.'),
         duration: zod_1.z
             .number()
-            .min(2)
+            .min(1)
             .max(23)
             .describe('The duration of the video. 一般与 tts 配音音频时长向上取整秒(ceil)一致，或者与 timeline_analysis 中确定的歌曲片段时长一致'),
         end_frame: zod_1.z
@@ -1718,7 +1645,7 @@ server.registerTool('generate-video', {
             .default(false)
             .describe('Whether to optimize the prompt.'),
     },
-}, async ({ prompt, sceneIndex, storyBoardFile = 'story_board.json', skipConsistencyCheck = false, saveToFileName, start_frame, end_frame, duration, watermark, resolution, type, optimizePrompt, saveLastFrameAs, }, context) => {
+}, async ({ prompt, sceneIndex, storyBoardFile = 'storyboard.json', skipConsistencyCheck = false, saveToFileName, start_frame, end_frame, duration, watermark, resolution, type, optimizePrompt, saveLastFrameAs, }, context) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('generate-video');
@@ -1739,7 +1666,7 @@ server.registerTool('generate-video', {
             console.warn(`zero 模型的视频仅支持 1080p 分辨率，用户指定的分辨率为 %s，已自动将 ${resolution} 转换为 1080p`, resolution);
             resolution = '1080p';
         }
-        // 校验 prompt 与 story_board.json 中场景设定的一致性以及视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
+        // 校验 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);
@@ -1758,7 +1685,7 @@ server.registerTool('generate-video', {
                         if (scene) {
                             const videoPrompt = scene.video_prompt;
                             if (videoPrompt && prompt !== videoPrompt) {
-                                return createErrorResponse('视频提示词必须严格遵照story_board的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
                             }
                             if (scene.is_continuous && !end_frame) {
                                 return createErrorResponse('连续场景必须指定end_frame参数，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
@@ -1771,7 +1698,7 @@ server.registerTool('generate-video', {
                             }
                         }
                         else {
-                            console.warn(`Scene index ${sceneIndex} not found in story_board.json`);
+                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
                         }
                     }
                 }
@@ -1781,7 +1708,7 @@ server.registerTool('generate-video', {
             }
             catch (error) {
                 console.error('Failed to validate prompt with story board:', error);
-                // 如果读取或解析 story_board.json 失败，继续执行但记录警告
+                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
             }
             // 校验视频时长与 timeline_analysis.json 中 proposed_video_scenes 的匹配
             try {
@@ -1818,10 +1745,10 @@ server.registerTool('generate-video', {
                                     if (!checkAudioVideoDurationFlag) {
                                         checkAudioVideoDurationFlag = true;
                                         if (scene.audio_mode === 'vo_sync') {
-                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 story_board 中视频时长为音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
+                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长为音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
                                         }
                                         else if (scene.audio_mode === 'dialogue') {
-                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 story_board 中视频时长**不小于**音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
+                                            return createErrorResponse('请先自我检查 media_logs 中的音频时长，确保 storyboard 中视频时长**不小于**音频时长向上取整 即 ceil(音频时长），然后再按照正确的视频时长创建视频', 'generate-video');
                                         }
                                     }
                                 }
@@ -1946,10 +1873,10 @@ server.registerTool('generate-video', {
                             type: 'string',
                             description: 'kenburns 视频 宽x高',
                         },
-                    },
-                    duration: {
-                        type: 'number',
-                        description: 'kenburns 视频 时长',
+                        duration: {
+                            type: 'number',
+                            description: 'kenburns 视频 时长',
+                        },
                     },
                     required: ['camera_motion', 'size', 'duration'],
                 },
@@ -2091,7 +2018,7 @@ server.registerTool('generate-video', {
                     console.warn('Failed to send progress update:', progressError);
                 }
             },
-            waitForFinish: type !== 'zero', // zero 模型由于时间比较长，因此要异步查询而不是等待
+            waitForFinish: true,
         });
         if (!res) {
             throw new Error('Failed to generate video: no response from AI service');
@@ -2139,7 +2066,7 @@ server.registerTool('generate-video', {
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
-                            message: '该视频生成任务已提交，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如该工具调用超时，你应立即再次重新调用直到任务结束。',
+                            message: '该视频生成任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如该工具调用超时，你应立即再次重新调用直到任务结束。',
                             taskUrl: res.taskUrl,
                         }),
                     },
@@ -2194,6 +2121,7 @@ server.registerTool('wait-for-task-finish', {
                     console.warn('Failed to send progress update:', progressError);
                 }
             },
+            timeout: 300000,
         });
         if (res.url) {
             const uri = await saveMaterial(currentSession, res.url, saveToFileName);
@@ -2423,7 +2351,7 @@ server.registerTool('generate-scene-tts', {
         storyBoardFile: zod_1.z
             .string()
             .optional()
-            .default('story_board.json')
+            .default('storyboard.json')
             .describe('故事板文件路径'),
         skipConsistencyCheck: zod_1.z
             .boolean()
@@ -2478,7 +2406,9 @@ server.registerTool('generate-scene-tts', {
             'ASMR',
         ])
             .optional(),
-        voiceID: zod_1.z.string().describe(`适合作为视频配音的音色ID`),
+        voiceID: zod_1.z
+            .string()
+            .describe(`适合作为视频配音的音色ID，除非用户指定，否则你必须已通过 search_voice 工具检查确定该音色确实是存在的。`),
         explicit_language: zod_1.z.enum(['zh', 'en', 'ja']).optional().default('zh'),
     },
 }, async ({ text, sceneIndex, storyBoardFile, skipConsistencyCheck, voiceID, saveToFileName, speed, pitch, volume, emotion, explicit_language, }) => {
@@ -2489,7 +2419,7 @@ server.registerTool('generate-scene-tts', {
         const finalSpeed = speed ?? 1;
         volume = volume ?? 1;
         let scene = null;
-        // 校验 text 与 story_board.json 中场景设定的一致性
+        // 校验 text 与 storyboard.json 中场景设定的一致性
         if (sceneIndex && !skipConsistencyCheck) {
             try {
                 const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
@@ -2524,11 +2454,11 @@ server.registerTool('generate-scene-tts', {
                                 }
                             }
                             if (!isValidText) {
-                                return createErrorResponse('配音文本必须严格遵照story_board的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-scene-tts');
+                                return createErrorResponse('配音文本必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-scene-tts');
                             }
                         }
                         else {
-                            console.warn(`Scene index ${sceneIndex} not found in story_board.json`);
+                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
                         }
                     }
                 }
@@ -2538,11 +2468,14 @@ server.registerTool('generate-scene-tts', {
             }
             catch (error) {
                 console.error('Failed to validate text with story board:', error);
-                // 如果读取或解析 story_board.json 失败，继续执行但记录警告
+                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
             }
         }
         console.log(`Generating TTS with voice: ${voiceID}, speed: ${finalSpeed}, text: ${text.substring(0, 100)}...`);
         const ai = currentSession.ai;
+        if (voiceID.startsWith('BV0')) {
+            throw new Error(`BV0* 系列音色已弃用，你必须已通过 search_voice 工具检查确定该音色确实是存在的。`);
+        }
         const type = voiceID.startsWith('zh_') ||
             voiceID.startsWith('en_') ||
             voiceID.startsWith('multi_') ||
@@ -2592,7 +2525,7 @@ server.registerTool('generate-scene-tts', {
             console.log('TTS generated successfully, saving to materials...');
             const { url, duration, ...opts } = res;
             if (!skipConsistencyCheck && duration > 16) {
-                return createErrorResponse('TTS duration exceeds 16 seconds, 建议调整文本长度、提升语速或拆分场景...，⚠️如简化文本内容或拆分文本，需要立即更新 story_board 以保持内容同步！如仍要生成，可设置 skipConsistencyCheck 为 true，跳过一致性检查。', 'generate-scene-tts');
+                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');
@@ -2678,8 +2611,8 @@ server.registerTool('compile-and-run', {
             checkStoryboardSubtitlesFlag = true;
             return createErrorResponse(`请先对 draft_content 进行以下一致性检查：
           
-1. 检查字幕文字内容是否与 story_board 中各个场景的 script 或 dialog 内容完全一致（⚠️ 允许字幕分段展示，只要最终文本保持一致就行）
-2. 检查视频 resolution 设定是否与 story_board 的 orientation 设置一致，默认 720p 情况下视频尺寸应为横屏 1280x720，竖屏 720x1280，若视频为 1080p 则尺寸应分别为横屏 1920x1080 和竖屏 1080x1920，切勿设反
+1. 检查字幕文字内容是否与 storyboard 中各个场景的 script 或 dialog 内容完全一致（⚠️ 允许字幕分段展示，只要最终文本保持一致就行）
+2. 检查视频 resolution 设定是否与 storyboard 的 orientation 设置一致，默认 720p 情况下视频尺寸应为横屏 1280x720，竖屏 720x1280，若视频为 1080p 则尺寸应分别为横屏 1920x1080 和竖屏 1080x1920，切勿设反
 3. 除非用户明确表示不要背景音乐，否则应检查是否有生成并配置了 BGM，若无，则生成 BGM 并将其加入素材和轨道配置
 
 以上检查任何一项有问题，先修复 draft_content 使其符合要求后再进行合成`, 'compile-and-run');
@@ -2837,47 +2770,28 @@ server.registerTool('compile-and-run', {
         return createErrorResponse(error, 'compile-and-run');
     }
 });
-server.registerTool('get-video-project-schema', {
-    title: 'Get VideoProject Schema',
-    description: 'Get the complete VideoProject JSON Schema definition. Should use this schema to validate draft_content JSON files.',
-    inputSchema: {},
-}, async () => {
+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, '../../utils/videoproject-schema.json');
+        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);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        schema,
-                        important_guidelines: `⚠️ 生成文件时请严格遵守输出规范，字幕文本内容必须与 story_board.json 中的 script（或dialog） 字段的文本内容完全一致。
+        let important_guidelines = '';
+        if (type === 'draft_content') {
+            important_guidelines = `⚠️ 生成文件时请严格遵守输出规范，字幕文本内容必须与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致。
 
 ** 字幕优化 **
-  * 在保证字幕文本内容与 story_board.json 中的 script（或dialog） 字段的文本内容完全一致的前提下，可根据 tts 返回的 \`captions.utterances\` 字段对字幕的显示进行优化，将过长的字幕分段显示，在 draft_content.json 中使用分段字幕，captions 的内容在 media_logs.json 中可查询到。
+  * 在保证字幕文本内容与 storyboard.json 中的 script（或dialog） 字段的文本内容完全一致的前提下，可根据 tts 返回的 \`captions.utterances\` 字段对字幕的显示进行优化，将过长的字幕分段显示，在 draft_content.json 中使用分段字幕，captions 的内容在 media_logs.json 中可查询到。
   * 如用户未特殊指定，字幕样式（字体及大小）务必遵守输出规范
-`,
-                        timestamp: new Date().toISOString(),
-                    }),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error, 'get-video-project-schema');
-    }
-});
-server.registerTool('get-storyboard-schema', {
-    title: 'Get Storyboard Schema',
-    description: 'Get the complete Storyboard JSON Schema definition.',
-    inputSchema: {},
-}, async () => {
-    try {
-        const schemaPath = (0, node_path_1.resolve)(__dirname, '../../utils/storyboard-schema.json');
-        const schemaContent = await (0, promises_1.readFile)(schemaPath, 'utf-8');
-        const schema = JSON.parse(schemaContent);
+`;
+        }
         return {
             content: [
                 {
@@ -2885,6 +2799,7 @@ server.registerTool('get-storyboard-schema', {
                     text: JSON.stringify({
                         success: true,
                         schema,
+                        important_guidelines,
                         timestamp: new Date().toISOString(),
                     }),
                 },
@@ -2892,7 +2807,7 @@ server.registerTool('get-storyboard-schema', {
         };
     }
     catch (error) {
-        return createErrorResponse(error, 'get-storyboard-schema');
+        return createErrorResponse(error, 'get-schema');
     }
 });
 server.registerTool('do-storyboard-optimization', {
@@ -2912,7 +2827,7 @@ server.registerTool('do-storyboard-optimization', {
                     text: JSON.stringify({
                         content: {
                             guideline: storyboardOptimizationGuidelines,
-                            action: '你应当根据guideline优化story_board.json',
+                            action: '你应当根据guideline优化storyboard.json',
                         },
                     }),
                 },
@@ -3296,180 +3211,206 @@ server.registerTool('media-analyzer', {
         return createErrorResponse(error, 'media-analyzer');
     }
 });
-server.registerTool('image-aligner', {
-    title: 'Image Aligner',
-    description: 'Analyze image quality and alignment with prompt using AI Image Quality Inspector.',
-    inputSchema: {
-        imageFileName: zod_1.z
-            .string()
-            .describe('The image file name in materials directory to analyze.'),
-        sceneIndex: zod_1.z.number().min(1).describe('场景索引，从1开始的下标'),
-        storyBoardFile: zod_1.z
-            .string()
-            .optional()
-            .default('story_board.json')
-            .describe('故事板文件路径'),
-        imagePrompt: zod_1.z
-            .string()
-            .optional()
-            .describe('可选的图片提示词，如果提供则覆盖story_board中的提示词'),
-        customPrompt: zod_1.z
-            .string()
-            .optional()
-            .describe('可选的额外用户要求，用于补充图片质量评估的特定需求'),
-    },
-}, async ({ imageFileName, sceneIndex, storyBoardFile = 'story_board.json', imagePrompt, customPrompt, }) => {
-    try {
-        const currentSession = await validateSession('image-aligner');
-        // 验证图片文件
-        validateImageFile(imageFileName);
-        // 获取图片 URL
-        const imageUrl = getMaterialUri(currentSession, imageFileName);
-        // 确定要使用的提示词
-        let finalPrompt = imagePrompt;
-        // 如果没有提供imagePrompt，则从story_board中获取
-        if (!imagePrompt) {
-            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) {
-                            // 根据文件名判断优先级：若end_frame存在且imageFileName包含"_end"则优先取end_frame，否则取start_frame
-                            if (scene.end_frame && imageFileName.includes('_end')) {
-                                finalPrompt = scene.end_frame;
-                            }
-                            else {
-                                finalPrompt = scene.start_frame || scene.end_frame;
-                            }
-                            if (!finalPrompt) {
-                                return createErrorResponse(`场景 ${sceneIndex} 中未找到 start_frame 或 end_frame 提示词`, 'image-aligner');
-                            }
-                        }
-                        else {
-                            return createErrorResponse(`在 ${storyBoardFile} 中未找到场景索引 ${sceneIndex}`, 'image-aligner');
-                        }
-                    }
-                    else {
-                        return createErrorResponse(`${storyBoardFile} 文件格式不正确，缺少 scenes 数组`, 'image-aligner');
-                    }
-                }
-                else {
-                    return createErrorResponse(`故事板文件不存在: ${storyBoardPath}`, 'image-aligner');
-                }
-            }
-            catch (error) {
-                return createErrorResponse(`读取或解析故事板文件失败: ${error}`, 'image-aligner');
-            }
-        }
-        // 如果仍然没有提示词，返回错误
-        if (!finalPrompt) {
-            return createErrorResponse('未提供 imagePrompt 且无法从故事板中获取提示词', 'image-aligner');
-        }
-        // 读取图片质量检查指南
-        const alignerGuidelinePath = (0, node_path_1.resolve)(__dirname, './prompts/reasonings/image_aligner.md');
-        let alignerGuideline = '';
-        try {
-            alignerGuideline = await (0, promises_1.readFile)(alignerGuidelinePath, 'utf8');
-        }
-        catch (error) {
-            console.warn('无法读取图片质量检查指南:', error);
-            alignerGuideline =
-                '请对图片质量进行评估，包括构图、色彩、清晰度等方面。';
-        }
-        // 构建系统提示
-        const systemPrompt = `你是一个专业的AI图片质量检查员。请根据以下指南对图片进行评估：
-
-${alignerGuideline}
-
-请严格按照指南中的JSON格式返回评估结果。`;
-        // 构建用户提示
-        const userPrompt = `请对这张图片进行质量评估。
-
-原始提示词：${finalPrompt}${customPrompt
-            ? `
-
-额外要求：${customPrompt}`
-            : ''}
-
-请按照指南要求，返回包含评分、问题列表和优化建议的JSON格式结果。`;
-        // 调用AI模型进行图片质量评估
-        const ai = currentSession.ai;
-        const completion = await ai.getCompletions({
-            model: 'Doubao-Seed-1.6',
-            messages: [
-                {
-                    role: 'system',
-                    content: systemPrompt,
-                },
-                {
-                    role: 'user',
-                    content: [
-                        {
-                            type: 'image_url',
-                            image_url: {
-                                url: imageUrl,
-                            },
-                        },
-                        {
-                            type: 'text',
-                            text: userPrompt,
-                        },
-                    ],
-                },
-            ],
-        });
-        const result = completion.choices[0]?.message?.content;
-        if (!result) {
-            throw new Error('No response from AI model');
-        }
-        // 解析AI响应
-        let alignmentResult;
-        try {
-            // 尝试从响应中提取JSON
-            const jsonMatch = result.match(/```json\s*([\s\S]*?)\s*```/) ||
-                result.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                alignmentResult = JSON.parse(jsonMatch[1] || jsonMatch[0]);
-            }
-            else {
-                // 如果没有找到JSON格式，尝试直接解析整个响应
-                alignmentResult = JSON.parse(result);
-            }
-        }
-        catch (error) {
-            // 如果解析失败，返回原始响应
-            alignmentResult = {
-                error: 'JSON解析失败',
-                raw_response: result,
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        imageFileName,
-                        sceneIndex,
-                        storyBoardFile,
-                        imagePrompt: finalPrompt,
-                        customPrompt,
-                        promptSource: imagePrompt ? 'manual_override' : 'story_board',
-                        analysis: alignmentResult,
-                        imageUrl,
-                        nextActionSuggest: '可根据分析结果调整提示词，修改story_board后，重新生成图片。',
-                    }),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error, 'image-aligner');
-    }
-});
+// server.registerTool(
+//   'image-aligner',
+//   {
+//     title: 'Image Aligner',
+//     description:
+//       'Analyze image quality and alignment with prompt using AI Image Quality Inspector.',
+//     inputSchema: {
+//       imageFileName: z
+//         .string()
+//         .describe('The image file name in materials directory to analyze.'),
+//       sceneIndex: z.number().min(1).describe('场景索引，从1开始的下标'),
+//       storyBoardFile: z
+//         .string()
+//         .optional()
+//         .default('storyboard.json')
+//         .describe('故事板文件路径'),
+//       imagePrompt: z
+//         .string()
+//         .optional()
+//         .describe('可选的图片提示词，如果提供则覆盖storyboard中的提示词'),
+//       customPrompt: z
+//         .string()
+//         .optional()
+//         .describe('可选的额外用户要求，用于补充图片质量评估的特定需求'),
+//     },
+//   },
+//   async ({
+//     imageFileName,
+//     sceneIndex,
+//     storyBoardFile = 'storyboard.json',
+//     imagePrompt,
+//     customPrompt,
+//   }) => {
+//     try {
+//       const currentSession = await validateSession('image-aligner');
+//       // 验证图片文件
+//       validateImageFile(imageFileName);
+//       // 获取图片 URL
+//       const imageUrl = getMaterialUri(currentSession, imageFileName);
+//       // 确定要使用的提示词
+//       let finalPrompt = imagePrompt;
+//       // 如果没有提供imagePrompt，则从storyboard中获取
+//       if (!imagePrompt) {
+//         try {
+//           const storyBoardPath = resolve(
+//             process.env.ZEROCUT_PROJECT_CWD || process.cwd(),
+//             projectLocalDir,
+//             storyBoardFile
+//           );
+//           if (existsSync(storyBoardPath)) {
+//             const storyBoardContent = await 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) {
+//                 // 根据文件名判断优先级：若end_frame存在且imageFileName包含"_end"则优先取end_frame，否则取start_frame
+//                 if (scene.end_frame && imageFileName.includes('_end')) {
+//                   finalPrompt = scene.end_frame;
+//                 } else {
+//                   finalPrompt = scene.start_frame || scene.end_frame;
+//                 }
+//                 if (!finalPrompt) {
+//                   return createErrorResponse(
+//                     `场景 ${sceneIndex} 中未找到 start_frame 或 end_frame 提示词`,
+//                     'image-aligner'
+//                   );
+//                 }
+//               } else {
+//                 return createErrorResponse(
+//                   `在 ${storyBoardFile} 中未找到场景索引 ${sceneIndex}`,
+//                   'image-aligner'
+//                 );
+//               }
+//             } else {
+//               return createErrorResponse(
+//                 `${storyBoardFile} 文件格式不正确，缺少 scenes 数组`,
+//                 'image-aligner'
+//               );
+//             }
+//           } else {
+//             return createErrorResponse(
+//               `故事板文件不存在: ${storyBoardPath}`,
+//               'image-aligner'
+//             );
+//           }
+//         } catch (error) {
+//           return createErrorResponse(
+//             `读取或解析故事板文件失败: ${error}`,
+//             'image-aligner'
+//           );
+//         }
+//       }
+//       // 如果仍然没有提示词，返回错误
+//       if (!finalPrompt) {
+//         return createErrorResponse(
+//           '未提供 imagePrompt 且无法从故事板中获取提示词',
+//           'image-aligner'
+//         );
+//       }
+//       // 读取图片质量检查指南
+//       const alignerGuidelinePath = resolve(
+//         __dirname,
+//         './prompts/reasonings/image_aligner.md'
+//       );
+//       let alignerGuideline = '';
+//       try {
+//         alignerGuideline = await readFile(alignerGuidelinePath, 'utf8');
+//       } catch (error) {
+//         console.warn('无法读取图片质量检查指南:', error);
+//         alignerGuideline =
+//           '请对图片质量进行评估，包括构图、色彩、清晰度等方面。';
+//       }
+//       // 构建系统提示
+//       const systemPrompt = `你是一个专业的AI图片质量检查员。请根据以下指南对图片进行评估：
+// ${alignerGuideline}
+// 请严格按照指南中的JSON格式返回评估结果。`;
+//       // 构建用户提示
+//       const userPrompt = `请对这张图片进行质量评估。
+// 原始提示词：${finalPrompt}${
+//         customPrompt
+//           ? `
+// 额外要求：${customPrompt}`
+//           : ''
+//       }
+// 请按照指南要求，返回包含评分、问题列表和优化建议的JSON格式结果。`;
+//       // 调用AI模型进行图片质量评估
+//       const ai = currentSession.ai;
+//       const completion = await ai.getCompletions({
+//         model: 'Doubao-Seed-1.6',
+//         messages: [
+//           {
+//             role: 'system',
+//             content: systemPrompt,
+//           },
+//           {
+//             role: 'user',
+//             content: [
+//               {
+//                 type: 'image_url',
+//                 image_url: {
+//                   url: imageUrl,
+//                 },
+//               },
+//               {
+//                 type: 'text',
+//                 text: userPrompt,
+//               },
+//             ],
+//           },
+//         ],
+//       });
+//       const result = completion.choices[0]?.message?.content;
+//       if (!result) {
+//         throw new Error('No response from AI model');
+//       }
+//       // 解析AI响应
+//       let alignmentResult;
+//       try {
+//         // 尝试从响应中提取JSON
+//         const jsonMatch =
+//           result.match(/```json\s*([\s\S]*?)\s*```/) ||
+//           result.match(/\{[\s\S]*\}/);
+//         if (jsonMatch) {
+//           alignmentResult = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+//         } else {
+//           // 如果没有找到JSON格式，尝试直接解析整个响应
+//           alignmentResult = JSON.parse(result);
+//         }
+//       } catch (error) {
+//         // 如果解析失败，返回原始响应
+//         alignmentResult = {
+//           error: 'JSON解析失败',
+//           raw_response: result,
+//         };
+//       }
+//       return {
+//         content: [
+//           {
+//             type: 'text',
+//             text: JSON.stringify({
+//               success: true,
+//               imageFileName,
+//               sceneIndex,
+//               storyBoardFile,
+//               imagePrompt: finalPrompt,
+//               customPrompt,
+//               promptSource: imagePrompt ? 'manual_override' : 'storyboard',
+//               analysis: alignmentResult,
+//               imageUrl,
+//               nextActionSuggest:
+//                 '可根据分析结果调整提示词，修改storyboard后，重新生成图片。',
+//             }),
+//           },
+//         ],
+//       };
+//     } catch (error) {
+//       return createErrorResponse(error, 'image-aligner');
+//     }
+//   }
+// );
 server.registerTool('audio-video-sync', {
     title: 'Audio Video Sync',
     description: 'Generate audio-video-synced video by matching video with audio. 还可以对口型。',
@@ -3625,6 +3566,11 @@ server.registerTool('generate-video-by-ref', {
         prompt: zod_1.z
             .string()
             .describe('The prompt to generate video with or without reference images.'),
+        rewritePrompt: zod_1.z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Whether to rewrite the prompt.'),
         referenceImages: zod_1.z
             .array(zod_1.z.object({
             name: zod_1.z
@@ -3640,7 +3586,7 @@ server.registerTool('generate-video-by-ref', {
             .describe('Array of reference image objects with name, url and type. Can be empty for text-only generation.'),
         duration: zod_1.z
             .number()
-            .min(2)
+            .min(1)
             .max(16)
             .optional()
             .default(5)
@@ -3671,7 +3617,7 @@ server.registerTool('generate-video-by-ref', {
         storyBoardFile: zod_1.z
             .string()
             .optional()
-            .default('story_board.json')
+            .default('storyboard.json')
             .describe('故事板文件路径'),
         skipConsistencyCheck: zod_1.z
             .boolean()
@@ -3688,7 +3634,7 @@ server.registerTool('generate-video-by-ref', {
             .default(false)
             .describe('Whether to optimize the prompt.'),
     },
-}, async ({ prompt, referenceImages, duration, size, watermark, type, mute, saveToFileName, sceneIndex, storyBoardFile, skipConsistencyCheck, optimizePrompt, }, context) => {
+}, async ({ prompt, rewritePrompt, referenceImages, duration, size, watermark, type, mute, saveToFileName, sceneIndex, storyBoardFile, skipConsistencyCheck, optimizePrompt, }, context) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('generate-video-by-ref');
@@ -3696,17 +3642,17 @@ server.registerTool('generate-video-by-ref', {
         // 检查 storyboard 标志
         if (!checkStoryboardFlag && (0, node_fs_1.existsSync)(storyBoardPath)) {
             checkStoryboardFlag = true;
-            return createErrorResponse(`必须先审查生成的 story_board.json 内容，按照如下步骤：
+            return createErrorResponse(`必须先审查生成的 storyboard.json 内容，按照如下步骤：
 
 1. 确保每个场景中的stage_atmosphere内容按照规则被正确融合到video_prompt中，不得遗漏
 2. 如有main_characters设定且包含了reference_image，或有reference_objects，需确保video_prompt描述已包含该场景相关main_characters和所有reference_objects中的物品或背景，并确保参考图具体内容已经在video_prompt中有明确描述，如果没有，可忽略。
 3. 如有配音，先自我检查 media_logs 中的查音频时长，确保以匹配音频时长来生成视频
 
-检查完上述问题后先汇报，如果有需要，应当先修改 story_board.json 内容，然后再调用 generate-video-by-ref 生成视频。注意修改 story_board 内容时，仅修改相应字段的字符串值，不要破坏JSON格式！
+检查完上述问题后先汇报，如果有需要，应当先修改 storyboard.json 内容，然后再调用 generate-video-by-ref 生成视频。注意修改 storyboard 内容时，仅修改相应字段的字符串值，不要破坏JSON格式！
 
 再次调用 generate-video-by-ref 时，如需要参考图，要确保referenceImages使用正确（main_characters中的reference_image作为参考人物，reference_objects中的image作为参考物品或参考背景）`, 'generate-image');
         }
-        // 校验 prompt 与 story_board.json 中场景设定的一致性（如果提供了 sceneIndex）
+        // 校验 prompt 与 storyboard.json 中场景设定的一致性（如果提供了 sceneIndex）
         if (!skipConsistencyCheck && sceneIndex) {
             try {
                 if ((0, node_fs_1.existsSync)(storyBoardPath)) {
@@ -3724,7 +3670,7 @@ server.registerTool('generate-video-by-ref', {
                         if (scene) {
                             const videoPrompt = scene.video_prompt;
                             if (videoPrompt && prompt !== videoPrompt) {
-                                return createErrorResponse('视频提示词必须严格遵照story_board的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video-by-ref');
+                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video-by-ref');
                             }
                             // 检查 scene.is_continuous 是否为 true
                             if (scene.is_continuous === true) {
@@ -3791,7 +3737,7 @@ server.registerTool('generate-video-by-ref', {
                             }
                         }
                         else {
-                            console.warn(`Scene index ${sceneIndex} not found in story_board.json`);
+                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
                         }
                     }
                 }
@@ -3801,7 +3747,7 @@ server.registerTool('generate-video-by-ref', {
             }
             catch (error) {
                 console.error('Failed to validate prompt with story board:', error);
-                // 如果读取或解析 story_board.json 失败，继续执行但记录警告
+                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
             }
         }
         const validatedFileName = validateFileName(saveToFileName);
@@ -3855,14 +3801,17 @@ server.registerTool('generate-video-by-ref', {
                 url: imageUrl,
             });
             console.log(`Added reference image URL: ${imageUrl} (name: ${imageRef.name}, type: ${imageRef.type})`);
-            promptPrefix += `参考“${imageRef.name}”（图${referenceImageUrls.length}）${imageRef.type === 'subject' ? '主体形象' : '背景'}\n`;
+            if (rewritePrompt) {
+                promptPrefix += `参考“${imageRef.name}”（图${referenceImageUrls.length}）${imageRef.type === 'subject' ? '主体形象' : '背景'}\n`;
+            }
         }
         if (promptPrefix) {
             promptPrefix += '\n';
         }
+        const finalPrompt = `${promptPrefix}${prompt}`;
         // 调用 referencesToVideo 函数
         const result = await currentSession.ai.referencesToVideo({
-            prompt: `${promptPrefix}${prompt}`,
+            prompt: finalPrompt,
             reference_images: referenceImageUrls, // 使用URL数组而不是base64数组
             duration,
             size,
@@ -3905,6 +3854,8 @@ server.registerTool('generate-video-by-ref', {
                         ratio: result.ratio,
                         url: result.url,
                         last_frame_url: result.last_frame_url,
+                        referenceImageUrls,
+                        prompt: finalPrompt,
                     }, null, 2),
                 },
             ],
@@ -4026,6 +3977,166 @@ server.registerTool('extend-video-duration', {
         return createErrorResponse(error, 'extend-video');
     }
 });
+server.registerTool('generate-video-by-template', {
+    title: 'Generate Video by Template',
+    description: 'Generate a video based on a template. The template must be a valid JSON string.',
+    inputSchema: {
+        user_request: zod_1.z.string().describe('用户请求，根据意图自动匹配模板'),
+        text_prompts: zod_1.z
+            .array(zod_1.z.string().describe('Text prompt for the template to build video.'))
+            .optional()
+            .describe('Optional text prompts to use in the template.'),
+        materials: zod_1.z
+            .array(zod_1.z.string().describe('Material file name in materials directory.'))
+            .optional()
+            .describe('Optional materials to use in the template.'),
+        saveToFileName: zod_1.z
+            .string()
+            .describe('The filename to save the generated video.'),
+    },
+}, async ({ user_request, text_prompts, saveToFileName, materials }) => {
+    try {
+        const templates = [
+            {
+                id: '7569583728302817331',
+                name: '宠物唱歌',
+                description: '用一张宠物照片，生成一段宠物唱歌的视频。',
+                trigger: '根据{A图片}生成一段{宠物A}唱歌的视频',
+            },
+            {
+                id: '7569605825011367976',
+                name: '万圣节宠物弹吉他',
+                description: '用一张宠物照片，生成一段宠物弹吉他的视频。',
+                trigger: '根据{A图片}生成一段{宠物A}弹吉他的视频',
+            },
+            {
+                id: '7572443489834844223',
+                name: '图生动作模仿视频',
+                description: '用一张图片和动作视频，生成一段图片主体模仿该动作视频的新视频。',
+                trigger: '生成{A图片}模仿{B视频}的视频',
+            },
+            {
+                id: '7575160546555674670',
+                name: '文生动作模仿视频',
+                description: '用一段提示词和视频，生成一段模仿该视频的新视频。',
+                trigger: '生成一段{提示词A}模仿{B视频}的视频',
+            },
+        ];
+        const currentSession = await validateSession('generate-video-by-template');
+        const validatedFileName = validateFileName(saveToFileName);
+        const ai = currentSession.ai;
+        let completion = await ai.getCompletions({
+            model: 'Doubao-Seed-1.6',
+            messages: [
+                {
+                    role: 'system',
+                    content: `你根据用户需求，从以下模板中选择一个匹配的模板，返回模板ID：\n\n${JSON.stringify(templates)}\n\n**约束**：只输出模板ID，不需要其他解释，如果没有匹配的模版，输出"无匹配模版"`,
+                },
+                {
+                    role: 'user',
+                    content: user_request,
+                },
+            ],
+        });
+        const templateId = completion.choices[0]?.message?.content.trim();
+        if (!templateId || templateId === '无匹配模版') {
+            throw new Error('Failed to get template ID');
+        }
+        const workflowInfo = await ai.getCozeWorkflowInfo(templateId);
+        const materialUrls = materials?.map(material => getMaterialUri(currentSession, material));
+        const schema = {
+            name: 'workflow_parameters',
+            schema: {
+                type: 'object',
+                properties: {
+                    parameters: {
+                        type: 'object',
+                        description: 'The parameters for the workflow.',
+                    },
+                },
+                required: ['parameters'],
+            },
+        };
+        const prompt = `你根据模板工作流输入 schema 和 prompt、materials 生成一个 JSON 字符串，作为模板工作流的参数。
+            
+## **工作流输入 schema**：
+${JSON.stringify(workflowInfo.data.workflow_detail.description)}
+
+## **prompt**:
+${text_prompts}
+
+## **materials**：
+${JSON.stringify(materialUrls)}`;
+        // console.log(prompt);
+        completion = await ai.getCompletions({
+            model: 'Doubao-Seed-1.6-flash',
+            messages: [
+                {
+                    role: 'system',
+                    content: prompt,
+                },
+                {
+                    role: 'user',
+                    content: `生成模板调用的正确parameters参数`,
+                },
+            ],
+            response_format: {
+                type: 'json_schema',
+                json_schema: schema,
+            },
+        });
+        const parameters = completion.choices[0]?.message?.content.trim();
+        if (!parameters) {
+            throw new Error('Failed to get parameters');
+        }
+        // console.log(parameters);
+        // return {
+        //   content: [
+        //     {
+        //       type: 'text',
+        //       text: JSON.stringify({
+        //         success: true,
+        //         prompt,
+        //         templateId,
+        //         parameters,
+        //       }),
+        //     },
+        //   ],
+        // };
+        const result = await ai.runCozeWorkflow(templateId, JSON.parse(parameters).parameters);
+        if (result.url) {
+            // 保存到项目材料目录
+            const uri = await saveMaterial(currentSession, result.url, validatedFileName);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            parameters,
+                            uri,
+                        }),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: false,
+                        result,
+                        parameters,
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return createErrorResponse(error, 'generate-video-by-template');
+    }
+});
 server.registerTool('run-ffmpeg-command', {
     title: 'Run FFmpeg Command',
     description: 'Run ffmpeg or ffprobe commands in the sandbox environment. Only ffmpeg and ffprobe commands are allowed. The default working directory is the materials directory.',
@@ -4269,182 +4380,6 @@ server.registerTool('build-capcat-draft', {
         return createErrorResponse(error, 'build-capcat-draft');
     }
 });
-// server.registerTool(
-//   'custom-edit-draft',
-//   {
-//     title: 'Custom Edit Draft',
-//     description:
-//       'Launch timeline editor server for custom draft editing. Starts a local server at specified port with draft file configuration.',
-//     inputSchema: {
-//       draftContentFileName: z
-//         .string()
-//         .optional()
-//         .default('draft_content.json')
-//         .describe('Draft content filename (default: draft_content.json)'),
-//       port: z
-//         .number()
-//         .optional()
-//         .default(6789)
-//         .describe('Server port (default: 6789)'),
-//     },
-//   },
-//   async ({ draftContentFileName = 'draft_content.json', port = 6789 }) => {
-//     try {
-//       // 使用项目本地目录
-//       const workDir = resolve(
-//         process.env.ZEROCUT_PROJECT_CWD || process.cwd(),
-//         projectLocalDir
-//       );
-//       // 检查 draft_content.json 文件是否存在
-//       const draftFilePath = resolve(workDir, draftContentFileName);
-//       if (!existsSync(draftFilePath)) {
-//         return createErrorResponse(
-//           new Error(
-//             `Draft content file not found: ${draftContentFileName}. Please generate draft content first using the generate-draft-content tool.`
-//           ),
-//           'custom-edit-draft'
-//         );
-//       }
-//       // 备份原始的 draft_content.json 文件
-//       const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-//       const backupFileName = `${draftContentFileName}.backup.${timestamp}`;
-//       const backupFilePath = resolve(workDir, backupFileName);
-//       try {
-//         const { copyFileSync } = await import('fs');
-//         copyFileSync(draftFilePath, backupFilePath);
-//         console.log(`Draft file backed up to: ${backupFileName}`);
-//       } catch (backupError) {
-//         console.warn(`Failed to backup draft file: ${backupError}`);
-//         // 继续执行，不因备份失败而中断
-//       }
-//       // 构建启动命令参数
-//       const timelineEditorPath = resolve(
-//         __dirname,
-//         '../../../dist/timeline-editor/index.js'
-//       );
-//       console.log(`Starting timeline editor server...`);
-//       console.log(`Working directory: ${workDir}`);
-//       console.log(`Draft file: ${draftContentFileName}`);
-//       console.log(`Server port: ${port}`);
-//       console.log(`Timeline editor path: ${timelineEditorPath}`);
-//       // 检查端口是否被占用，如果被占用则停止占用的进程
-//       if (await isPortInUse(port)) {
-//         console.log(`Port ${port} is in use, killing existing processes...`);
-//         await killPortProcess(port);
-//       }
-//       // 直接启动服务器进程
-//       const platform = os.platform();
-//       const nodeCommand = platform === 'win32' ? 'node.exe' : 'node';
-//       const serverProcess = spawn(
-//         nodeCommand,
-//         [
-//           timelineEditorPath,
-//           '--draft-file',
-//           draftContentFileName,
-//           '--project-dir',
-//           workDir,
-//           '--port',
-//           port.toString(),
-//         ],
-//         {
-//           cwd: workDir,
-//           stdio: 'pipe',
-//           shell: platform === 'win32', // 在 Windows 下使用 shell
-//         }
-//       );
-//       const serverUrl = `http://localhost:${port}`;
-//       // 等待服务器启动 - 使用健康检查 API 轮询
-//       await new Promise((resolve, reject) => {
-//         const timeout = setTimeout(() => {
-//           reject(new Error('Server startup timeout'));
-//         }, 30000); // 增加超时时间到30秒
-//         const checkHealth = async () => {
-//           try {
-//             const healthUrl = `${serverUrl}/health`;
-//             const req = http.get(healthUrl, (res: any) => {
-//               let data = '';
-//               res.on('data', (chunk: any) => {
-//                 data += chunk;
-//               });
-//               res.on('end', () => {
-//                 try {
-//                   const healthData = JSON.parse(data);
-//                   if (healthData.status === 'ok') {
-//                     clearTimeout(timeout);
-//                     console.log('Server health check passed');
-//                     resolve(void 0);
-//                   } else {
-//                     // 继续轮询
-//                     setTimeout(checkHealth, 1000);
-//                   }
-//                 } catch (parseError) {
-//                   // 继续轮询
-//                   setTimeout(checkHealth, 1000);
-//                 }
-//               });
-//             });
-//             req.on('error', () => {
-//               // 服务器还未启动，继续轮询
-//               setTimeout(checkHealth, 1000);
-//             });
-//             req.setTimeout(2000, () => {
-//               req.destroy();
-//               // 继续轮询
-//               setTimeout(checkHealth, 1000);
-//             });
-//           } catch (error) {
-//             // 继续轮询
-//             setTimeout(checkHealth, 1000);
-//           }
-//         };
-//         serverProcess.stdout?.on('data', (data: any) => {
-//           console.log('Server output:', data.toString());
-//         });
-//         serverProcess.stderr?.on('data', (data: any) => {
-//           console.error('Server error:', data.toString());
-//         });
-//         serverProcess.on('error', (error: any) => {
-//           clearTimeout(timeout);
-//           reject(error);
-//         });
-//         // 开始健康检查轮询
-//         setTimeout(checkHealth, 2000); // 2秒后开始第一次检查
-//       });
-//       return {
-//         content: [
-//           {
-//             type: 'text',
-//             text: JSON.stringify(
-//               {
-//                 success: true,
-//                 message: 'Timeline editor server started successfully',
-//                 serverUrl: serverUrl,
-//                 draftFile: draftContentFileName,
-//                 backupFile: backupFileName,
-//                 projectDirectory: workDir,
-//                 port: port,
-//                 pid: serverProcess.pid,
-//                 instructions: [
-//                   `Timeline editor is now running at: ${serverUrl}`,
-//                   'Open the URL in your browser to edit the draft',
-//                   'The server will automatically save changes to the draft file',
-//                   `Original draft file has been backed up as: ${backupFileName}`,
-//                   `Server process ID: ${serverProcess.pid}`,
-//                   'The server will continue running in the background',
-//                 ],
-//               },
-//               null,
-//               2
-//             ),
-//           },
-//         ],
-//       };
-//     } catch (error) {
-//       console.error('Error starting timeline editor:', error);
-//       return createErrorResponse(error, 'custom-edit-draft');
-//     }
-//   }
-// );
 async function run() {
     // Start receiving messages on stdin and sending messages on stdout
     const transport = new stdio_js_1.StdioServerTransport();