cerevox 4.16.0 → 4.17.0

package/dist/mcp/servers/zerocut.js

@@ -47,11 +47,9 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod_1 = require("zod");
 const index_1 = __importDefault(require("../../index"));
 const constants_1 = require("../../utils/constants");
-const videokit_1 = require("../../utils/videokit");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importStar(require("node:path"));
 const node_fs_1 = require("node:fs");
-const image_size_1 = __importDefault(require("image-size"));
 const seed_1 = require("../../utils/seed");
 const uuid_1 = require("uuid");
 const node_crypto_1 = require("node:crypto");
@@ -302,8 +300,8 @@ 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';
 const MAIN_PROVIDER = process.env.MAIN_PROVIDER || 'zerocut';
+const MCP_TIMEOUT_MS = Number(process.env.RUN_MCP_TIMEOUT_MS || '300000') - 60000;
 // 注册 ZeroCut 指导规范 Prompt
 server.registerPrompt('zerocut-guideline', {
     title: 'ZeroCut 短视频创作指导规范',
@@ -698,165 +696,11 @@ server.registerTool('wait-for-task-finish', {
         return createErrorResponse(error, 'wait-for-task-finish');
     }
 });
-server.registerTool('generate-subject-image', {
-    title: 'Generate Subject Image',
-    description: '生成主体四视图（人物或物品形象）',
-    inputSchema: {
-        type: zod_1.z.enum(['object', 'character']).optional().default('character'),
-        model: zod_1.z
-            .enum([
-            'seedream',
-            'seedream-pro',
-            'seedream-5l',
-            'banana',
-            'banana-pro',
-            'wan',
-        ])
-            .default('banana-pro')
-            .describe('除非用户特别指定，否则默认使用 banana-pro 模型'),
-        prompt: zod_1.z
-            .string()
-            .describe('忠于用户原始需求，严格按用户需求用简洁提示词描述主体外观，不用再提这是四视图、无须解释四视图方位，也无须描述与主体无关的其他内容比如一致性之类，工具会自行处理'),
-        referenceImages: zod_1.z
-            .array(zod_1.z.object({
-            name: zod_1.z.string().describe('图片名称，人物名或物品名'),
-            fileName: zod_1.z.string().describe('Reference image file name'),
-        }))
-            .optional()
-            .default([])
-            .describe('Array of reference image objects with name, url and type. Can be empty for text-only generation.如果传了参考图，不要文字描述主体详细外观，以免和参考主体冲突'),
-        saveToFileName: zod_1.z.string().describe('应该是png文件'),
-    },
-}, async ({ type, model, prompt, referenceImages = [], saveToFileName }, context) => {
-    try {
-        // 验证session状态
-        const currentSession = await validateSession('generate-character-image');
-        checkModelEnabled(type);
-        const validatedFileName = validateFileName(saveToFileName);
-        const ai = currentSession.ai;
-        const imageUrls = await Promise.all(referenceImages.map(async (item) => ({
-            url: await getMaterialUri(currentSession, item.fileName, {
-                fileSizeLimit: 10,
-            }),
-            name: item.name,
-        })));
-        try {
-            if (type === 'character' && imageUrls.length <= 0) {
-                // 补充人物细节
-                const promptOptimizer = await (0, promises_1.readFile)((0, node_path_1.resolve)(__dirname, './prompts/character-prompt-optimizer.md'), 'utf8');
-                const userContent = [
-                    {
-                        type: 'text',
-                        text: prompt,
-                    },
-                ];
-                if (imageUrls.length > 0) {
-                    userContent.push(...imageUrls.map(item => ({
-                        type: 'image_url',
-                        image_url: {
-                            url: item.url,
-                        },
-                    })));
-                }
-                const completion = await ai.getCompletions({
-                    model: 'Doubao-Seed-1.8',
-                    messages: [
-                        {
-                            role: 'system',
-                            content: promptOptimizer,
-                        },
-                        {
-                            role: 'user',
-                            content: userContent,
-                        },
-                    ],
-                });
-                const optimizedPrompt = completion.choices[0]?.message?.content.trim();
-                if (optimizedPrompt) {
-                    prompt = `${optimizedPrompt} 8K,超高细节,逼真质感。`;
-                }
-            }
-        }
-        catch (error) {
-            console.warn('Failed to optimize character prompt');
-        }
-        let progress = 0;
-        const res = await ai.generateTurnaroundImage({
-            type: model,
-            prompt,
-            reference_images: imageUrls,
-            onProgress: async (metaData) => {
-                try {
-                    await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
-                }
-                catch (progressError) {
-                    console.warn('Failed to send progress update:', progressError);
-                }
-            },
-        });
-        if (!res) {
-            throw new Error('Failed to generate image: no response from AI service');
-        }
-        res.url = res.url || res.urls[0];
-        if (res.taskUrl) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: '该任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish (saveFileName=outline_sheet.png) 来等待任务结束，如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
-                            taskUrl: res.taskUrl,
-                        }),
-                    },
-                ],
-            };
-        }
-        if (res.url) {
-            console.log('Image generated successfully, saving to materials...');
-            const image = await saveMaterial(currentSession, res.url, validatedFileName);
-            const result = {
-                success: true,
-                // source: res.url,
-                image,
-                prompt,
-                timestamp: new Date().toISOString(),
-            };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result),
-                    },
-                ],
-            };
-        }
-        else {
-            console.warn('Image generation completed but no URL returned');
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: 'No image URL returned from AI service',
-                            response: res,
-                            timestamp: new Date().toISOString(),
-                        }),
-                    },
-                ],
-            };
-        }
-    }
-    catch (error) {
-        return createErrorResponse(error, 'generate-character-image');
-    }
-});
 server.registerTool('generate-image', {
     title: 'Generate Image',
     description: `生成图片`,
     inputSchema: {
-        type: zod_1.z
+        model: zod_1.z
             .enum([
             'banana',
             'banana-pro',
@@ -866,11 +710,23 @@ server.registerTool('generate-image', {
             'seedream-5l',
             'zero',
             'wan',
+        ])
+            .optional()
+            .default(MAIN_PROVIDER === 'aliyun' ? 'wan' : 'seedream-pro'),
+        type: zod_1.z
+            .enum([
+            'default',
             'line-sketch',
             'storyboard-grid',
+            'subject-turnaround',
         ])
             .optional()
-            .default(MAIN_PROVIDER === 'aliyun' ? 'wan' : 'seedream-pro'),
+            .default('default')
+            .describe(`生成图片类型
+- 默认 default，生成普通图片
+- 生成分镜宫格（3x3）： type 使用 storyboard-grid，注意只有九宫格（3x3）才使用这个，其他形式的宫格一律用default！
+- 生成线稿： type 使用 line-sketch
+- 生成主体四视图：type 使用 subject-turnaround`),
         panelCount: zod_1.z
             .union([zod_1.z.literal(4), zod_1.z.literal(6), zod_1.z.literal(9)])
             .optional()
@@ -878,7 +734,7 @@ server.registerTool('generate-image', {
             .describe('仅 type=storyboard-grid 时生效，默认9宫格'),
         prompt: zod_1.z
             .string()
-            .describe('生图提示词，需严格忠于用户的具体需求； 如有sceneIndex，一般要严格对应 storyboard 中当前分镜的 start_frame 或 end_frame 中的字段描述，如果是生成线稿，则 type 使用 line-sketch'),
+            .describe('生图提示词，需严格忠于用户的具体需求； 如有sceneIndex，一般要严格对应 storyboard 中当前分镜的 start_frame 或 end_frame 中的字段描述'),
         sceneIndex: zod_1.z
             .number()
             .min(1)
@@ -964,14 +820,12 @@ server.registerTool('generate-image', {
 \`\`\`
           `),
     },
-}, async ({ type = 'seedream', prompt, sceneIndex, size, imageCount = 1, saveToFileNames, watermark, referenceImages, panelCount, }, context) => {
+}, async ({ model = 'seedream-5l', type = 'default', prompt, sceneIndex, size, imageCount = 1, saveToFileNames, watermark, referenceImages, panelCount, }, context) => {
     try {
         const storyBoardFile = 'storyboard.json';
         // 验证session状态
         const currentSession = await validateSession('generate-image');
-        if (type !== 'line-sketch' && type !== 'storyboard-grid') {
-            checkModelEnabled(type);
-        }
+        checkModelEnabled(model);
         // storyboard-grid 默认为2K分辨率 2560x1440，其余默认 1440x2560.
         if (!size) {
             if (type === 'storyboard-grid') {
@@ -1093,6 +947,7 @@ server.registerTool('generate-image', {
         const ai = currentSession.ai;
         let progress = 0;
         const res = await ai.generateImage({
+            model,
             type,
             prompt: processedPrompt,
             panelCount: type === 'storyboard-grid' ? panelCount : undefined,
@@ -1253,7 +1108,6 @@ server.registerTool('generate-video-outlines', {
                     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');
@@ -1581,7 +1435,6 @@ server.registerTool('text-to-speech', {
         return createErrorResponse(error, 'text-to-speech');
     }
 });
-let lastEffect = '';
 server.registerTool('generate-video', {
     title: 'Generate Video',
     description: `首帧图和首尾帧生视频工具`,
@@ -1597,49 +1450,89 @@ server.registerTool('generate-video', {
                 .describe('语音音色详细描述，如性别、声线、情感等，每一次都需要详细信息'),
             voice_id: zod_1.z.string().optional().describe('用户指定优先使用的音色ID'),
         })
+            .describe('只有用户明确使用旁白时，才使用旁白')
             .optional(),
         sceneIndex: zod_1.z
             .number()
             .min(1)
             .optional()
             .describe('分镜索引，从1开始的下标，如果非分镜对应素材，则可不传，分镜素材必传'),
-        type: zod_1.z
+        model: zod_1.z
             .enum([
+            'zerocut3.0',
             'pro',
-            'hailuo',
-            'hailuo-fast',
+            'seedance-1.5-pro',
             'vidu',
-            'viduq2',
-            'vidu-turbo',
             'vidu-pro',
             'viduq3',
             'viduq3-turbo',
             'kling',
             'kling-v3',
+            'wan',
             'wan-flash',
-            'pixv',
-            'veo3.1',
-            'veo3.1-pro',
             'sora2',
             'sora2-pro',
-            'kenburns',
+            'veo3.1',
+            'veo3.1-pro',
         ])
             .default(MAIN_PROVIDER === 'aliyun' ? 'wan-flash' : 'vidu'),
-        audio: zod_1.z
+        silent: zod_1.z
             .boolean()
             .optional()
-            .default(true)
-            .describe('除非用户明确要求静音，否则默认audio=true，此时视频模型会自己配音，不需要再使用tts工具！'),
+            .default(false)
+            .describe('除非用户明确要求静音，否则默认silent=false，此时视频模型会自己配音，不需要再使用tts工具！'),
         bgm: zod_1.z.boolean().optional().describe('是否启用背景音乐，缺省的话是自动'),
         seed: zod_1.z
             .number()
             .optional()
             .describe('用户可以指定一个固定值来获得可重复的结果'),
         saveToFileName: zod_1.z.string().describe('应该是mp4文件'),
-        start_frame: zod_1.z
-            .string()
+        images: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z
+                .string()
+                .optional()
+                .describe('图片名称，人物名、图片背景名或物品名'),
+            fileName: zod_1.z.string().describe('Reference image file name'),
+            type: zod_1.z
+                .enum(['reference', 'storyboard', 'first_frame', 'last_frame'])
+                .default('reference')
+                .describe(`Type of reference: 
+- reference 图片是主体参考图，当用户说参考xx图时，默认用这个类型
+- storyboard 图片是镜头宫格参考图，当用户说参考xx分镜宫格时，用这个类型
+- first_frame 图片是首帧图，当用户强调图生视频，或者以xxx为首帧时，用这个类型
+- last_frame 图片是尾帧图，当用户说以xxx为尾帧时，用这个类型
+`),
+        }))
             .optional()
-            .describe('The image file name of the first frame of the video.'),
+            .default([])
+            .describe('Array of reference image objects with name, url and type. Can be empty for text-only generation.'),
+        videos: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z.string().optional().describe('参考视频名称'),
+            fileName: zod_1.z.string().describe('Reference video file name'),
+            type: zod_1.z.enum(['base', 'reference']).describe(`Type of reference: 
+- base 是用于编辑的原视频
+- ref 是用作参考镜头或主体的视频
+`),
+        }))
+            .optional()
+            .default([])
+            .describe('Array of reference video objects with name, url and type. Can be empty for text-only generation.'),
+        audios: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z.string().optional().describe('参考音频名称'),
+            fileName: zod_1.z.string().describe('Reference audio file name'),
+            type: zod_1.z.enum(['speaker', 'lipsync', 'sound', 'bgm']).describe(`Type of reference: 
+- speaker 用于角色参考音色
+- lipsync 将音频与视频对口型
+- sound 合成背景音效、旁白等
+- bgm 合成背景音乐
+`),
+        }))
+            .optional()
+            .default([])
+            .describe('Array of reference audio objects with name, url and type. Can be empty for text-only generation.'),
         duration: zod_1.z
             .number()
             .min(0)
@@ -1647,16 +1540,12 @@ server.registerTool('generate-video', {
             .optional()
             .default(0)
             .describe('若传0，表示根据视频提示词内容自动确定时长，当用户未给出明确时长指令时，优先传0'),
-        end_frame: zod_1.z
-            .string()
-            .optional()
-            .describe('The image file name of the last frame of the video.'),
-        saveLastFrameAs: zod_1.z
-            .string()
+        aspectRatio: zod_1.z
+            .enum(['16:9', '9:16', '1:1'])
             .optional()
-            .describe('The filename to save the last frame. 只有用户不传end_frame且需要该帧延续下一个分镜时，才需要这个参数，默认不传'),
+            .describe('若使用首、尾帧，则忽略该参数（自动根据图片适配）'),
         resolution: zod_1.z
-            .enum(['720p', '1080p'])
+            .enum(['720p', '1080p', '2K', '4K'])
             .optional()
             .default('720p')
             .describe('除非用户明确提出使用其他分辨率，否则一律用720p'),
@@ -1666,14 +1555,13 @@ server.registerTool('generate-video', {
             .default(true)
             .describe('默认true，自动规范化镜头语言'),
     },
-}, async ({ prompt, narration, sceneIndex, saveToFileName, start_frame, end_frame, duration, resolution, type = 'vidu', optimizeCameraMotion, saveLastFrameAs, audio = true, bgm, seed, }, context) => {
+}, async ({ prompt, narration, sceneIndex, saveToFileName, images = [], videos = [], audios = [], duration, resolution, aspectRatio, model = 'vidu', optimizeCameraMotion, bgm, silent = false, seed, }, context) => {
     try {
         // 验证session状态
         const currentSession = await validateSession('generate-video');
-        checkModelEnabled(type);
-        if (!start_frame) {
-            return createErrorResponse('start_frame 不能为空', 'generate-video');
-        }
+        checkModelEnabled(model);
+        if (model === 'pro')
+            model = 'seedance-1.5-pro';
         const storyBoardFile = 'storyboard.json';
         // 校验 prompt 与 storyboard.json 中分镜设定的一致性
         if (sceneIndex) {
@@ -1696,24 +1584,37 @@ server.registerTool('generate-video', {
                             if (videoPrompt && prompt.trim() !== videoPrompt?.trim()) {
                                 return createErrorResponse('视频提示词必须严格遵照storyboard的设定，内容完全一致，包括空格、回车、标点和特殊符号，检查传入的prompt参数与storyboard中的video_prompt是否完全一致', 'generate-video');
                             }
-                            if (scene.is_continuous && !end_frame) {
-                                return createErrorResponse('连续分镜必须指定end_frame参数', 'generate-video');
-                            }
                             if (scene.video_duration != null &&
                                 duration !== scene.video_duration) {
                                 return createErrorResponse(`视频时长必须严格遵照storyboard的设定，storyboard 中设定的时长为 ${scene.video_duration} 秒${scene.video_duration === 0 ? '。0秒表示根据视频提示词内容自动确定时长' : ''}`, 'generate-video');
                             }
                             if (storyBoard.voice_type &&
                                 storyBoard.voice_type !== 'slient') {
-                                if (!audio) {
-                                    return createErrorResponse('有对话和旁白的分镜不能静音，请将audio设为true再重新使用工具。', 'generate-video');
+                                if (silent) {
+                                    return createErrorResponse('有对话和旁白的分镜不能静音，请将silent设为false再重新使用工具。', 'generate-video');
+                                }
+                            }
+                            if (storyBoard.narration && !narration) {
+                                return createErrorResponse('有对话和旁白的分镜必须传入旁白参数 narration。', 'generate-video');
+                            }
+                            // 检查 storyBoard.orientation 与 size 参数的一致性
+                            if (storyBoard.orientation && aspectRatio) {
+                                const isLandscapeSize = aspectRatio === '16:9';
+                                const isPortraitSize = aspectRatio === '9:16';
+                                if (storyBoard.orientation === 'landscape' &&
+                                    !isLandscapeSize) {
+                                    return createErrorResponse(`故事板设定为横屏模式(orientation: landscape)，但视频为竖屏格式，请使用横屏尺寸 1280x720`, 'generate-video');
+                                }
+                                if (storyBoard.orientation === 'portrait' &&
+                                    !isPortraitSize) {
+                                    return createErrorResponse(`故事板设定为竖屏模式(orientation: portrait)，但视频为横屏格式，请使用竖屏尺寸 720x1280`, '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参数值相同。`, 'generate-video');
+                                model &&
+                                scene.use_video_model !== model) {
+                                return createErrorResponse(`分镜建议的视频模型(${scene.use_video_model})与传入的模型参数(${model})不一致。请确保use_video_model与type参数值相同。`, 'generate-video');
                             }
                         }
                         else {
@@ -1733,232 +1634,71 @@ server.registerTool('generate-video', {
         const validatedFileName = validateFileName(saveToFileName);
         console.log(`Generating video with prompt: ${prompt.substring(0, 100)}...`);
         const ai = currentSession.ai;
+        let narrationVoice;
+        if (narration) {
+            if (model === 'seedance-1.5-pro' ||
+                model === 'wan-flash' ||
+                (model?.startsWith('vidu') && !model?.startsWith('viduq3'))) {
+                narrationVoice = await ai.textToSpeech({
+                    text: narration.text,
+                    voiceId: narration.voice_id,
+                    prompt: narration.tone,
+                });
+                const voiceDuration = narrationVoice.duration;
+                if (duration === 0) {
+                    duration = Math.ceil(voiceDuration + 0.05);
+                }
+            }
+            else {
+                prompt = `画外音（${narration.tone}）：“${narration.text}”\n\n${prompt}`;
+            }
+        }
         let progress = 0;
-        const startFrameUri = start_frame
-            ? await getMaterialUri(currentSession, start_frame, {
-                fileSizeLimit: 10,
-            })
-            : undefined;
-        const endFrameUri = end_frame
-            ? await getMaterialUri(currentSession, end_frame, {
+        const referenceImages = await Promise.all(images.map(async (item) => {
+            const url = await getMaterialUri(currentSession, item.fileName, {
                 fileSizeLimit: 10,
-            })
-            : undefined;
-        if (type === 'kenburns') {
-            // 实现 getImageSize 函数
-            async function getImageSize(imageUri) {
-                // imageUri 是一个可以 http 访问的图片
-                // eslint-disable-next-line custom/no-fetch-in-src
-                const response = await fetch(imageUri);
-                const arrayBuffer = await response.arrayBuffer();
-                const buffer = Buffer.from(arrayBuffer);
-                const image = (0, image_size_1.default)(buffer);
-                return [image.width, image.height];
-            }
-            const [imageWidth, imageHeight] = await getImageSize(startFrameUri);
-            const kenburnsPrompt = `根据用户描述和配置，生成适合的 kenburns 动画参数。
-
-## 配置信息
-- 视频时长：${duration}秒
-- 分辨率：${resolution}
-- 保存最后一帧：${saveLastFrameAs ? '是' : '否'}
-- 图片宽高：${imageWidth}x${imageHeight}
-- 上一次选择的特效：${lastEffect || '无'}
-
-## camera_motion 可选特效
-- zoom_in
-- zoom_out
-- zoom_in_left_top
-- zoom_out_left_top
-- zoom_in_right_top
-- zoom_out_right_top
-- zoom_in_left_bottom
-- zoom_out_left_bottom
-- zoom_in_right_bottom
-- zoom_out_right_bottom
-- pan_up
-- pan_down
-- pan_left
-- pan_right
-- static
-
-## 特效选用规则
-- 视频时长6秒内：优先选择zoom类型(zoom_in, zoom_out)
-- 视频时长6秒以上：优先选择pan类型(pan_left, pan_right, pan_up, pan_down)
-- 除非用户指定，否则不要主动使用 static 效果
-- 除非用户指定，否则不要和上一次选择的效果重复
-`;
-            const schema = {
-                name: 'kenburns_effect',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        camera_motion: {
-                            type: 'string',
-                            description: 'kenburns 特效类型',
-                            enum: [
-                                'zoom_in',
-                                'zoom_out',
-                                'zoom_in_left_top',
-                                'zoom_out_left_top',
-                                'zoom_in_right_top',
-                                'zoom_out_right_top',
-                                'zoom_in_left_bottom',
-                                'zoom_out_left_bottom',
-                                'zoom_in_right_bottom',
-                                'zoom_out_right_bottom',
-                                'pan_up',
-                                'pan_down',
-                                'pan_left',
-                                'pan_right',
-                                'static',
-                            ],
-                        },
-                        size: {
-                            type: 'string',
-                            description: 'kenburns 视频 宽x高',
-                        },
-                        duration: {
-                            type: 'number',
-                            description: 'kenburns 视频 时长',
-                        },
-                    },
-                    required: ['camera_motion', 'size', 'duration'],
-                },
+            });
+            return {
+                name: item.name,
+                url,
+                type: item.type,
             };
-            const analysisPayload = {
-                model: 'Doubao-Seed-1.8',
-                messages: [
-                    {
-                        role: 'system',
-                        content: kenburnsPrompt,
-                    },
-                    {
-                        role: 'user',
-                        content: prompt.trim(),
-                    },
-                ],
-                response_format: {
-                    type: 'json_schema',
-                    json_schema: schema,
-                },
+        }));
+        const referenceVideos = await Promise.all(videos.map(async (item) => {
+            const url = await getMaterialUri(currentSession, item.fileName, {
+                fileSizeLimit: 50,
+            });
+            return {
+                name: item.name,
+                url,
+                type: item.type,
             };
-            console.log(JSON.stringify(analysisPayload, null, 2));
-            const completion = await ai.getCompletions(analysisPayload);
-            const analysisResult = completion.choices[0]?.message?.content;
-            if (!analysisResult) {
-                throw new Error('Failed to generate kenburns effect');
-            }
-            try {
-                const kenburnsEffect = JSON.parse(analysisResult);
-                const { camera_motion, size, duration } = kenburnsEffect;
-                if (!camera_motion || !size || !duration) {
-                    throw new Error('Invalid kenburns effect parameters');
-                }
-                lastEffect = camera_motion;
-                const files = currentSession.files;
-                const terminal = currentSession.terminal;
-                await getMaterialUri(currentSession, start_frame, {
-                    fileSizeLimit: 10,
-                }); // 确保素材上传
-                start_frame = (0, node_path_1.resolve)('/home/user/cerevox-zerocut/projects', terminal.id, 'materials', (0, node_path_1.basename)(start_frame));
-                const saveToPath = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials/${validatedFileName}`;
-                const saveLocalPath = (0, node_path_1.resolve)(projectLocalDir, 'materials', validatedFileName);
-                // 解析尺寸参数
-                const sizeArray = size.split('x');
-                if (sizeArray.length !== 2) {
-                    throw new Error(`Invalid size format: ${size}. Expected format: WIDTHxHEIGHT`);
-                }
-                const [widthStr, heightStr] = sizeArray;
-                const width = Number(widthStr);
-                const height = Number(heightStr);
-                if (isNaN(width) || isNaN(height) || width <= 0 || height <= 0) {
-                    throw new Error(`Invalid dimensions: ${width}x${height}. Both width and height must be positive numbers`);
-                }
-                console.log(`Compiling Ken Burns motion command...`);
-                let command;
-                try {
-                    command = await (0, videokit_1.compileKenBurnsMotion)(start_frame, duration, camera_motion, {
-                        output: saveToPath,
-                        width,
-                        height,
-                    });
-                }
-                catch (compileError) {
-                    console.error('Failed to compile Ken Burns motion command:', compileError);
-                    throw new Error(`Failed to compile Ken Burns motion: ${compileError}`);
-                }
-                console.log(`Executing FFmpeg command: ${command.substring(0, 100)}...`);
-                const res = await terminal.run(command);
-                const result = await res.json();
-                if (result.exitCode !== 0) {
-                    console.error('FFmpeg command failed:', result);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    error: 'Ken Burns motion generation failed',
-                                    exitCode: result.exitCode,
-                                    stderr: result.stderr,
-                                    command,
-                                    timestamp: new Date().toISOString(),
-                                }),
-                            },
-                        ],
-                    };
-                }
-                console.log('Ken Burns motion generated successfully, downloading file...');
-                try {
-                    await files.download(saveToPath, saveLocalPath);
-                }
-                catch (downloadError) {
-                    console.warn('Failed to download file to local:', downloadError);
-                    // 继续执行，因为远程文件已生成成功
-                }
-                const resultData = {
-                    success: true,
-                    uri: saveToPath,
-                    durationMs: Math.floor(duration * 1000),
-                    cameraMotion: camera_motion,
-                    imagePath: start_frame,
-                    size,
-                    dimensions: { width, height },
-                    timestamp: new Date().toISOString(),
-                    systemPrompt: kenburnsPrompt,
-                };
-                console.log(`Ken Burns motion completed: ${saveToPath}`);
-                currentSession.track('KenBurns Video Generated', {
-                    durationMs: Math.floor(duration * 1000).toString(),
-                    cameraMotion: camera_motion,
-                    imagePath: start_frame,
-                    size,
-                    dimensions: size,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(resultData),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                throw new Error('Failed to parse kenburns effect parameters');
-            }
+        }));
+        const referenceAudios = await Promise.all(audios.map(async (item) => {
+            const url = await getMaterialUri(currentSession, item.fileName);
+            return {
+                name: item.name,
+                url,
+                type: item.type,
+            };
+        }));
+        if (narration) {
+            referenceAudios.push({
+                name: narration?.voice_id,
+                url: narrationVoice.url,
+                type: 'sound',
+            });
         }
-        const res = await ai.framesToVideo({
+        const res = await ai.generateVideo({
             prompt: prompt.trim(),
-            narration,
-            start_frame: startFrameUri,
-            end_frame: endFrameUri,
+            model,
+            images: referenceImages,
+            videos: referenceVideos,
+            audios: referenceAudios,
             duration,
             resolution,
-            type,
-            return_last_frame: Boolean(saveLastFrameAs),
-            optimizeCameraMotion,
+            aspect_ratio: aspectRatio,
+            optimize_camera: optimizeCameraMotion,
             onProgress: async (metaData) => {
                 try {
                     await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
@@ -1967,10 +1707,10 @@ server.registerTool('generate-video', {
                     console.warn('Failed to send progress update:', progressError);
                 }
             },
-            waitForFinish: CLIENT_TYPE !== '5ire',
-            mute: !audio,
-            enableBGM: bgm,
+            mute: silent,
+            bgm,
             seed,
+            timeout: MCP_TIMEOUT_MS,
         });
         if (!res) {
             throw new Error('Failed to generate video: no response from AI service');
@@ -1978,21 +1718,14 @@ server.registerTool('generate-video', {
         if (res.url) {
             console.log('Video generated successfully, saving to materials...');
             const video = await saveMaterial(currentSession, res.url, validatedFileName);
-            let lastFrameImage;
-            if (saveLastFrameAs && res.last_frame_url) {
-                lastFrameImage = await saveMaterial(currentSession, res.last_frame_url, validateFileName(saveLastFrameAs));
-            }
             const { url, duration: videoDuration, ...opts } = res;
             const result = {
                 success: true,
                 // source: url,
                 video,
-                lastFrameImage,
                 durationMs: Math.floor((videoDuration || duration) * 1000),
                 prompt,
                 timestamp: new Date().toISOString(),
-                startFrame: start_frame,
-                endFrame: end_frame,
                 ...opts,
             };
             // Update media_logs.json
@@ -2035,7 +1768,6 @@ server.registerTool('generate-video', {
                             success: false,
                             error: 'No video URL returned from AI service',
                             response: res,
-                            startFrameUri,
                             timestamp: new Date().toISOString(),
                         }),
                     },
@@ -2047,515 +1779,6 @@ server.registerTool('generate-video', {
         return createErrorResponse(error, 'generate-video');
     }
 });
-server.registerTool('generate-video-by-ref', {
-    title: 'Generate Video By Text or References',
-    description: `参考生视频（包含文生视频）工具`,
-    inputSchema: {
-        prompt: zod_1.z
-            .string()
-            .describe('The prompt to generate video with or without reference images. '),
-        referenceImages: zod_1.z
-            .array(zod_1.z.object({
-            name: zod_1.z.string().describe('图片名称，人物名、图片背景名或物品名'),
-            fileName: zod_1.z.string().describe('Reference image file name'),
-            type: zod_1.z
-                .enum(['subject', 'background', 'storyboard'])
-                .describe('Type of reference: subject是主体，background是背景，storyboard是镜头宫格'),
-        }))
-            .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和kling-v3模型支持'),
-        duration: zod_1.z
-            .number()
-            .min(0)
-            .max(16)
-            .optional()
-            .default(0)
-            .describe('若传0，表示根据视频提示词内容自动确定时长，当用户未给出明确时长指令时，优先传0'),
-        aspectRatio: zod_1.z.enum(['16:9', '9:16', '1:1']).default('16:9'),
-        resolution: zod_1.z.enum(['720p', '1080p']).default('720p'),
-        type: zod_1.z
-            .enum([
-            'pro',
-            'sora2',
-            'sora2-pro',
-            'veo3.1',
-            'veo3.1-pro',
-            'vidu',
-            'viduq2',
-            'vidu-pro',
-            'viduq2-pro',
-            'viduq3',
-            'viduq3-turbo',
-            'wan',
-            'kling',
-            'kling-v3',
-            'zerocut3.0',
-            'pixv',
-        ])
-            .default(MAIN_PROVIDER === 'aliyun' ? 'wan' : 'vidu'),
-        audio: zod_1.z
-            .boolean()
-            .optional()
-            .default(true)
-            .describe('除非用户明确要求静音，否则默认audio=true，此时视频模型会自己配音，不需要再使用tts工具！'),
-        bgm: zod_1.z.boolean().optional().describe('是否启用背景音乐，缺省的话是自动'),
-        style: zod_1.z.string().optional().describe('画面及美学风格'),
-        seed: zod_1.z
-            .number()
-            .optional()
-            .describe('用户可以指定一个固定值来获得可重复的结果'),
-        saveToFileName: zod_1.z.string().describe('应该是mp4文件'),
-        sceneIndex: zod_1.z
-            .number()
-            .min(1)
-            .optional()
-            .describe('分镜索引，从1开始的下标，如果非分镜对应素材，则可不传，分镜素材必传'),
-        optimizeCameraMotion: zod_1.z
-            .boolean()
-            .optional()
-            .default(true)
-            .describe('默认true，自动规范化镜头语言'),
-        autoStoryboard: zod_1.z
-            .boolean()
-            .optional()
-            .describe('自动生成分镜宫格（智能分镜），除非用户指定，否则不传该参数，缺省为根据用户需要自动判断'),
-        storyboardPanelCount: zod_1.z
-            .enum(['4', '6', '9'])
-            .optional()
-            .describe('智能分镜时的分镜宫格数量，除非用户明确指定，否则缺省，缺省将根据视频时长智能判断'),
-    },
-}, async ({ prompt, referenceImages, duration, aspectRatio, resolution, type = 'vidu', audio = true, bgm, saveToFileName, sceneIndex, optimizeCameraMotion, seed, referenceVideo, autoStoryboard, storyboardPanelCount, }, context) => {
-    try {
-        const storyBoardFile = 'storyboard.json';
-        // 验证session状态
-        const currentSession = await validateSession('generate-video-by-ref');
-        checkModelEnabled(type);
-        const storyBoardPath = (0, node_path_1.resolve)(projectLocalDir, storyBoardFile);
-        if (type !== 'vidu-pro' &&
-            type !== 'viduq2-pro' &&
-            type !== 'kling-v3' &&
-            referenceVideo) {
-            return createErrorResponse('只有vidu-pro和kling-v3模型支持参考视频', 'generate-video-by-ref');
-        }
-        const outlineSheetImagePath = (0, node_path_1.resolve)(projectLocalDir, 'materials', 'outline_sheet.png');
-        const hasOutlineSheet = (0, node_fs_1.existsSync)(outlineSheetImagePath);
-        // 校验 prompt 与 storyboard.json 中分镜设定的一致性（如果提供了 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 语法合法性
-                    let storyBoard;
-                    try {
-                        storyBoard = JSON.parse(storyBoardContent);
-                    }
-                    catch (jsonError) {
-                        return createErrorResponse(`storyBoard 文件 ${storyBoardFile} 存在 JSON 语法错误，请修复后重试。错误详情: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`, 'generate-video-by-ref');
-                    }
-                    if (storyBoard.scenes && Array.isArray(storyBoard.scenes)) {
-                        const scene = storyBoard.scenes[sceneIndex - 1]; // sceneIndex 从1开始，数组从0开始
-                        if (scene) {
-                            const videoPrompt = scene.video_prompt;
-                            if (videoPrompt && prompt.trim() !== videoPrompt?.trim()) {
-                                return createErrorResponse('视频提示词必须严格遵照storyboard的设定，内容完全一致，包括空格、回车、标点和特殊符号，检查传入的prompt参数与storyboard中的video_prompt是否完全一致', 'generate-video-by-ref');
-                            }
-                            // 检查 scene.is_continuous 是否为 true
-                            if (scene.is_continuous === true) {
-                                return createErrorResponse('连续镜头应使用首尾帧，请修改连续镜头设置，或将本分镜改为首尾帧方式实现', 'generate-video-by-ref');
-                            }
-                            if (scene.video_type !== 'references') {
-                                return createErrorResponse(`分镜 ${sceneIndex} 中的 video_type (${scene.video_type}) 未设置为 'references'，不应当使用参考生视频，请使用图生视频 generate-video 方式生成`, 'generate-video-by-ref');
-                            }
-                            // 检查 use_video_model 与 type 参数的一致性
-                            if (scene.use_video_model &&
-                                type &&
-                                scene.use_video_model !== type) {
-                                return createErrorResponse(`分镜 ${sceneIndex} 中的 use_video_model (${scene.use_video_model}) 必须与 type 参数 (${type}) 保持一致`, 'generate-video-by-ref');
-                            }
-                            // 检查 scene.references 的一致性
-                            if (scene.references &&
-                                Array.isArray(scene.references) &&
-                                scene.references.length > 0) {
-                                // 获取 main_characters 和 reference_objects
-                                const mainCharacters = storyBoard.main_characters || [];
-                                const referenceObjects = storyBoard.reference_objects || [];
-                                for (const referenceName of scene.references) {
-                                    let found = false;
-                                    let requiredImage = '';
-                                    // 检查是否在 main_characters 中
-                                    const character = mainCharacters.find((char) => char.name === referenceName);
-                                    if (character) {
-                                        if (!character.reference_image) {
-                                            return createErrorResponse(`分镜 ${sceneIndex} 中引用的角色 "${referenceName}" 在 main_characters 中没有 reference_image 属性`, 'generate-video-by-ref');
-                                        }
-                                        requiredImage = character.reference_image;
-                                        found = true;
-                                    }
-                                    // 检查是否在 reference_objects 中
-                                    if (!found) {
-                                        const refObject = referenceObjects.find((obj) => obj.name === referenceName);
-                                        if (refObject) {
-                                            if (!refObject.image) {
-                                                return createErrorResponse(`分镜 ${sceneIndex} 中引用的物品/背景 "${referenceName}" 在 reference_objects 中没有 image 属性`, 'generate-video-by-ref');
-                                            }
-                                            requiredImage = refObject.image;
-                                            found = true;
-                                        }
-                                    }
-                                    // 如果既不在 main_characters 也不在 reference_objects 中
-                                    if (!found) {
-                                        return createErrorResponse(`分镜 ${sceneIndex} 中引用的 "${referenceName}" 在 main_characters 或 reference_objects 中都找不到对应的定义`, 'generate-video-by-ref');
-                                    }
-                                    // 检查对应的图片是否在 referenceImages 参数中
-                                    if (!referenceImages.some(ref => ref.fileName === requiredImage)) {
-                                        return createErrorResponse(`分镜 ${sceneIndex} 中引用的 "${referenceName}" 对应的图片 "${requiredImage}" 不在 referenceImages 参数中，请确保传入正确的参考图片`, 'generate-video-by-ref');
-                                    }
-                                }
-                            }
-                            // 检查 storyBoard.orientation 与 size 参数的一致性
-                            if (storyBoard.orientation) {
-                                const isLandscapeSize = aspectRatio === '16:9';
-                                const isPortraitSize = aspectRatio === '9:16';
-                                if (storyBoard.orientation === 'landscape' &&
-                                    !isLandscapeSize) {
-                                    return createErrorResponse(`故事板设定为横屏模式(orientation: landscape)，但视频为竖屏格式，请使用横屏尺寸 1280x720`, 'generate-video-by-ref');
-                                }
-                                if (storyBoard.orientation === 'portrait' &&
-                                    !isPortraitSize) {
-                                    return createErrorResponse(`故事板设定为竖屏模式(orientation: portrait)，但视频为横屏格式，请使用竖屏尺寸 720x1280`, 'generate-video-by-ref');
-                                }
-                            }
-                        }
-                        else {
-                            console.warn(`Scene index ${sceneIndex} not found in storyboard.json`);
-                        }
-                    }
-                }
-                else {
-                    console.warn(`Story board file not found: ${storyBoardPath}`);
-                }
-            }
-            catch (error) {
-                console.error('Failed to validate prompt with story board:', error);
-                // 如果读取或解析 storyboard.json 失败，继续执行但记录警告
-            }
-        }
-        const validatedFileName = validateFileName(saveToFileName);
-        // 验证参考图数量限制
-        if ((type === 'sora2' ||
-            type === 'sora2-pro' ||
-            type === 'veo3.1' ||
-            type === 'veo3.1-pro') &&
-            referenceImages.length > 4) {
-            return createErrorResponse(`${type} model only supports maximum 4 reference image`, 'generate-video-by-ref');
-        }
-        if (referenceImages.length > 7) {
-            return createErrorResponse('Only support maximum 7 reference images', 'generate-video-by-ref');
-        }
-        console.log(`Generating video ${referenceImages.length > 0 ? `with ${referenceImages.length} reference image(s)` : 'without reference images'} using ${type} model...`);
-        const task = referenceImages.map(async (imageRef) => {
-            const imageUrl = await getMaterialUri(currentSession, imageRef.fileName, {
-                fileSizeLimit: 10,
-            });
-            return {
-                type: imageRef.type,
-                name: imageRef.name,
-                url: imageUrl,
-            };
-        });
-        // 处理参考图：转换为URL而不是base64
-        const referenceImageUrls = await Promise.all(task);
-        // for (const imageRef of referenceImages) {
-        //   // 使用 getMaterialUri 获取图片URL
-        //   const imageUrl = await getMaterialUri(
-        //     currentSession,
-        //     imageRef.fileName,
-        //     {
-        //       fileSizeLimit: 10,
-        //     }
-        //   );
-        //   referenceImageUrls.push({
-        //     type: imageRef.type,
-        //     name: imageRef.name,
-        //     url: imageUrl,
-        //   });
-        //   console.log(
-        //     `Added reference image URL: ${imageUrl} (name: ${imageRef.name}, type: ${imageRef.type})`
-        //   );
-        // }
-        const finalPrompt = `${prompt}`;
-        const videos = referenceVideo
-            ? [
-                {
-                    type: 'video',
-                    name: referenceVideo.name,
-                    url: await getMaterialUri(currentSession, referenceVideo.fileName, {
-                        fileSizeLimit: 50,
-                    }),
-                },
-            ]
-            : undefined;
-        // 调用 referencesToVideo 函数
-        let progress = 0;
-        const result = await currentSession.ai.referencesToVideo({
-            prompt: finalPrompt,
-            reference_images: referenceImageUrls, // 使用URL数组而不是base64数组
-            duration,
-            aspect_ratio: aspectRatio,
-            resolution,
-            type,
-            mute: !audio,
-            enableBGM: bgm,
-            seed,
-            videos,
-            optimizeCameraMotion,
-            autoStoryboard,
-            storyboardPanelCount: storyboardPanelCount
-                ? Number(storyboardPanelCount)
-                : undefined,
-            onProgress: metaData => {
-                console.log('Video generation progress:', metaData);
-                if (metaData.storyboard) {
-                    const url = metaData.storyboard.url;
-                    // 将它用 saveToFileName 的 basename + .storyboard.png 保存到本地
-                    const storyboardFileName = `${saveToFileName.split('.')[0]}-storyboard.png`;
-                    saveMaterial(currentSession, url, storyboardFileName);
-                }
-                sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
-            },
-            waitForFinish: CLIENT_TYPE !== '5ire',
-        });
-        if (result.error) {
-            return createErrorResponse(result.error, 'generate-video-by-ref');
-        }
-        if (!result.url && !result.taskUrl) {
-            return createErrorResponse('Video generation failed: no video URL returned', 'generate-video-by-ref');
-        }
-        else if (result.taskUrl) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: '该视频生成任务正在运行中，它是异步任务，且执行时间较长，你应立即调用工具 wait-for-task-finish 来等待任务结束，如如 wait-for-task-finish 工具调用超时，你应立即再次重新调用直到任务结束。',
-                            taskUrl: result.taskUrl,
-                        }),
-                    },
-                ],
-            };
-        }
-        // 下载生成的视频
-        const video = await saveMaterial(currentSession, result.url, validatedFileName);
-        // 更新媒体日志
-        await updateMediaLogs(currentSession, validatedFileName, {
-            model: type,
-            duration: result.duration,
-            resolution: result.resolution,
-            ratio: result.ratio,
-            reference_images_count: referenceImages.length,
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: referenceImages.length > 0
-                            ? `Video generated successfully using ${referenceImages.length} reference image(s) with ${type} model`
-                            : `Video generated successfully without reference images using ${type} model`,
-                        video,
-                        duration: result.duration,
-                        resolution: result.resolution,
-                        ratio: result.ratio,
-                        url: result.url,
-                        last_frame_url: result.last_frame_url,
-                        referenceImageUrls,
-                        prompt: finalPrompt,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        console.error('Error generating video by reference:', error);
-        return createErrorResponse(error.message, 'generate-video-by-ref');
-    }
-});
-server.registerTool('edit-video', {
-    title: 'Edit Video',
-    description: `根据不同type修改视频，包括编辑、对口型、延长、超清`,
-    inputSchema: {
-        type: zod_1.z
-            .enum(['edit', 'lipsync', 'extend', 'upscale'])
-            .default('edit')
-            .describe('The editing type'),
-        video: zod_1.z.string().describe(`The video to edit`),
-        duration: zod_1.z
-            .number()
-            .min(0)
-            .max(7)
-            .optional()
-            .describe(`0 表示与原视频相同。编辑视频时如用户未指定，默认为 0。`),
-        resolution: zod_1.z
-            .enum(['720p', '1080p', '2K', '4K'])
-            .optional()
-            .describe(`延长视频和超清视频时的分辨率（可选）`),
-        prompt: zod_1.z
-            .string()
-            .optional()
-            .describe(`编辑或延长视频的提示词，对口型或超清可忽略`),
-        referenceImages: zod_1.z
-            .array(zod_1.z.object({
-            name: zod_1.z.string().describe('图片名称，人物名、图片背景名或物品名'),
-            fileName: zod_1.z.string().describe('Reference image file name'),
-            type: zod_1.z.enum(['subject', 'background', 'last_frame']),
-        }))
-            .optional()
-            .describe(`编辑视频时传参考图，延长视频时传尾帧图，其他情况忽略`),
-        saveToFileName: zod_1.z.string().describe(`应该是mp4文件`),
-    },
-}, async ({ type, video, duration = 0, resolution, prompt, referenceImages, saveToFileName, }, context) => {
-    try {
-        const currentSession = await validateSession('edit-video');
-        const ai = currentSession.ai;
-        const validatedFileName = validateFileName(saveToFileName);
-        let res = {};
-        let progress = 0;
-        if (type === 'extend' && (resolution === '2K' || resolution === '4K')) {
-            throw new Error('Extend type only supports 720p resolution or 1080p resolution');
-        }
-        if (type === 'upscale' && resolution === '720p') {
-            throw new Error('720p resolution is not supported for upscale type');
-        }
-        const onProgress = async (metaData) => {
-            console.log('Replace video progress:', metaData);
-            try {
-                await sendProgress(context, ++progress, undefined, JSON.stringify(metaData));
-            }
-            catch (progressError) {
-                console.warn('Failed to send progress update:', progressError);
-            }
-        };
-        let referenceImageUrls = undefined;
-        if (referenceImages) {
-            const tasks = referenceImages.map(async (file) => {
-                const url = await getMaterialUri(currentSession, file.fileName, {
-                    fileSizeLimit: 10,
-                });
-                return {
-                    name: file.name,
-                    url,
-                    type: file.type,
-                };
-            });
-            referenceImageUrls = await Promise.all(tasks);
-        }
-        const videoUrl = await getMaterialUri(currentSession, video, {
-            fileSizeLimit: 50,
-        });
-        if (type === 'edit') {
-            if (!prompt) {
-                throw new Error('prompt is required for edit type');
-            }
-            res = await ai.editVideo({
-                videoUrl,
-                prompt,
-                referenceImages: referenceImageUrls?.map(item => item.url),
-                onProgress,
-                waitForFinish: CLIENT_TYPE !== '5ire',
-            });
-        }
-        else if (type === 'lipsync') {
-            // 调用AI的lipSync方法，使用处理后的音频
-            const { audio: audioUrl } = await ai.splitVideoAndAudio({
-                videoUrl,
-            });
-            res = await ai.lipSync({
-                videoUrl,
-                audioUrl,
-                audioInMs: 0,
-                pad_audio: false,
-                onProgress,
-                waitForFinish: CLIENT_TYPE !== '5ire',
-            });
-        }
-        else if (type === 'extend') {
-            res = await ai.extendVideo({
-                video_url: videoUrl,
-                resolution: resolution || '720p',
-                prompt,
-                duration: duration || 5,
-                end_frame: referenceImageUrls?.[0].url,
-                onProgress,
-                waitForFinish: CLIENT_TYPE !== '5ire',
-            });
-        }
-        else if (type === 'upscale') {
-            res = await ai.upscaleVideo({
-                video_url: videoUrl,
-                resolution,
-                onProgress,
-                waitForFinish: CLIENT_TYPE !== '5ire',
-            });
-        }
-        if (res.url) {
-            const video = await saveMaterial(currentSession, res.url, validatedFileName);
-            const result = {
-                success: true,
-                // source: url,
-                video,
-                prompt,
-                timestamp: new Date().toISOString(),
-            };
-            // Update media_logs.json
-            try {
-                await updateMediaLogs(currentSession, validatedFileName, result);
-            }
-            catch (error) {
-                console.warn(`Failed to update media_logs.json for ${validatedFileName}:`, error);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result),
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: 'No video URL returned from AI service',
-                        response: res,
-                        timestamp: new Date().toISOString(),
-                    }),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return createErrorResponse(error, 'edit-video');
-    }
-});
 server.registerTool('media-analyzer', {
     title: 'Media Analyzer',
     description: 'Analyze media content (images, videos, audio) using Doubao-Seed-1.8 model to understand specific details for creative work.',