cerevox 4.0.0-alpha.3 → 4.0.0-alpha.31

package/dist/mcp/servers/zerocut.js

@@ -54,6 +54,7 @@ const node_fs_1 = require("node:fs");
 const mp3_duration_1 = __importDefault(require("mp3-duration"));
 const image_size_1 = __importDefault(require("image-size"));
 const seed_1 = require("../../utils/seed");
+const uuid_1 = require("uuid");
 function createErrorResponse(error, operation, details) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error(`[${operation}] Error:`, error);
@@ -140,6 +141,8 @@ async function saveMaterial(session, url, saveToFileName) {
     const terminal = session.terminal;
     const saveToPath = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials/${saveToFileName}`;
     const saveLocalPath = (0, node_path_1.resolve)(projectLocalDir, 'materials', saveToFileName);
+    // 确保目录存在
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(saveLocalPath), { recursive: true });
     // 先下载到本地，再上传 sandbox，比直接 sandbox 更好，也以免下载超时
     // 通过 fetch 下载到本地
     const res = await fetch(url);
@@ -320,6 +323,24 @@ async function listFiles(dir) {
     const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
     return entries.filter(e => e.isFile()).map(e => (0, node_path_1.resolve)(dir, e.name));
 }
+function checkModelEnabled(model) {
+    // 检查是否是许可的模型
+    if (!process.env.ENABLED_MODELS) {
+        return true;
+    }
+    const enabledModels = process.env.ENABLED_MODELS.split(/\s*,\s*/g);
+    if (!enabledModels.includes(model)) {
+        throw new Error(`Type ${model} is not enabled. Use any model in ${JSON.stringify(enabledModels)} instead.`);
+    }
+    return true;
+}
+function checkSkillEnabled(skillName) {
+    if (!process.env.ENABLED_SKILLS) {
+        return true;
+    }
+    const enabledSkills = process.env.ENABLED_SKILLS.split(/\s*,\s*/g);
+    return enabledSkills.includes(skillName);
+}
 // Create an MCP server
 const server = new mcp_js_1.McpServer({
     name: 'Cerevox Server',
@@ -330,18 +351,18 @@ const cerevox = new index_1.default({
     logLevel: 'error',
 });
 let session = null;
-let projectLocalDir = process.env.ZEROCUT_PROJECT_CWD || process.cwd() || '.';
-let checkStoryboardFlag = false;
-let checkAudioVideoDurationFlag = false;
-// let checkStoryboardSubtitlesFlag = false;
+let projectLocalDir = process.env.ZEROCUT_PROJECT_CWD ||
+    `${(0, node_path_1.resolve)(process.env.ZEROCUT_WORKSPACE_DIR, (0, uuid_1.v4)())}` ||
+    '.';
 let closeSessionTimerId = null;
+const CLIENT_TYPE = process.env.CLIENT_TYPE || 'trae';
 // 注册 ZeroCut 指导规范 Prompt
 server.registerPrompt('zerocut-guideline', {
     title: 'ZeroCut 短视频创作指导规范',
     description: '专业的短视频创作 Agent 指导规范，包含完整的工作流程、工具说明和质量建议',
 }, async () => {
     try {
-        const promptPath = (0, node_path_1.resolve)(__dirname, './prompts/zerocut-core-web.md');
+        const promptPath = (0, node_path_1.resolve)(__dirname, './prompts/zerocut-core.md');
         const promptContent = await (0, promises_1.readFile)(promptPath, 'utf-8');
         return {
             messages: [
@@ -362,25 +383,23 @@ server.registerPrompt('zerocut-guideline', {
 });
 server.registerTool('project-open', {
     title: 'Open Project',
-    description: 'Launch a new Cerevox session with a Chromium browser instance and open a new project context. Supports smart file filtering to optimize upload performance.',
+    description: 'Launch a new Cerevox session with a Chromium browser instance and open a new project context. Supports smart file filtering to optimize resource-sync performance.',
     inputSchema: {
-        localDir: zod_1.z
+        projectName: zod_1.z
             .string()
-            .optional()
-            .default('.')
-            .describe('The path of the file to upload.'),
+            .describe('项目名，命名规则如同命名文件，可以用空格，但不得使用特殊字符（如/、:等），如果你知晓当前目录，必须用当前目录的最后一级目录名作为项目名，否则根据用户需求自定义项目名'),
         tosFiles: zod_1.z
             .array(zod_1.z.string())
             .optional()
             .default([])
             .describe('对象存储系统中的持久化文件，不通过本地直接下载到项目目录，可选参数'),
-        uploadAllFiles: zod_1.z
+        syncAllFiles: zod_1.z
             .boolean()
             .optional()
             .default(false)
-            .describe('Whether to upload all files without filtering. If true, skips the smart filtering logic.'),
+            .describe('Whether to sync all resources without filtering. If true, skips the smart filtering logic.'),
     },
-}, async ({ localDir, uploadAllFiles, tosFiles }, context) => {
+}, async ({ projectName, syncAllFiles, tosFiles }, context) => {
     try {
         if (closeSessionTimerId) {
             clearTimeout(closeSessionTimerId);
@@ -388,12 +407,9 @@ server.registerTool('project-open', {
         }
         // 检查是否已有活跃session
         if (session) {
-            console.warn('Session already exists, closing previous session');
-            // try {
-            //   await session.close();
-            // } catch (closeError) {
-            //   console.warn('Failed to close previous session:', closeError);
-            // }
+            if (session.projectName !== projectName) {
+                return createErrorResponse('project-open', `Another project is already open: ${session.projectName}，Ask user to close it first.`);
+            }
             const result = {
                 success: true,
                 sessionId: session.id,
@@ -424,10 +440,20 @@ server.registerTool('project-open', {
         if (!session) {
             throw new Error('Failed to create Cerevox session');
         }
+        // 保存项目名到session
+        session.projectName = projectName;
         console.log('Initializing project...');
         const workDir = await initProject(session);
-        projectLocalDir = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), localDir || '.');
+        if (!process.env.ZEROCUT_PROJECT_CWD &&
+            !process.env.ZEROCUT_WORKSPACE_DIR) {
+            throw new Error('ZEROCUT_WORKSPACE_DIR environment variable is required');
+        }
+        projectLocalDir = process.env.ZEROCUT_PROJECT_CWD
+            ? (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD, '.')
+            : (0, node_path_1.resolve)(process.env.ZEROCUT_WORKSPACE_DIR, projectName);
         const syncDir = (0, node_path_1.resolve)(projectLocalDir, 'materials');
+        // 保证项目目录存在
+        await (0, promises_1.mkdir)(projectLocalDir, { recursive: true });
         try {
             await (0, promises_1.mkdir)(syncDir, { recursive: true });
         }
@@ -439,39 +465,37 @@ server.registerTool('project-open', {
         // 文件过滤逻辑
         let filesToUpload = [];
         let skippedFiles = [];
-        if (localDir) {
-            try {
-                materials = await listFiles(syncDir);
-            }
-            catch (listError) {
-                console.warn('Failed to list materials:', listError);
-                materials = [];
-            }
-            if (uploadAllFiles) {
-                // 如果 uploadAllFiles 为 true，跳过智能过滤，上传所有文件
-                filesToUpload = materials;
-                skippedFiles = [];
-            }
-            else {
-                // 智能文件过滤逻辑
-                const filterResult = await filterMaterialsForUpload(materials, projectLocalDir);
-                filesToUpload = filterResult.filesToUpload;
-                skippedFiles = filterResult.skippedFiles;
-            }
+        try {
+            materials = await listFiles(syncDir);
+        }
+        catch (listError) {
+            console.warn('Failed to list materials:', listError);
+            materials = [];
+        }
+        if (syncAllFiles) {
+            // 如果 syncAllFiles 为 true，跳过智能过滤，上传所有文件
+            filesToUpload = materials;
+            skippedFiles = [];
+        }
+        else {
+            // 智能文件过滤逻辑
+            const filterResult = await filterMaterialsForUpload(materials, projectLocalDir);
+            filesToUpload = filterResult.filesToUpload;
+            skippedFiles = filterResult.skippedFiles;
         }
         const files = session.files;
         let progress = 0;
-        const uploadErrors = [];
+        const syncErrors = [];
         const totalFiles = filesToUpload.length + tosFiles.length;
         for (const material of filesToUpload) {
             try {
                 await files.upload(material, `${workDir}/materials/${(0, node_path_1.basename)(material)}`);
                 await sendProgress(context, ++progress, totalFiles, material);
             }
-            catch (uploadError) {
-                const errorMsg = `Failed to upload ${material}: ${uploadError}`;
+            catch (syncError) {
+                const errorMsg = `Failed to sync ${material}: ${syncError}`;
                 console.error(errorMsg);
-                uploadErrors.push(errorMsg);
+                syncErrors.push(errorMsg);
             }
         }
         for (const tosFile of tosFiles) {
@@ -480,10 +504,10 @@ server.registerTool('project-open', {
                 await session.terminal.run(`wget -O ${workDir}/materials/${(0, node_path_1.basename)(url.pathname)} ${tosFile}`);
                 await sendProgress(context, ++progress, totalFiles, tosFile);
             }
-            catch (uploadError) {
-                const errorMsg = `Failed to upload ${tosFile}: ${uploadError}`;
+            catch (syncError) {
+                const errorMsg = `Failed to sync ${tosFile}: ${syncError}`;
                 console.error(errorMsg);
-                uploadErrors.push(errorMsg);
+                syncErrors.push(errorMsg);
             }
         }
         const result = {
@@ -491,11 +515,12 @@ server.registerTool('project-open', {
             nextActionSuggest: '检查规则上下文是否已召回，若未召回，调用 retrieve_rules 工具召回规则上下文',
             sessionId: session.id,
             workDir,
+            projectName,
             projectLocalDir,
             materials,
-            uploadedFiles: filesToUpload.map(file => (0, node_path_1.basename)(file)),
+            syncedFiles: filesToUpload.map(file => (0, node_path_1.basename)(file)),
             skippedFiles: skippedFiles.map(file => (0, node_path_1.basename)(file)),
-            uploadErrors: uploadErrors.length > 0 ? uploadErrors : undefined,
+            syncErrors: syncErrors.length > 0 ? syncErrors : undefined,
         };
         return {
             content: [
@@ -521,7 +546,7 @@ server.registerTool('project-close', {
             .min(0)
             .max(20)
             .default(5)
-            .describe('Close the session after the specified number of minutes. Default is 5 minutes. 除非用户要求立即关闭会话，将该参数设置为0，否则应默认设为5'),
+            .describe('Close the session after the specified number of minutes. Default is 5 minutes. 当用户主动要求关闭会话时，将该参数设置为0，否则应默认设为5'),
     },
 }, async ({ inMinutes }) => {
     try {
@@ -578,9 +603,9 @@ server.registerTool('retrieve-rules-context', {
     }
     else {
         // 当 projectRulesFile 不存在时，设置 checkStoryboardFlag 为 false
-        checkStoryboardFlag = false;
+        // checkStoryboardFlag = false;
         // 当 projectRulesFile 不存在时，设置 checkAudioVideoDurationFlag 为 false
-        checkAudioVideoDurationFlag = false;
+        // checkAudioVideoDurationFlag = false;
     }
     try {
         const ai = currentSession.ai;
@@ -593,7 +618,8 @@ server.registerTool('retrieve-rules-context', {
             await (0, promises_1.writeFile)(projectRulesFile, promptContent);
         }
         if (!(0, node_fs_1.existsSync)(skillsIndexFile)) {
-            const skills = rules.filter((rule) => rule.name.startsWith('skill-'));
+            const skills = rules.filter((rule) => rule.name.startsWith('skill-') &&
+                checkSkillEnabled(rule.name.slice(6)));
             const skillsList = skills.map((skill) => `## ${skill.name}
 ${skill.trigger}
 `);
@@ -636,8 +662,8 @@ server.registerTool('upload-custom-material', {
     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());
+        // 构建本地文件路径，使用 projectLocalDir
+        const validatedPath = (0, node_path_1.resolve)(projectLocalDir, 'materials', localFileName.trim());
         // 验证本地文件存在性
         if (!(0, node_fs_1.existsSync)(validatedPath)) {
             throw new Error(`File not found: ${validatedPath}`);
@@ -711,7 +737,7 @@ server.registerTool('upload-custom-material', {
     }
 });
 server.registerTool('wait-for-task-finish', {
-    title: 'Wait Workflow or VideoTask Done；只有正在运行Coze工作流或者有异步生成视频任务时才需要执行这个工具;⚠️ 如果执行这个工具未失败只是超时，你应立即再次重新调用，以继续等待直到任务完成或失败',
+    title: 'Wait Workflow or VideoTask Done；只有正在运行Coze工作流或者有异步生成视频任务时才需要执行这个工具;⚠️ 如果执行这个工具未失败只是超时，你应立即再次重新调用，以继续等待直到任务完成或失败；‼️ 有的任务执行时间需要很长，所以如果只是超时不是失败，重试多少次都是正常的，请耐心等待即可。',
     description: 'Wait for a workflow to complete.',
     inputSchema: {
         taskUrl: zod_1.z
@@ -767,6 +793,32 @@ server.registerTool('wait-for-task-finish', {
             catch (error) {
                 console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
             }
+            if (res.data?.scenes) {
+                const { scenes, video_type, voice_type, voiceover_tone, bgm_prompt, video_model, aspect_ratio, } = res.data;
+                const seed = (0, seed_1.getRandomSeed)();
+                const orientation = aspect_ratio === '16:9' ? 'landscape' : 'portrait';
+                const storyboard = {
+                    orientation,
+                    video_type,
+                    outline_sheet: 'outline_sheet.png',
+                    bgm_prompt,
+                    voice_type,
+                    scenes: scenes.map((scene) => {
+                        let video_prompt = scene.video_prompt;
+                        if (voiceover_tone && video_prompt.includes('画外音')) {
+                            video_prompt = video_prompt.replace(/画外音[：:]/g, `画外音（${voiceover_tone}）：`);
+                        }
+                        return {
+                            ...scene,
+                            video_prompt,
+                            use_video_model: video_model,
+                            seed,
+                        };
+                    }),
+                };
+                const saveLocalPath = (0, node_path_1.resolve)(projectLocalDir, 'storyboard.json');
+                await (0, promises_1.writeFile)(saveLocalPath, JSON.stringify(storyboard, null, 2));
+            }
             return {
                 content: [
                     {
@@ -839,6 +891,7 @@ server.registerTool('generate-character-image', {
     try {
         // 验证session状态
         const currentSession = await validateSession('generate-character-image');
+        checkModelEnabled(type);
         const validatedFileName = validateFileName(saveToFileName);
         // 根据 isTurnaround 参数生成不同的提示词和尺寸
         let prompt;
@@ -932,7 +985,7 @@ ${roleDescriptionPrompt}
                     ? referenceImage
                     : `./materials/${referenceImage}`;
                 // 需要得到当前项目的绝对路径
-                const imageFilePath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, imagePath);
+                const imageFilePath = (0, node_path_1.resolve)(projectLocalDir, imagePath);
                 // 读取图片文件内容
                 const imageBuffer = await (0, promises_1.readFile)(imageFilePath);
                 const fileName = (0, node_path_1.basename)(imagePath);
@@ -1026,20 +1079,6 @@ server.registerTool('generate-image', {
             .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，必须要传这个参数'),
         size: zod_1.z
             .enum([
             '1024x1024',
@@ -1124,15 +1163,17 @@ server.registerTool('generate-image', {
 \`\`\`
           `),
     },
-}, async ({ type = 'seedream', prompt, sceneIndex, storyBoardFile = 'storyboard.json', skipConsistencyCheck = false, size = '720x1280', imageCount = 1, saveToFileNames, watermark, referenceImages, }, context) => {
+}, async ({ type = 'seedream', prompt, sceneIndex, size = '720x1280', imageCount = 1, saveToFileNames, watermark, referenceImages, }, context) => {
     try {
+        const storyBoardFile = 'storyboard.json';
         // 验证session状态
         const currentSession = await validateSession('generate-image');
-        const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
-        const outlineSheetImagePath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'materials', 'outline_sheet.png');
+        checkModelEnabled(type);
+        const storyBoardPath = (0, node_path_1.resolve)(projectLocalDir, storyBoardFile);
+        const outlineSheetImagePath = (0, node_path_1.resolve)(projectLocalDir, 'materials', 'outline_sheet.png');
         const hasOutlineSheet = (0, node_fs_1.existsSync)(outlineSheetImagePath);
         // 校验 prompt 与 storyboard.json 中分镜设定的一致性
-        if (sceneIndex && !skipConsistencyCheck) {
+        if (sceneIndex) {
             try {
                 if ((0, node_fs_1.existsSync)(storyBoardPath)) {
                     const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
@@ -1151,7 +1192,7 @@ server.registerTool('generate-image', {
                             const endFrame = scene.end_frame;
                             // 检查 prompt 是否严格等于 start_frame 或 end_frame
                             if (prompt !== startFrame && prompt !== endFrame) {
-                                return createErrorResponse('图片提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-image');
+                                return createErrorResponse('图片提示词必须严格遵照storyboard的设定', 'generate-image');
                             }
                             if (hasOutlineSheet &&
                                 (!referenceImages ||
@@ -1235,7 +1276,7 @@ server.registerTool('generate-image', {
                     ? refImage.image
                     : `./materials/${refImage.image}`;
                 // 需要得到当前项目的绝对路径
-                const imageFilePath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, imagePath);
+                const imageFilePath = (0, node_path_1.resolve)(projectLocalDir, imagePath);
                 try {
                     // 直接读取本地文件
                     if (!(0, node_fs_1.existsSync)(imageFilePath)) {
@@ -1296,7 +1337,7 @@ ${processedPrompt}`.trim();
             }
         }
         const ai = currentSession.ai;
-        const { taskUrl } = await ai.generateImage({
+        const taskRes = await ai.generateImage({
             type,
             prompt: processedPrompt,
             size,
@@ -1304,6 +1345,10 @@ ${processedPrompt}`.trim();
             image: imageBase64Array,
             async: true,
         });
+        const taskUrl = taskRes.taskUrl;
+        if (!taskUrl) {
+            return createErrorResponse(`Failed to generate image: ${taskRes.error || JSON.stringify(taskRes)}`, 'generate-image');
+        }
         let progress = 0;
         const res = await ai.waitForTaskComplete({
             taskUrl,
@@ -1444,7 +1489,7 @@ server.registerTool('edit-image', {
             ? sourceImageFileName
             : `./materials/${sourceImageFileName}`;
         // 需要得到当前项目的绝对路径
-        const imageFilePath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, imagePath);
+        const imageFilePath = (0, node_path_1.resolve)(projectLocalDir, imagePath);
         if (!(0, node_fs_1.existsSync)(imageFilePath)) {
             return createErrorResponse(`Reference image not found: ${imageFilePath}`, 'edit-image');
         }
@@ -1512,9 +1557,9 @@ server.registerTool('edit-image', {
         return createErrorResponse(error, 'edit-image');
     }
 });
-server.registerTool('generate-short-video-outlines', {
-    title: 'Generate Short Video Outlines',
-    description: `根据用户描述生成短视频的大纲；执行本工具会自动创建两个文件，一个是storyboard.json，一个是outline_sheet.png，前者是分镜设置，后者是分镜宫格图`,
+server.registerTool('generate-video-outlines', {
+    title: 'Generate Video Outlines',
+    description: `根据用户描述生成短视频的大纲；执行本工具会自动创建两个文件，一个是storyboard.json，一个是outline_sheet.png，前者是分镜设置，后者是分镜宫格图，其中outline_sheet.png生成于materials目录下，storyboard.json生成于materials的上级目录。`,
     inputSchema: {
         prompt: zod_1.z
             .string()
@@ -1550,10 +1595,11 @@ server.registerTool('generate-short-video-outlines', {
             .default('pro')
             .describe('除非用户主动提出使用其他模型，否则一律用pro模型'),
     },
-}, async ({ prompt, voiceType, language, images, orientation, model }) => {
+}, async ({ prompt, voiceType, language, images, orientation, model }, context) => {
     try {
         // 验证session状态
-        const currentSession = await validateSession('generate-short-video-outlines');
+        const currentSession = await validateSession('generate-video-outlines');
+        let progress = 0;
         const ai = currentSession.ai;
         const res = await ai.generateShortVideoOutlines({
             prompt,
@@ -1562,6 +1608,15 @@ server.registerTool('generate-short-video-outlines', {
             images,
             videoModel: model,
             aspectRatio: orientation === 'portrait' ? '9:16' : '16:9',
+            onProgress: async (metaData) => {
+                try {
+                    await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
+                }
+                catch (progressError) {
+                    console.warn('Failed to send progress update:', progressError);
+                }
+            },
+            waitForFinish: CLIENT_TYPE !== '5ire',
         });
         if (!res) {
             throw new Error('Failed to generate short video outlines: no response from AI service');
@@ -1573,7 +1628,7 @@ server.registerTool('generate-short-video-outlines', {
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
-                            message: '该任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
+                            message: '该任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish (saveFileName=outline_sheet.png) 来等待任务结束，如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
                             taskUrl: res.taskUrl,
                         }),
                     },
@@ -1583,7 +1638,7 @@ server.registerTool('generate-short-video-outlines', {
         else if (res.url) {
             const url = res.url;
             await saveMaterial(currentSession, url, 'outline_sheet.png');
-            const { scenes, video_type, voice_type, voiceover_tone, bgm_prompt } = res.data || {};
+            const { scenes, video_type, voice_type, voiceover_tone, bgm_prompt, video_model, } = res.data || {};
             const seed = (0, seed_1.getRandomSeed)();
             const storyboard = {
                 orientation,
@@ -1593,19 +1648,13 @@ server.registerTool('generate-short-video-outlines', {
                 voice_type,
                 scenes: scenes.map((scene) => {
                     let video_prompt = scene.video_prompt;
-                    if (video_prompt.includes('画外音') ||
-                        video_prompt.toLowerCase().includes('voiceover')) {
-                        if (voiceover_tone) {
-                            video_prompt = video_prompt.replace(/画外音[：:]\s*“([^”]*)”/g, `画外音（${voiceover_tone}）镜头内所有角色都不言语，从远处传来广播声<广播开始>$1——</广播结束>`);
-                        }
-                        else {
-                            video_prompt = video_prompt.replace(/画外音[：:]\s*“([^”]*)”/g, `镜头内所有角色都不言语，从远处传来广播声<广播开始>$1——</广播结束>`);
-                        }
+                    if (voiceover_tone && video_prompt.includes('画外音')) {
+                        video_prompt = video_prompt.replace(/画外音[：:]/g, `画外音（${voiceover_tone}）：`);
                     }
                     return {
                         ...scene,
                         video_prompt,
-                        use_video_model: model,
+                        use_video_model: video_model,
                         seed,
                     };
                 }),
@@ -1640,7 +1689,7 @@ server.registerTool('generate-short-video-outlines', {
         };
     }
     catch (error) {
-        return createErrorResponse(error, 'generate-short-video-outlines');
+        return createErrorResponse(error, 'generate-video-outlines');
     }
 });
 server.registerTool('generate-music-or-mv', {
@@ -1959,26 +2008,12 @@ server.registerTool('generate-video', {
     inputSchema: {
         prompt: zod_1.z
             .string()
-            .describe('The prompt to generate. 一般要严格对应 storyboard 中当前分镜的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
+            .describe('The prompt 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，必须要传这个参数'),
         type: zod_1.z
             .enum([
             'pro',
@@ -2039,10 +2074,11 @@ server.registerTool('generate-video', {
             .default(false)
             .describe('Whether to optimize the prompt.'),
     },
-}, 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, sceneIndex, saveToFileName, start_frame, end_frame, duration, resolution, type = 'vidu', optimizePrompt, saveLastFrameAs, mute = true, seed, }, context) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('generate-video');
+        checkModelEnabled(type);
         const isZeroModel = type.startsWith('zero');
         if (!start_frame && !isZeroModel) {
             return createErrorResponse('start_frame 不能为空', 'generate-video');
@@ -2060,10 +2096,11 @@ server.registerTool('generate-video', {
             console.warn(`zero 模型的视频仅支持 1080p 分辨率，用户指定的分辨率为 %s，已自动将 ${resolution} 转换为 1080p`, resolution);
             resolution = '1080p';
         }
+        const storyBoardFile = 'storyboard.json';
         // 校验 prompt 与 storyboard.json 中分镜设定的一致性
-        if (sceneIndex && !skipConsistencyCheck) {
+        if (sceneIndex) {
             try {
-                const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
+                const storyBoardPath = (0, node_path_1.resolve)(projectLocalDir, storyBoardFile);
                 if ((0, node_fs_1.existsSync)(storyBoardPath)) {
                     const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
                     // 检查 storyBoard JSON 语法合法性
@@ -2079,26 +2116,26 @@ server.registerTool('generate-video', {
                         if (scene) {
                             const videoPrompt = scene.video_prompt;
                             if (videoPrompt && prompt !== videoPrompt) {
-                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定', 'generate-video');
                             }
                             if (scene.is_continuous && !end_frame) {
-                                return createErrorResponse('连续分镜必须指定end_frame参数，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                                return createErrorResponse('连续分镜必须指定end_frame参数', 'generate-video');
                             }
                             if (scene.video_duration != null &&
                                 duration !== scene.video_duration) {
-                                return createErrorResponse(`视频时长必须严格遵照storyboard的设定，用户指定的时长为 ${duration} 秒，而 storyboard 中建议的时长为 ${scene.video_duration} 秒。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用`, 'generate-video');
+                                return createErrorResponse(`视频时长必须严格遵照storyboard的设定，storyboard 中设定的时长为 ${scene.video_duration} 秒。`, 'generate-video');
                             }
                             if (storyBoard.voice_type &&
                                 storyBoard.voice_type !== 'slient') {
                                 if (mute) {
-                                    return createErrorResponse('有对话和旁白的分镜不能静音，请将mute设为false再重新使用工具。如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video');
+                                    return createErrorResponse('有对话和旁白的分镜不能静音，请将mute设为false再重新使用工具。', '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');
+                                return createErrorResponse(`分镜建议的视频模型(${scene.use_video_model})与传入的type参数(${type})不一致。请确保use_video_model与type参数值相同。`, 'generate-video');
                             }
                         }
                         else {
@@ -2232,7 +2269,7 @@ server.registerTool('generate-video', {
                 },
             };
             const analysisPayload = {
-                model: 'Doubao-Seed-1.6-flash',
+                model: 'Doubao-Seed-1.8',
                 messages: [
                     {
                         role: 'system',
@@ -2367,7 +2404,7 @@ server.registerTool('generate-video', {
                     console.warn('Failed to send progress update:', progressError);
                 }
             },
-            waitForFinish: type !== 'zero',
+            waitForFinish: type !== 'zero' && CLIENT_TYPE !== '5ire',
             mute,
             seed,
         });
@@ -2450,38 +2487,47 @@ server.registerTool('edit-video', {
     title: 'Edit Video',
     description: `Edit video using Coze workflow，可以做以下事情：
 
-- 替换视频内容，type 为 replace
+- 编辑视频（增加、修改、删除视频中的内容），type 为 edit
+- 参考视频动作和特效，type 也为 edit
 - 视频对口型，type 为 lipsync
-- 视频动作模仿，type 为 imitate
+
+‼️ 故障排查
+如果出错，依次检查以下事项：
+
+1. 视频是否太长（超过了8秒）或太大（超过了100M）
+2. 视频像素过小（小于128x128）或宽高比太悬殊（大于1:4）
+3. 视频格式是否是 mp4
 `,
     inputSchema: {
         type: zod_1.z
-            .enum(['replace', 'lipsync', 'imitate'])
+            .enum(['edit', 'lipsync'])
+            .default('edit')
             .describe('The editing type'),
         video: zod_1.z.string().describe(`The video to edit
 
-- type 为 replace 时，video 为要替换内容的视频
+- type 为 edit 时，video 为要编辑的视频
 - type 为 lipsync 时，video 为要对口型的视频 
-- type 为 imitate 时，video 为模仿动作参考视频
 `),
         prompt: zod_1.z.string().optional()
-            .describe(`The editing prompt, 如实转述用户需求即可，**不**添加其他任何信息如视频规格等，本工具会自己优化
+            .describe(`The editing prompt, 如实转述用户需求即可
 
-- type 为 replace 时，prompt 为要替换的内容
+要求：
+1）用**极简的话语**准确描述，不添加其他任何补充信息，本工具会自己优化
+2）video一律用“视频1”指代
+
+- type 为 edit 时，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 二选一
+        referenceImages: zod_1.z.array(zod_1.z.string()).optional()
+            .describe(`The reference image Files for editing
+- type 为 edit 时，referenceImages 为参考图片（1-7张）
+- type 为 lipsync 时，referenceImages 为空
 `),
         saveToFileName: zod_1.z
             .string()
             .describe(`The file name to save the edited video to. 应该是mp4文件`),
     },
-}, async ({ type, video, prompt, referenceImage, saveToFileName }, context) => {
+}, async ({ type, video, prompt, referenceImages, saveToFileName }, context) => {
     try {
         const currentSession = await validateSession('edit-video');
         const ai = currentSession.ai;
@@ -2498,19 +2544,33 @@ server.registerTool('edit-video', {
             }
         };
         let referenceImageUrl = undefined;
-        if (referenceImage) {
-            referenceImageUrl = getMaterialUri(currentSession, referenceImage);
+        let referenceImageUrls = undefined;
+        if (referenceImages) {
+            referenceImageUrls = referenceImages.map(fileName => getMaterialUri(currentSession, fileName));
+            referenceImageUrl = referenceImageUrls[0];
         }
         const videoUrl = getMaterialUri(currentSession, video);
-        if (type === 'replace') {
+        if (type === 'edit') {
             if (!prompt) {
-                throw new Error('prompt is required for replace type');
+                throw new Error('prompt is required for edit type');
             }
-            res = await ai.editVideo({
-                videoUrl,
+            // res = await ai.editVideo({
+            //   videoUrl,
+            //   prompt,
+            //   referenceImageUrl,
+            //   onProgress,
+            //   waitForFinish: CLIENT_TYPE !== '5ire',
+            // });
+            res = await ai.referencesToVideo({
                 prompt,
-                referenceImageUrl,
+                duration: 0,
+                type: 'vidu-pro', //'vidu', //'pixv', // 'lite', // 'sora2',
+                reference_images: referenceImageUrls,
+                videos: [videoUrl],
                 onProgress,
+                waitForFinish: CLIENT_TYPE !== '5ire',
+                // aspect_ratio: '9:16',
+                // mute: true,
             });
         }
         else if (type === 'lipsync') {
@@ -2525,23 +2585,7 @@ server.registerTool('edit-video', {
                 audioInMs: 0,
                 pad_audio: false,
                 onProgress,
-            });
-        }
-        else if (type === 'imitate') {
-            if (!prompt && !referenceImageUrl) {
-                throw new Error('prompt or referenceImageUrl is required for imitate type');
-            }
-            if (prompt) {
-                referenceImageUrl = (await ai.generateImage({
-                    prompt,
-                    type: 'banana',
-                    image: referenceImageUrl ? [referenceImageUrl] : undefined,
-                })).url;
-            }
-            res = await ai.actionImitation({
-                videoUrl,
-                imageUrl: referenceImageUrl,
-                onProgress,
+                waitForFinish: CLIENT_TYPE !== '5ire',
             });
         }
         if (res.url) {
@@ -2750,11 +2794,15 @@ server.registerTool('audio-video-sync', {
             .describe('The volume of video audio. 0.0 to 2.0.'),
         loopAudio: zod_1.z.boolean().optional().default(true),
         addSubtitles: zod_1.z.boolean().optional().default(false),
+        subtitlesContext: zod_1.z
+            .string()
+            .optional()
+            .describe('字幕的参考上下文（非必需），用于提升字幕准确性'),
         saveToFileName: zod_1.z
             .string()
             .describe('The filename to save the audio-video-synced video. 应该是mp4文件'),
     },
-}, async ({ videos, audio, audioInMs, audioFadeOutMs, audioVolume, videoAudioVolume, saveToFileName, loopAudio, addSubtitles, }, context) => {
+}, async ({ videos, audio, audioInMs, audioFadeOutMs, audioVolume, videoAudioVolume, saveToFileName, loopAudio, addSubtitles, subtitlesContext, }, context) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('audio-video-sync');
@@ -2788,6 +2836,7 @@ server.registerTool('audio-video-sync', {
             videoAudioVolume,
             loopAudio,
             subtitles: addSubtitles,
+            subtitlesContext,
         });
         if (result.url) {
             console.log('Audio sync completed successfully');
@@ -2835,12 +2884,7 @@ server.registerTool('generate-video-by-ref', {
     inputSchema: {
         prompt: zod_1.z
             .string()
-            .describe('The prompt to generate video with or without reference images. 一般要严格对应 storyboard 中当前分镜的 video_prompt 字段描述；传这个参数时，若跳过了一致性检查，记得保留镜头切换语言，如“切镜至第二镜头”这样的指令不应当省略。'),
-        rewritePrompt: zod_1.z
-            .boolean()
-            .optional()
-            .default(true)
-            .describe('Whether to rewrite the prompt.'),
+            .describe('The prompt to generate video with or without reference images. 尽量忠于用户的原始需求，除非用户明确要求协助优化，否则不要擅自发挥！'),
         referenceImages: zod_1.z
             .array(zod_1.z.object({
             name: zod_1.z
@@ -2854,18 +2898,30 @@ server.registerTool('generate-video-by-ref', {
             .optional()
             .default([])
             .describe('Array of reference image objects with name, url and type. Can be empty for text-only generation.'),
+        referenceVideo: zod_1.z
+            .object({
+            name: zod_1.z
+                .string()
+                .describe('Reference video file name in materials directory'),
+            fileName: zod_1.z.string().describe('Reference video file name'),
+            type: zod_1.z.enum(['video']).describe('Type of reference: video'),
+        })
+            .optional()
+            .describe('Reference video file name in materials directory, 用于参考视频动作和特效，只有vidu-pro模型支持'),
         duration: zod_1.z
             .number()
             .min(0)
             .max(16)
             .optional()
             .default(5)
-            .describe('The duration of the video in seconds.'),
+            .describe('The duration of the video in seconds.可以传0，此时会根据视频提示词内容自动确定时长'),
         aspectRatio: zod_1.z
             .enum(['16:9', '9:16'])
+            .default('16:9')
             .describe('The aspect ratio of the video.'),
         resolution: zod_1.z
             .enum(['720p', '1080p'])
+            .default('720p')
             .describe('The resolution of the video.'),
         type: zod_1.z
             .enum([
@@ -2875,6 +2931,7 @@ server.registerTool('generate-video-by-ref', {
             'veo3.1',
             'veo3.1-pro',
             'vidu',
+            'vidu-pro',
             'vidu-uc',
             'pixv',
         ])
@@ -2897,42 +2954,30 @@ server.registerTool('generate-video-by-ref', {
             .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，必须要传这个参数'),
         optimizePrompt: zod_1.z
             .boolean()
             .optional()
             .default(false)
             .describe('Whether to optimize the prompt.'),
     },
-}, async ({ prompt, rewritePrompt, referenceImages, duration, aspectRatio, resolution, type = 'vidu', mute, saveToFileName, sceneIndex, storyBoardFile, skipConsistencyCheck, optimizePrompt, seed, }, context) => {
+}, async ({ prompt, referenceImages, duration, aspectRatio, resolution, type = 'vidu', mute, saveToFileName, sceneIndex, optimizePrompt, seed, referenceVideo, }, context) => {
     try {
+        const storyBoardFile = 'storyboard.json';
         // 验证session状态
         const currentSession = await validateSession('generate-video-by-ref');
-        const storyBoardPath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, storyBoardFile);
-        if (type !== 'pro' && duration === 0) {
-            return createErrorResponse('非 pro 模型的视频时长不能为 0', 'generate-video');
+        checkModelEnabled(type);
+        const storyBoardPath = (0, node_path_1.resolve)(projectLocalDir, storyBoardFile);
+        if (type !== 'vidu-pro' && referenceVideo) {
+            return createErrorResponse('只有vidu-pro模型支持参考视频', 'generate-video-by-ref');
         }
-        const outlineSheetImagePath = (0, node_path_1.resolve)(process.env.ZEROCUT_PROJECT_CWD || process.cwd(), projectLocalDir, 'materials', 'outline_sheet.png');
+        const outlineSheetImagePath = (0, node_path_1.resolve)(projectLocalDir, 'materials', 'outline_sheet.png');
         const hasOutlineSheet = (0, node_fs_1.existsSync)(outlineSheetImagePath);
-        if (hasOutlineSheet && !skipConsistencyCheck) {
-            return createErrorResponse('监测到素材中存在outline_sheet.png这张图（由outline工具生成的），应采用 generate-video 图生视频。若用户明确要用参考生视频，则跳过一致性检查。', 'generate-video');
-        }
         // 校验 prompt 与 storyboard.json 中分镜设定的一致性（如果提供了 sceneIndex）
-        if (!skipConsistencyCheck && sceneIndex) {
+        if (sceneIndex) {
             try {
+                if (hasOutlineSheet) {
+                    return createErrorResponse('监测到素材中存在outline_sheet.png这张图（由outline工具生成的），应采用 generate-video 图生视频。', 'generate-video-by-ref');
+                }
                 if ((0, node_fs_1.existsSync)(storyBoardPath)) {
                     const storyBoardContent = await (0, promises_1.readFile)(storyBoardPath, 'utf8');
                     // 检查 storyBoard JSON 语法合法性
@@ -2948,7 +2993,7 @@ server.registerTool('generate-video-by-ref', {
                         if (scene) {
                             const videoPrompt = scene.video_prompt;
                             if (videoPrompt && prompt !== videoPrompt) {
-                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定，如果用户明确指出不需要遵守，请将skipConsistencyCheck设置为true后再次调用', 'generate-video-by-ref');
+                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定', 'generate-video-by-ref');
                             }
                             // 检查 scene.is_continuous 是否为 true
                             if (scene.is_continuous === true) {
@@ -3072,7 +3117,6 @@ server.registerTool('generate-video-by-ref', {
         console.log(`Generating video ${referenceImages.length > 0 ? `with ${referenceImages.length} reference image(s)` : 'without reference images'} using ${type} model...`);
         // 处理参考图：转换为URL而不是base64
         const referenceImageUrls = [];
-        let promptPrefix = '';
         for (const imageRef of referenceImages) {
             // 使用 getMaterialUri 获取图片URL
             const imageUrl = getMaterialUri(currentSession, imageRef.fileName);
@@ -3082,14 +3126,17 @@ server.registerTool('generate-video-by-ref', {
                 url: imageUrl,
             });
             console.log(`Added reference image URL: ${imageUrl} (name: ${imageRef.name}, type: ${imageRef.type})`);
-            if (rewritePrompt) {
-                promptPrefix += `参考“${imageRef.name}”（图${referenceImageUrls.length}）${imageRef.type === 'subject' ? '主体形象' : '背景'}\n`;
-            }
-        }
-        if (promptPrefix) {
-            promptPrefix += '\n';
         }
-        const finalPrompt = `${promptPrefix}${prompt}`;
+        const finalPrompt = `${prompt}`;
+        const videos = referenceVideo
+            ? [
+                {
+                    type: 'video',
+                    name: referenceVideo.name,
+                    url: getMaterialUri(currentSession, referenceVideo.fileName),
+                },
+            ]
+            : undefined;
         // 调用 referencesToVideo 函数
         const result = await currentSession.ai.referencesToVideo({
             prompt: finalPrompt,
@@ -3100,10 +3147,12 @@ server.registerTool('generate-video-by-ref', {
             type,
             mute,
             seed,
+            videos,
             onProgress: metaData => {
                 console.log('Video generation progress:', metaData);
                 sendProgress(context, metaData.progress || 0, 100, 'Generating video...');
             },
+            waitForFinish: CLIENT_TYPE !== '5ire',
         });
         if (result.error) {
             return createErrorResponse(result.error, 'generate-video-by-ref');
@@ -3229,6 +3278,7 @@ server.registerTool('extend-video-duration', {
             onProgress: async (metaData) => {
                 sendProgress(context, ++progress, undefined, `Extension progress: ${Math.round(progress * 100)}%`);
             },
+            waitForFinish: CLIENT_TYPE !== '5ire',
         });
         // 检查结果
         if (!result || result.error) {
@@ -3305,7 +3355,7 @@ server.registerTool('use-template', {
         }));
         const validatedFileName = validateFileName(saveToFileName);
         let completion = await ai.getCompletions({
-            model: 'Doubao-Seed-1.6',
+            model: 'Doubao-Seed-1.8',
             messages: [
                 {
                     role: 'system',
@@ -3351,7 +3401,7 @@ ${user_request}
 ${JSON.stringify(materialUrls)}`;
         // console.log(prompt);
         completion = await ai.getCompletions({
-            model: 'Doubao-Seed-1.6',
+            model: 'Doubao-Seed-1.8',
             messages: [
                 {
                     role: 'system',