diff --git a/src/components/FileProcessor.vue b/src/components/FileProcessor.vue
new file mode 100644
index 0000000..efe250e
--- /dev/null
+++ b/src/components/FileProcessor.vue
@@ -0,0 +1,153 @@
+<template>
+    <div class="file-processor">
+      <!-- 这里可以添加上传进度等UI组件 -->
+    </div>
+  </template>
+  
+  <script>
+  import { getUserMedia, getDisplayMedia, float32ArrayToBlob } from "@/utils/stream";
+  import { MEDIA_TYPE } from "@/constants/modules/audioVideoCall";
+  import emitter from "@/utils/event";
+  import { sleep } from "@/utils/tools";
+  import awaitTo from "@/utils/await-to-js";
+  import AudioManagerClass from "@/utils/audio";
+  
+  export default {
+    name: "FileProcessor",
+    data() {
+      return {
+        videoContext: null,
+        audioContext: null,
+        extractFrameTimer: null,
+        audioManager: null,
+        isProcessing: false
+      };
+    },
+    methods: {
+      // 处理上传的文件
+      async processFiles(videoFile, audioFile) {
+        this.isProcessing = true;
+        
+        try {
+          // 1. 处理视频文件
+          await this.processVideo(videoFile);
+          
+          // 2. 处理音频文件 
+          await this.processAudio(audioFile);
+          
+          return { success: true };
+        } catch (error) {
+          console.error('File processing failed:', error);
+          return { success: false, error };
+        } finally {
+          this.isProcessing = false;
+        }
+      },
+  
+      // 处理视频文件并抽帧
+      async processVideo(videoFile) {
+        // 创建视频元素
+        const video = document.createElement('video');
+        video.src = URL.createObjectURL(videoFile);
+        
+        await new Promise((resolve) => {
+          video.onloadedmetadata = () => resolve();
+        });
+  
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        
+        // 设置canvas尺寸为视频尺寸
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+  
+        // 开始播放视频
+        await video.play();
+        
+        // 每隔指定时间抽取一帧
+        const extractFrameRate = 1000; // 每秒抽一帧，可以根据需要调整
+        
+        return new Promise((resolve) => {
+          this.extractFrameTimer = setInterval(() => {
+            // 绘制当前帧到canvas
+            ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+            
+            // 将帧转换为blob并发送
+            canvas.toBlob((blob) => {
+              if (blob) {
+                this.sendVideoFrame(blob);
+              }
+            }, 'image/jpeg');
+  
+            // 如果视频播放结束，停止抽帧
+            if(video.ended) {
+              clearInterval(this.extractFrameTimer);
+              resolve();
+            }
+          }, extractFrameRate);
+        });
+      },
+  
+      // 处理音频文件
+      async processAudio(audioFile) {
+        // 创建音频管理实例
+        this.audioManager = new AudioManagerClass({
+          sampleRate: 16000,
+          average: 35,
+          analyserRate: 50
+        });
+  
+        // 读取音频文件并转换为AudioBuffer
+        const arrayBuffer = await audioFile.arrayBuffer();
+        const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+  
+        // 将AudioBuffer转换为Float32Array
+        const channelData = audioBuffer.getChannelData(0);
+        
+        // 分段处理音频数据
+        const chunkSize = 4096; // 每个块的大小
+        for(let i = 0; i < channelData.length; i += chunkSize) {
+          const chunk = channelData.slice(i, i + chunkSize);
+          const audioBlob = float32ArrayToBlob('audio/wav', chunk, audioBuffer.sampleRate);
+          await this.sendAudioData(audioBlob);
+        }
+      },
+  
+      // 发送视频帧数据
+      async sendVideoFrame(blob) {
+        const base64 = await this.blobToBase64(blob);
+        this.$emit('onVideoFrame', base64);
+      },
+  
+      // 发送音频数据
+      async sendAudioData(blob) {
+        const base64 = await this.blobToBase64(blob);
+        this.$emit('onAudioData', base64);
+      },
+  
+      // Blob转Base64
+      blobToBase64(blob) {
+        return new Promise((resolve) => {
+          const reader = new FileReader();
+          reader.onloadend = () => resolve(reader.result.split(',')[1]);
+          reader.readAsDataURL(blob);
+        });
+      },
+  
+      // 清理资源
+      cleanup() {
+        if(this.extractFrameTimer) {
+          clearInterval(this.extractFrameTimer);
+        }
+        if(this.audioContext) {
+          this.audioContext.close();
+        }
+      }
+    },
+    
+    beforeDestroy() {
+      this.cleanup();
+    }
+  };
+  </script>
\ No newline at end of file
diff --git a/src/router/index.js b/src/router/index.js
index bc75041..0e1372b 100644
--- a/src/router/index.js
+++ b/src/router/index.js
@@ -1,5 +1,6 @@
 import { createRouter, createWebHistory } from 'vue-router';
 import AudioVideoCall from '../views/AudioVideoCall/Index.vue';
+import FileUpload from '@/views/FileUpload/Index.vue'; // 2025-04-21
 
 // 定义路由
 const routes = [
@@ -7,6 +8,10 @@ const routes = [
     path: '/',
     name: 'Home',
     component: AudioVideoCall
+  },
+  {
+    path: '/upload',
+    component: FileUpload
   }
 ];
 
diff --git a/src/server/index.js b/src/server/index.js
new file mode 100644
index 0000000..4372109
--- /dev/null
+++ b/src/server/index.js
@@ -0,0 +1,20 @@
+import 'dotenv/config';
+import express from 'express';
+import cors from 'cors';
+import uploadRouter from './server.js';
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+app.use(cors());
+app.use(express.json());
+app.use('/api', uploadRouter);
+
+app.listen(port, () => {
+    console.log(`Server is running on port ${port}`);
+    console.log('Environment:', {
+        VITE_APP_DOMAIN: process.env.VITE_APP_DOMAIN,
+        VITE_APP_PROXY_PATH: process.env.VITE_APP_PROXY_PATH,
+        API_KEY: process.env.API_KEY ? '已设置' : '未设置'
+    });
+});
\ No newline at end of file
diff --git a/src/server/server.js b/src/server/server.js
new file mode 100644
index 0000000..fb6d942
--- /dev/null
+++ b/src/server/server.js
@@ -0,0 +1,408 @@
+//视频发送出错，需要继续分析
+import path from 'path';
+import multer from 'multer';
+import express from 'express';
+import { WebSocket } from 'ws';
+import { promises as fs } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// 只保留一种导入方式，推荐使用 ES 模块的静态导入
+import { processVideoFrames, readFileAsBase64 } from '../views/FileUpload/videoProcessor.js';
+
+// 在代码开始处验证函数是否正确导入
+console.log('正在检查视频处理模块...');
+console.log('视频处理模块检查结果:', {
+    processVideoFrames: typeof processVideoFrames,
+    readFileAsBase64: typeof readFileAsBase64
+});
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+
+const router = express.Router();
+
+// 确保上传目录存在
+//const uploadDir = join(__dirname, '../../uploads');
+//await fs.mkdir(uploadDir, { recursive: true });
+
+// 使用异步方式配置 storage
+const storage = multer.diskStorage({
+    destination: async function (req, file, cb) {
+        const uploadDir = path.join(process.cwd(), 'uploads');
+        try {
+            await fs.access(uploadDir);
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                await fs.mkdir(uploadDir, { recursive: true });
+            }
+        }
+        cb(null, uploadDir);
+    },
+    filename: function (req, file, cb) {
+        const timestamp = Date.now();
+        const randomString = Math.random().toString(36).substring(7);
+        cb(null, `${file.fieldname}-${timestamp}-${randomString}${path.extname(file.originalname)}`);
+    }
+});
+
+const fileFilter = (req, file, cb) => {
+    if (file.fieldname === 'video') {
+        if (!file.mimetype.startsWith('video/')) {
+            return cb(new Error('只接受视频文件'));
+        }
+    } else if (file.fieldname === 'audio') {
+        if (!file.mimetype.startsWith('audio/')) {
+            return cb(new Error('只接受音频文件'));
+        }
+    }
+    cb(null, true);
+};
+
+const upload = multer({
+    storage: storage,
+    fileFilter: fileFilter,
+    limits: {
+        fileSize: 50 * 1024 * 1024, // 限制文件大小为 50MB
+    }
+}).fields([
+    { name: 'video', maxCount: 1 },
+    { name: 'audio', maxCount: 1 }
+]);
+
+// 处理文件上传的路由
+router.post('/upload', (req, res) => {
+    console.log('接收到上传请求');
+
+    upload(req, res, async function (err) {
+        console.log('multer 处理完成');
+
+        try {
+            if (err) {
+                console.error('文件上传错误:', err);
+                throw new Error('文件上传错误: ' + err.message);
+            }
+
+            if (!req.files || !req.files.video || !req.files.audio) {
+                console.error('文件缺失:', req.files);
+                throw new Error('缺少必要的文件');
+            }
+
+            const videoFile = req.files.video[0];
+            const audioFile = req.files.audio[0];
+
+            console.log('接收到的文件信息:');
+            console.log('视频文件:', {
+                path: videoFile.path,
+                size: videoFile.size,
+                mimetype: videoFile.mimetype
+            });
+            console.log('音频文件:', {
+                path: audioFile.path,
+                size: audioFile.size,
+                mimetype: audioFile.mimetype
+            });
+
+            // 检查文件是否真实存在
+            console.log('检查文件是否存在:');
+            //console.log('视频文件存在:', fs.existsSync(videoFile.path));
+            //console.log('音频文件存在:', fs.existsSync(audioFile.path));
+
+            console.log('开始调用 AI 处理...');
+            const messages = await processFilesAndCallAI(videoFile.path, audioFile.path);
+
+            // ... 其余代码保持不变
+        } catch (error) {
+            console.error('处理过程中出错:', error);
+            res.status(500).json({
+                success: false,
+                message: '处理失败',
+                error: error.message
+            });
+        }
+    });
+});
+
+
+// 简单的文件类型验证函数
+function isValidVideoFile(buffer) {
+    // 检查 MP4 文件头
+    const header = buffer.slice(4, 8);
+    return header.toString() === 'ftyp';
+}
+
+function isValidAudioFile(buffer) {
+    // 检查 WAV 文件头
+    const header = buffer.slice(0, 4);
+    return header.toString() === 'RIFF';
+}
+
+// 添加环境变量检查
+const checkEnvironmentVariables = () => {
+    const domain = process.env.VITE_APP_DOMAIN || 'https://api.zhipu.ai';
+    const proxyPath = process.env.VITE_APP_PROXY_PATH || '/eastai';
+    const apiKey = process.env.API_KEY || "d20c08612ef746beb7038a326131d475.cv71sxB0l7w8yOAO";
+
+    console.log('环境变量检查:');
+    console.log('VITE_APP_DOMAIN:', domain);
+    console.log('VITE_APP_PROXY_PATH:', proxyPath);
+    console.log('API_KEY:', apiKey ? '已设置' : '未设置');
+
+    return { domain, proxyPath, apiKey };
+};
+
+async function processFilesAndCallAI(videoPath, audioPath) {
+    try {
+        console.log('开始 AI 处理流程...');
+
+        // 修正环境变量的使用
+        const domain = process.env.VITE_APP_DOMAIN || 'https://api.zhipu.ai';
+        const proxyPath = process.env.VITE_APP_PROXY_PATH || '/eastai';  // 修正为正确的默认值
+        const apiKey = process.env.VITE_APP_API_KEY;  // 使用相同的环境变量名
+
+        // 检查环境变量
+        console.log('环境变量检查:');
+        console.log('DOMAIN:', domain);
+        console.log('PROXY_PATH:', proxyPath);
+        console.log('API_KEY 是否存在:', !!apiKey);
+
+        const wsUrl = `${domain}${proxyPath}/v4/realtime?Authorization=${apiKey}`;
+        console.log('WebSocket URL:', wsUrl.replace(/Authorization=.*$/, 'Authorization=***'));
+
+        // 创建文件对象
+        const videoFile = {
+            name: videoPath.split('/').pop(),
+            type: 'video/mp4',
+            size: (await fs.stat(videoPath)).size,
+            async arrayBuffer() {
+                return await fs.readFile(videoPath);
+            }
+        };
+
+        const audioFile = {
+            name: audioPath.split('/').pop(),
+            type: 'audio/wav',
+            size: (await fs.stat(audioPath)).size,
+            async arrayBuffer() {
+                return await fs.readFile(audioPath);
+            }
+        };
+
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(wsUrl);
+            let messages = [];
+
+            ws.on('open', async () => {
+                try {
+                    console.log('WebSocket 连接已建立');
+
+                    // 1. 发送会话配置
+                    console.log('发送会话配置...');
+                    ws.send(JSON.stringify({
+                        type: 'session.update',
+                        session: {
+                            turn_detection: {
+                                type: 'client_vad',
+                            },
+                            beta_fields: {
+                                chat_mode: 'video_passive',
+                            },
+                            output_audio_format: "mp3",
+                            input_audio_format: "wav",
+                        }
+                    }));
+
+                    // 2. 处理视频帧
+                    console.log('开始处理视频帧...');
+                    const videoFrames = await processVideoFrames(videoFile, (progress) => {
+                        console.log(`视频处理进度: ${progress}%`);
+                    });
+                    console.log(`提取到 ${videoFrames.length} 个视频帧`);
+
+                    // 3. 发送视频帧 - 
+                    console.log('开始发送视频帧...');
+                    for (const frameData of videoFrames) {
+                        ws.send(JSON.stringify({
+                            type: 'video.append',
+                            client_timestamp: 0,  // 使用固定时间戳
+                            video_frame: frameData  // 直接发送 base64 字符串
+                        }));
+                    }
+                    console.log('视频帧发送完成');
+
+                    // 等待一下确保视频帧处理完成
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+
+                    // 4. 处理并发送音频数据
+                    // 在 server.js 中修改音频文件处理
+                    // 4. 处理并发送音频数据
+                    console.log('开始处理音频...');
+                    console.log('音频文件路径:', audioPath);
+
+                    try {
+                        await fs.access(audioPath);
+                        const audioBase64 = await readFileAsBase64(audioFile);
+                        console.log('音频数据准备完成');
+
+                        // 发送音频开始标记
+                        ws.send(JSON.stringify({
+                            type: 'audio.start',
+                            client_timestamp: Date.now()
+                        }));
+
+                        // 发送音频数据
+                        ws.send(JSON.stringify({
+                            type: 'audio.append',
+                            client_timestamp: Date.now(),
+                            audio: audioBase64,
+                            role: 'user',
+                            receive_voice: true
+                        }));
+                        console.log('音频数据发送完成');
+
+                        // 发送音频结束标记
+                        ws.send(JSON.stringify({
+                            type: 'audio.end',
+                            client_timestamp: Date.now()
+                        }));
+
+                    } catch (error) {
+                        console.error('音频文件处理失败:', error);
+                        throw error;
+                    }
+
+                    // 5. 发送提交指令
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    console.log('发送提交指令...');
+                    ws.send(JSON.stringify({
+                        type: 'commit',
+                        client_timestamp: Date.now()
+                    }));
+                    console.log('提交指令发送完成');
+
+                } catch (error) {
+                    console.error('处理过程中出错:', error);
+                    ws.close();
+                    reject(error);
+                }
+            });
+
+            ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data);
+                    console.log('收到 WebSocket 消息:', message.type);
+
+                    switch (message.type) {
+                        case 'response.audio_txt':
+                        case 'response.text':
+                            console.log('收到响应内容:', message.delta);
+                            messages.push(message.delta);
+                            break;
+
+                        case 'response.audio_done':
+                            console.log('AI 处理完成');
+                            ws.close();
+                            break;
+
+                        case 'error':
+                            console.error('收到错误消息:', message.error);
+                            ws.close();
+                            reject(new Error(message.error?.message || '处理失败'));
+                            break;
+                    }
+                } catch (err) {
+                    console.error('处理消息时出错:', err);
+                    ws.close();
+                    reject(err);
+                }
+            });
+
+            ws.on('error', (error) => {
+                console.error('WebSocket 错误:', error);
+                reject(error);
+            });
+
+            ws.on('close', () => {
+                console.log('WebSocket 连接已关闭');
+                if (messages.length > 0) {
+                    resolve(messages);
+                } else {
+                    reject(new Error('处理完成但没有收到任何消息'));
+                }
+            });
+        });
+    } catch (error) {
+        console.error('AI 处理过程中出错:', error);
+        throw error;
+    }
+}
+// 在上传路由中调用 AI 处理
+router.post('/upload', (req, res) => {
+    upload(req, res, async function (err) {
+        console.log('开始处理上传请求');
+
+        try {
+            // 处理 multer 错误
+            if (err instanceof multer.MulterError) {
+                throw new Error(`文件上传错误: ${err.code}`);
+            } else if (err) {
+                throw new Error(`文件上传错误: ${err.message}`);
+            }
+
+            // 验证文件是否存在
+            if (!req.files || !req.files.video || !req.files.audio) {
+                throw new Error('缺少必要的文件');
+            }
+
+            const videoFile = req.files.video[0];
+            const audioFile = req.files.audio[0];
+
+            // 记录文件信息
+            console.log('接收到的文件:');
+            console.log('视频文件:', videoFile.path);
+            console.log('音频文件:', audioPath);
+
+            // 确认文件存在
+            if (!fs.existsSync(videoFile.path) || !fs.existsSync(audioFile.path)) {
+                throw new Error('文件保存失败');
+            }
+
+            console.log('开始调用 AI 处理...');
+            const messages = await processFilesAndCallAI(videoFile.path, audioFile.path);
+            console.log('AI 处理返回的消息:', messages);
+
+            // 清理文件
+            await Promise.all([
+                fs.unlink(videoFile.path).catch(e => console.error('清理视频文件失败:', e)),
+                fs.unlink(audioFile.path).catch(e => console.error('清理音频文件失败:', e))
+            ]);
+
+            res.json({
+                success: true,
+                message: '处理成功',
+                data: { messages }
+            });
+
+        } catch (error) {
+            console.error('处理过程中出错:', error);
+
+            // 清理文件（如果存在）
+            if (req.files) {
+                await Promise.all(Object.values(req.files).flat().map(file =>
+                    fs.unlink(file.path).catch(e =>
+                        console.error(`清理文件 ${file.path} 失败:`, e)
+                    )
+                ));
+            }
+
+            res.status(500).json({
+                success: false,
+                message: '处理失败',
+                error: error.message
+            });
+        }
+    });
+});
+
+export default router;
\ No newline at end of file
diff --git a/src/views/FileProcessing.vue b/src/views/FileProcessing.vue
new file mode 100644
index 0000000..bdd8aa2
--- /dev/null
+++ b/src/views/FileProcessing.vue
@@ -0,0 +1,245 @@
+<template>
+  <div class="file-processing">
+    <div class="upload-section">
+      <div class="file-input">
+        <label>视频文件：</label>
+        <input type="file" accept="video/*" @change="handleVideoUpload" />
+        <span v-if="videoFile">已选择: {{ videoFile.name }}</span>
+      </div>
+      
+      <div class="file-input">
+        <label>音频文件：</label>
+        <input type="file" accept="audio/*" @change="handleAudioUpload" />
+        <span v-if="audioFile">已选择: {{ audioFile.name }}</span>
+      </div>
+
+      <div class="process-button">
+        <button 
+          class="start-button" 
+          @click="startProcessing" 
+          :disabled="!canProcess"
+          :class="{ 'button-disabled': !canProcess }"
+        >
+          {{ isProcessing ? '处理中...' : '开始处理' }}
+        </button>
+      </div>
+      
+      <div v-if="isProcessing" class="processing-status">
+        <div class="status-text">正在处理文件...</div>
+        <div v-if="processStats.videoFrames || processStats.audioChunks">
+          处理进度：
+          <div>视频帧：{{ processStats.videoFrames }}</div>
+          <div>音频块：{{ processStats.audioChunks }}</div>
+        </div>
+      </div>
+    </div>
+    
+    <FileProcessor 
+      ref="fileProcessor"
+      @onVideoFrame="handleVideoFrame"
+      @onAudioData="handleAudioData"
+    />
+  </div>
+</template>
+
+<script>
+import FileProcessor from '@/components/FileProcessor.vue';
+import { SOCKET_STATUS } from '@/constants/modules/audioVideoCall';
+
+export default {
+  name: 'FileProcessing',
+  components: {
+    FileProcessor
+  },
+  
+  data() {
+    return {
+      videoFile: null,
+      audioFile: null,
+      sock: null,
+      isConnected: false,
+      isProcessing: false,
+      processStats: {
+        videoFrames: 0,
+        audioChunks: 0
+      },
+      wsUrl: `wss://open.bigmodel.cn/api/paas/v4/realtime?Authorization=f2fa9dda05124b6a89a2eebb7c7396db.fsGVk256VE2hWHtW}` // 替换为实际的WebSocket服务器地址
+    };
+  },
+  
+  computed: {
+    canProcess() {
+      return this.videoFile && this.audioFile && !this.isProcessing;
+    }
+  },
+  
+  methods: {
+    handleVideoUpload(event) {
+      const file = event.target.files[0];
+      if (file) {
+        console.log('Selected video file:', file.name);
+        this.videoFile = file;
+      }
+    },
+    
+    handleAudioUpload(event) {
+      const file = event.target.files[0];
+      if (file) {
+        console.log('Selected audio file:', file.name);
+        this.audioFile = file;
+      }
+    },
+    
+    // 初始化WebSocket连接
+    async initWebSocket() {
+      return new Promise((resolve, reject) => {
+        try {
+          this.sock = new WebSocket(this.wsUrl);
+          
+          this.sock.onopen = () => {
+            console.log('WebSocket connected');
+            this.isConnected = true;
+            this.sessionUpdate();
+            resolve();
+          };
+          
+          this.sock.onclose = () => {
+            console.log('WebSocket disconnected');
+            this.isConnected = false;
+          };
+          
+          this.sock.onerror = (error) => {
+            console.error('WebSocket error:', error);
+            reject(error);
+          };
+          
+          this.sock.onmessage = (event) => {
+            this.handleWsResponse(event.data);
+          };
+        } catch (error) {
+          reject(error);
+        }
+      });
+    },
+    
+    // 处理视频帧数据
+    handleVideoFrame(base64Data) {
+      if (!this.isConnected) {
+        console.warn('WebSocket not connected');
+        return;
+      }
+      
+      const params = {
+        type: SOCKET_STATUS.VIDEO_APPEND,
+        client_timestamp: Date.now(),
+        video_frame: base64Data
+      };
+      
+      this.sendMessage(params);
+      this.processStats.videoFrames++;
+    },
+    
+    // 处理音频数据
+    handleAudioData(base64Data) {
+      if (!this.isConnected) {
+        console.warn('WebSocket not connected');
+        return;
+      }
+      
+      const params = {
+        type: SOCKET_STATUS.AUDIO_APPEND,
+        client_timestamp: Date.now(),
+        audio: base64Data
+      };
+      
+      this.sendMessage(params);
+      this.processStats.audioChunks++;
+    },
+    
+    // 发送WebSocket消息
+    sendMessage(params) {
+      if (this.sock && this.isConnected) {
+        this.sock.send(JSON.stringify(params));
+      }
+    },
+    
+    // 设置会话信息
+    sessionUpdate() {
+      const params = {
+        event_id: "evt_" + Date.now(),
+        type: SOCKET_STATUS.SESSION_UPDATE,
+        session: {
+          // 设置会话参数，根据实际需要配置
+          model: "default",
+          temperature: 0.7,
+          // ... 其他参数
+        }
+      };
+      this.sendMessage(params);
+    },
+    
+    // 处理WebSocket响应
+    handleWsResponse(data) {
+      try {
+        const res = JSON.parse(data);
+        console.log('Received WebSocket response:', res);
+        
+        switch (res.type) {
+          case SOCKET_STATUS.SESSION_CREATED:
+            console.log('Session created');
+            break;
+            
+          case SOCKET_STATUS.RESPONSE_AUDIO:
+            console.log('Received audio response');
+            break;
+            
+          case SOCKET_STATUS.ERROR:
+            console.error('Server error:', res.error);
+            break;
+            
+          // ... 处理其他响应类型
+        }
+      } catch (e) {
+        console.error('Failed to parse WebSocket response:', e);
+      }
+    },
+    
+    async startProcessing() {
+      if (!this.canProcess) {
+        console.log('Cannot process: missing files or already processing');
+        return;
+      }
+      
+      this.isProcessing = true;
+      this.processStats = { videoFrames: 0, audioChunks: 0 };
+      
+      try {
+        console.log('Starting processing...');
+        
+        // 1. 建立WebSocket连接
+        await this.initWebSocket();
+        
+        // 2. 开始处理文件
+        await this.$refs.fileProcessor.processFiles(this.videoFile, this.audioFile);
+        
+        console.log('Processing completed successfully');
+      } catch (error) {
+        console.error('Processing failed:', error);
+        alert('处理失败，请重试');
+      } finally {
+        this.isProcessing = false;
+      }
+    }
+  },
+  
+  beforeUnmount() {
+    if (this.sock) {
+      this.sock.close();
+    }
+  }
+};
+</script>
+
+<style lang="less">
+// ... 保持原有样式不变
+</style>
\ No newline at end of file
diff --git a/src/views/FileUpload/Index.vue b/src/views/FileUpload/Index.vue
new file mode 100644
index 0000000..dbe77ad
--- /dev/null
+++ b/src/views/FileUpload/Index.vue
@@ -0,0 +1,632 @@
+<template>
+    <div class="file-upload">
+      <div class="file-upload__header">
+        <h3>文件上传处理</h3>
+      </div>
+      <div class="file-upload__content">
+        <!-- 上传区域 -->
+        <div class="upload-section">
+          <div class="upload-box">
+            <h4>视频文件</h4>
+            <input 
+              type="file" 
+              accept="video/*"
+              @change="handleVideoUpload"
+            >
+            <div v-if="videoFile" class="file-info">
+              已选择: {{ videoFile.name }}
+            </div>
+          </div>
+          <div class="upload-box">
+            <h4>音频文件</h4>
+            <input 
+              type="file"
+              accept="audio/*" 
+              @change="handleAudioUpload"
+            >
+            <div v-if="audioFile" class="file-info">
+              已选择: {{ audioFile.name }}
+            </div>
+          </div>
+        </div>
+  
+        <!-- 处理状态和进度显示 -->
+        <div class="process-status">
+          <div v-if="processing || currentStep" class="process-progress">
+            {{ currentStep }}: {{ progress }}%
+          </div>
+  
+          <!-- 日志显示区域 -->
+          <div v-if="debugLogs.length" class="debug-logs">
+            <div v-for="(log, index) in debugLogs" 
+                 :key="index" 
+                 :class="['log-entry', log.type]">
+              <span class="log-time">{{ log.timestamp }}</span>
+              <span class="log-message">{{ log.message }}</span>
+            </div>
+          </div>
+  
+          <!-- 消息列表 -->
+          <div v-if="messageList.length" class="message-list">
+            <div v-for="(msg, index) in messageList" 
+                 :key="msg.id || index"
+                 class="message-item"
+                 :class="msg.type">
+              <div class="message-time">{{ formatTime(msg.timestamp) }}</div>
+              <div v-if="msg.textContent?.length" class="message-content">
+                <div v-for="(text, i) in msg.textContent" 
+                     :key="i"
+                     class="message-text">
+                  {{ text }}
+                </div>
+              </div>
+              <div v-if="msg.audioUrl" class="audio-player">
+                <audio :src="msg.audioUrl" controls></audio>
+              </div>
+            </div>
+          </div>
+        </div>
+  
+        <!-- 操作按钮 -->
+        <el-button 
+          type="primary"
+          :loading="processing"
+          @click="processFiles"
+          :disabled="!videoFile || !audioFile"
+        >
+          开始处理
+        </el-button>
+      </div>
+    </div>
+  </template>
+  
+  <script>
+  import { processVideoFrames, readFileAsBase64 } from './videoProcessor'
+  import { MSG_TYPE, SOCKET_STATUS, VAD_TYPE, CALL_MODE_TYPE } from "@/constants/modules/audioVideoCall"
+  
+  export default {
+    name: 'FileUpload',
+    data() {
+      return {
+        videoFile: null,
+        audioFile: null,
+        processing: false,
+        progress: 0,
+        currentStep: '',
+        messageList: [],
+        wsConnection: null,
+        currentRequestId: '',
+        currentResponseId: '',
+        debugLogs: []
+      }
+    },
+    methods: {
+      // 添加时间格式化方法
+      formatTime(timestamp) {
+        if (!timestamp) return ''
+        const date = new Date(timestamp)
+        return date.toLocaleTimeString()
+      },
+      // 添加日志函数
+      addLog(message, type = 'info') {
+        const timestamp = new Date().toLocaleTimeString()
+        this.debugLogs.push({ timestamp, message, type })
+        console.log(`${type.toUpperCase()}: ${message}`)
+      },
+      // 处理视频文件选择
+      handleVideoUpload(event) {
+        const file = event.target.files[0]
+        if (file && file.type.startsWith('video/')) {
+          this.videoFile = file
+          this.addLog(`选择视频文件: ${file.name} (${Math.round(file.size / 1024 / 1024)}MB)`)
+        }
+      },
+  
+      // 处理音频文件选择  
+      handleAudioUpload(event) {
+        const file = event.target.files[0]
+        if (file && file.type.startsWith('audio/')) {
+          this.audioFile = file
+          this.addLog(`选择音频文件: ${file.name} (${Math.round(file.size / 1024 / 1024)}MB)`)
+        }
+      },
+  
+      // 处理WebSocket消息
+      handleWsMessage(event) {
+        try {
+          const data = JSON.parse(event.data)
+          // 不显示心跳消息
+          if (data.type !== 'heartbeat') {
+            this.addLog(`收到WebSocket消息: ${data.type}`)
+          }          
+  
+          switch (data.type) {
+            case SOCKET_STATUS.SESSION_CREATED:
+              this.currentStep = '会话已创建'
+              this.addLog('会话创建成功，开始更新会话配置')
+              this.sendSessionUpdate()
+              break
+              
+            case SOCKET_STATUS.SESSION_UPDATED:
+              this.currentStep = '开始处理音视频'
+              this.addLog('会话配置更新成功，开始处理文件')
+              this.startProcessingFiles()
+              break
+              
+            case SOCKET_STATUS.COMMITED:
+            this.currentRequestId = data.item_id
+                this.addLog(`服务器已接收数据，请求ID: ${data.item_id}`)
+                // 发送响应创建请求
+                this.wsConnection.send(JSON.stringify({
+                    type: SOCKET_STATUS.RESPONSE_CREATE,
+                    client_timestamp: Date.now()
+                }))
+                this.addLog('已请求创建AI响应')
+                break
+
+              
+            case SOCKET_STATUS.RESPONSE_CREATED:
+                this.currentResponseId = data.response.id
+                    this.currentStep = 'AI处理中'
+                    this.addLog(`AI开始处理，响应ID: ${data.response.id}`)
+                    break
+              
+            case SOCKET_STATUS.ASR_COMPLETED:
+              if (data.transcript) {
+                this.addLog(`语音识别完成: ${data.transcript}`)
+                const msgIndex = this.messageList.findIndex(m => m.id === this.currentRequestId)
+                if (msgIndex !== -1) {
+                  this.messageList[msgIndex].textContent = [data.transcript]
+                }
+              }
+              break
+              
+            case SOCKET_STATUS.RESPONSE_AUDIO_TXT:
+            case SOCKET_STATUS.RESPONSE_TEXT:  // 添加文本响应类型的处理
+            this.addLog(`收到AI响应: ${data.delta}`)
+                const responseMsg = {
+                    id: this.currentResponseId,
+                    type: MSG_TYPE.SERVER,
+                    textContent: [data.delta],
+                    timestamp: Date.now()
+                }
+                
+                const existingIndex = this.messageList.findIndex(msg => msg.id === this.currentResponseId)
+                if (existingIndex === -1) {
+                    this.messageList.push(responseMsg)
+                } else {
+                    const existing = this.messageList[existingIndex]
+                    existing.textContent = [...existing.textContent, data.delta]
+                    this.$set(this.messageList, existingIndex, { ...existing })
+                }
+                
+                // 保存到 localStorage
+                this.saveMessages()
+                break
+              
+            case SOCKET_STATUS.RESPONSE_AUDIO:
+              this.addLog('收到AI音频响应')
+              this.addOrUpdateMessage(this.currentResponseId, MSG_TYPE.SERVER, {
+                audioData: [{ data: data.delta }]
+              })
+              break
+              
+            case SOCKET_STATUS.RESPONSE_AUDIO_DONE:
+                this.addLog('AI处理完成', 'success')
+                this.currentStep = '处理完成'
+                
+                // 延迟关闭处理状态
+                setTimeout(() => {
+                    this.processing = false
+                    // 保存最终状态
+                    this.saveState()
+                }, 2000)
+                break
+  
+            case SOCKET_STATUS.ERROR:
+                const errorMsg = data.error?.message || '未知错误'
+                this.currentStep = '处理失败: ' + errorMsg
+                this.addLog(`处理失败: ${errorMsg}`, 'error')
+                // 延迟关闭处理状态
+                setTimeout(() => {
+                    this.processing = false
+                    this.saveState()
+                }, 2000)
+                break
+  
+            default:
+              this.addLog(`未处理的消息类型: ${data.type}`, 'warning')
+              break
+          }
+        } catch (err) {
+          this.addLog(`处理WebSocket消息错误: ${err.message}`, 'error')
+          console.error('完整错误:', err)
+        }
+      },
+  
+      // 添加或更新消息列表
+      addOrUpdateMessage(id, type, data) {
+        const index = this.messageList.findIndex(m => m.id === id)
+        if (index !== -1) {
+          const msg = this.messageList[index]
+          if (data.textContent) {
+            msg.textContent = [...(msg.textContent || []), ...data.textContent]
+          }
+          if (data.audioData) {
+            msg.audioData = [...(msg.audioData || []), ...data.audioData]
+            // 将base64音频数据转换为Blob URL
+            const audioBlob = this.base64ToBlob(data.audioData[0].data, 'audio/mp3')
+            msg.audioUrl = URL.createObjectURL(audioBlob)
+          }
+          this.messageList.splice(index, 1, { ...msg })
+        } else {
+          this.messageList.push({
+            id,
+            type,
+            ...data,
+          })
+        }
+      },
+  
+      // 发送会话更新
+      sendSessionUpdate() {
+        const sessionConfig = {
+          turn_detection: {
+            type: VAD_TYPE.CLIENT_VAD,
+          },
+          beta_fields: {
+            chat_mode: CALL_MODE_TYPE.VIDEO_PASSIVE,
+          },
+          output_audio_format: "mp3",
+          input_audio_format: "wav",
+        }
+        
+        this.wsConnection.send(JSON.stringify({
+          type: SOCKET_STATUS.SESSION_UPDATE,
+          session: sessionConfig
+        }))
+      },
+  
+      // base64转Blob
+      base64ToBlob(base64, type) {
+        const binStr = atob(base64)
+        const len = binStr.length
+        const arr = new Uint8Array(len)
+        for (let i = 0; i < len; i++) {
+          arr[i] = binStr.charCodeAt(i)
+        }
+        return new Blob([arr], { type })
+      },
+  
+      // 开始处理文件
+      async startProcessingFiles() {
+        try {
+          // 1. 处理视频帧
+          this.currentStep = '提取视频帧'
+          this.addLog('开始提取视频帧')
+          const videoFrames = await processVideoFrames(this.videoFile, (p) => {
+              this.progress = p
+          })
+          this.addLog(`视频帧提取完成，共 ${videoFrames.length} 帧`)
+  
+          // 修改 startProcessingFiles 方法中发送视频帧的部分
+          // 2. 发送视频帧
+          this.currentStep = '发送视频数据'
+          this.addLog('开始发送视频帧数据')
+          try {
+            for (let i = 0; i < videoFrames.length; i++) {
+            if (!this.wsConnection || this.wsConnection.readyState !== WebSocket.OPEN) {
+                throw new Error('WebSocket连接已断开')
+            }
+        
+            // 添加延时，避免发送过快
+            await new Promise(resolve => setTimeout(resolve, 50))
+        
+            this.wsConnection.send(JSON.stringify({
+                type: SOCKET_STATUS.VIDEO_APPEND,
+                client_timestamp: Date.now(),
+                video_frame: videoFrames[i]
+            }))
+        
+            // 确保进度不会超过100%
+            this.progress = Math.min(Math.floor((i + 1) / videoFrames.length * 100), 100)
+        
+            if (i % 10 === 0) {
+                this.addLog(`已发送 ${i + 1}/${videoFrames.length} 帧`)
+            }
+          }
+          this.addLog('视频帧发送完成')
+        } catch (err) {
+          this.addLog(`发送视频帧失败: ${err.message}`, 'error')
+          throw err
+        }
+  
+          // 3. 发送音频
+          this.currentStep = '发送音频数据'
+          this.addLog('开始发送音频数据')
+          this.progress = 0
+          const audioData = await readFileAsBase64(this.audioFile, (p) => {
+            this.progress = p
+          })
+            this.addLog(`音频数据准备完成，大小: ${Math.round(audioData.length * 3 / 4 / 1024)}KB`)
+
+          if (!this.wsConnection || this.wsConnection.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket连接已断开')
+          }
+        
+          await new Promise(resolve => setTimeout(resolve, 500)) // 添加短暂延时
+        
+          this.wsConnection.send(JSON.stringify({
+            type: SOCKET_STATUS.AUDIO_APPEND,
+            client_timestamp: Date.now(),
+            audio: audioData
+          }))
+          this.addLog('音频数据发送完成')
+  
+          // 4. 发送提交指令
+          await new Promise(resolve => setTimeout(resolve, 1000)) // 确保音频数据已被接收
+        
+          this.addLog('发送提交指令')
+          if (!this.wsConnection || this.wsConnection.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket连接已断开')
+          }
+          this.wsConnection.send(JSON.stringify({
+            type: SOCKET_STATUS.COMMIT,
+            client_timestamp: Date.now(),
+            response_type: "text" // 明确要求文本响应
+          }))
+          this.addLog('提交指令发送完成，等待AI响应...')
+          this.currentStep = '等待AI响应'
+  
+        } catch (err) {
+          this.addLog(`处理文件错误: ${err.message}`, 'error')
+          console.error('完整错误:', err)
+          this.processing = false
+          this.currentStep = '处理失败: ' + err.message
+        }
+      },
+  
+      // 处理文件并发送到AI接口
+      async processFiles() {
+        if (!this.videoFile || !this.audioFile) {
+          this.addLog('请选择视频和音频文件', 'error')
+          return
+        }
+  
+        try {
+          this.processing = true
+          this.progress = 0
+          this.currentStep = '建立连接'
+          this.messageList = []
+          this.debugLogs = []
+  
+          // 创建WebSocket连接
+          const domain = import.meta.env.VITE_APP_DOMAIN
+          const proxyPath = import.meta.env.VITE_APP_PROXY_PATH
+          const apiKey = "d20c08612ef746beb7038a326131d475.cv71sxB0l7w8yOAO"
+          const wsUrl = `${domain}${proxyPath}/v4/realtime?Authorization=${apiKey}`
+          
+          this.addLog(`开始建立WebSocket连接: ${domain}${proxyPath}/v4/realtime`)
+          // 修改 processFiles 方法中的 WebSocket 初始化部分
+          // 修改 processFiles 方法中的 WebSocket 初始化部分
+          this.wsConnection = new WebSocket(wsUrl)
+
+          this.wsConnection.onopen = () => {
+            this.addLog('WebSocket连接已建立', 'success')
+          }
+
+          this.wsConnection.onmessage = (event) => {
+            // 添加心跳消息的处理，避免显示在日志中
+            if (event.data === 'heartbeat') {
+                return
+            }
+            this.handleWsMessage(event)
+          }
+
+          this.wsConnection.onerror = (error) => {
+            this.addLog(`WebSocket错误: ${error}`, 'error')
+            console.error('WebSocket错误:', error)
+            // 不要立即设置 processing 为 false，等待 onclose 事件处理
+          }
+
+          this.wsConnection.onclose = (event) => {
+            // 添加更详细的关闭原因
+            let closeReason = '未知原因'
+            if (event.code === 1000) {
+                closeReason = '正常关闭'
+            } else if (event.code === 1006) {
+                closeReason = '异常关闭'
+            }
+    
+            this.addLog(`WebSocket连接已关闭 (code: ${event.code}, reason: ${closeReason})`, 
+                this.processing ? 'error' : 'info')
+    
+            if (this.processing) {
+                this.processing = false
+                this.currentStep = `连接已关闭: ${closeReason}`
+            }
+          }  
+        } catch (err) {
+            this.addLog(`初始化错误: ${err.message}`, 'error')
+            console.error('完整错误:', err)
+            this.processing = false
+            this.currentStep = '初始化失败: ' + err.message                     
+        }
+      },
+          // 保存消息列表和日志
+      saveMessages() {
+        localStorage.setItem('fileUpload_messages', JSON.stringify(this.messageList))
+        localStorage.setItem('fileUpload_logs', JSON.stringify(this.debugLogs))
+      },
+
+      // 保存整个状态
+      saveState() {
+        const state = {
+            messages: this.messageList,
+            logs: this.debugLogs,
+            currentStep: this.currentStep,
+            processing: this.processing
+        }
+        localStorage.setItem('fileUpload_state', JSON.stringify(state))
+      },
+
+      // 恢复状态
+      restoreState() {
+        try {
+            const state = localStorage.getItem('fileUpload_state')
+            if (state) {
+                const parsed = JSON.parse(state)
+                this.messageList = parsed.messages || []
+                this.debugLogs = parsed.logs || []
+                this.currentStep = parsed.currentStep || ''
+                this.processing = parsed.processing || false
+            }
+        } catch (err) {
+            console.error('恢复状态失败:', err)
+        }
+      },
+
+      // 修改添加日志方法
+      addLog(message, type = 'info') {
+        const timestamp = new Date().toLocaleTimeString()
+        const logEntry = { timestamp, message, type }
+        this.debugLogs.push(logEntry)
+        console.log(`${type.toUpperCase()}: ${message}`)
+        
+        // 保存日志
+        this.saveMessages()
+      }
+    
+    },
+    // 添加组件销毁前的处理
+    beforeDestroy() {
+      this.saveState()
+        if (this.wsConnection && this.wsConnection.readyState === WebSocket.OPEN) {
+            this.wsConnection.close()
+        }
+    },
+  
+    // 修改生命周期钩子
+    created() {
+      this.restoreState()
+    },
+  }
+  </script>
+  
+  <style lang="less" scoped>
+.file-upload {
+  background-color: #fff;
+  height: 100%;
+  
+  &__header {
+    height: 59px;
+    border-bottom: 1px solid rgba(224, 224, 224, 0.6);
+    padding: 0 24px;
+    
+    h3 {
+      color: #131212;
+      font-size: 20px;
+      font-weight: 500;
+      line-height: 59px;
+      margin: 0;
+    }
+  }
+  
+  &__content {
+    padding: 24px;
+    
+    .upload-section {
+      display: flex;
+      gap: 24px;
+      margin-bottom: 24px;
+    }
+    
+    .upload-box {
+      flex: 1;
+      padding: 16px;
+      border: 1px dashed #dcdfe6;
+      border-radius: 8px;
+      
+      h4 {
+        margin: 0 0 12px;
+      }
+      
+      .file-info {
+        margin-top: 8px;
+        color: #409eff;
+      }
+    }
+  }
+
+  .process-status {
+    margin-top: 20px;
+    
+    .debug-logs {
+      margin: 16px 0;
+      padding: 12px;
+      background-color: #f8f9fa;
+      border: 1px solid #e9ecef;
+      border-radius: 4px;
+      max-height: 200px;
+      overflow-y: auto;
+      
+      .log-entry {
+        display: flex;
+        margin: 4px 0;
+        font-family: monospace;
+        font-size: 12px;
+        
+        .log-time {
+          min-width: 100px;
+          color: #666;
+        }
+        
+        .log-message {
+          flex: 1;
+        }
+        
+        &.error { color: #dc3545; }
+        &.warning { color: #ffc107; }
+        &.success { color: #28a745; }
+        &.info { color: #17a2b8; }
+      }
+    }
+    
+    .message-list {
+      margin-top: 16px;
+      
+      .message-item {
+        margin-bottom: 16px;
+        padding: 12px;
+        border-radius: 4px;
+        
+        &.client {
+          background-color: #f5f7fa;
+        }
+        
+        &.server {
+          background-color: #ecf5ff;
+        }
+
+        .message-time {
+          font-size: 12px;
+          color: #999;
+          margin-bottom: 4px;
+        }
+
+        .message-content {
+          margin: 8px 0;
+        }
+
+        .audio-player {
+          margin-top: 8px;
+          
+          audio {
+            width: 100%;
+          }
+        }
+      }
+    }
+  }
+}
+</style>
\ No newline at end of file
diff --git a/src/views/FileUpload/index.less b/src/views/FileUpload/index.less
new file mode 100644
index 0000000..2137a59
--- /dev/null
+++ b/src/views/FileUpload/index.less
@@ -0,0 +1,83 @@
+.file-upload {
+    // 定义变量，便于维护和复用
+    @header-height: 59px;
+    @standard-padding: 24px;
+    @border-color: rgba(224, 224, 224, 0.6);
+    @primary-color: #409eff;
+    @border-radius: 8px;
+  
+    background-color: #fff;
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+    
+    &__header {
+      height: @header-height;
+      border-bottom: 1px solid @border-color;
+      padding: 0 @standard-padding;
+      
+      h3 {
+        color: #131212;
+        font-size: 20px;
+        font-weight: 500;
+        line-height: @header-height;
+        margin: 0;
+      }
+    }
+    
+    &__content {
+      padding: @standard-padding;
+      flex: 1;
+      overflow-y: auto;
+      
+      .upload-section {
+        display: flex;
+        gap: @standard-padding;
+        margin-bottom: @standard-padding;
+  
+        // 使用CSS Grid作为备选布局方案
+        @media (max-width: 768px) {
+          display: grid;
+          grid-template-columns: 1fr;
+          gap: 16px;
+        }
+      }
+      
+      .upload-box {
+        flex: 1;
+        padding: 16px;
+        border: 1px dashed #dcdfe6;
+        border-radius: @border-radius;
+        transition: border-color 0.3s ease;
+        
+        &:hover {
+          border-color: @primary-color;
+        }
+        
+        h4 {
+          margin: 0 0 12px;
+          font-weight: 500;
+        }
+        
+        .file-info {
+          margin-top: 8px;
+          color: @primary-color;
+          word-break: break-all;
+          font-size: 14px;
+        }
+      }
+      
+      .process-progress {
+        margin-top: 16px;
+        padding: 12px;
+        background-color: #f8f9fa;
+        border-radius: 4px;
+        
+        // 添加进度条动画
+        &.processing {
+          animation: progress-pulse 2s infinite;
+        }
+      }
+    }
+  }
+  
\ No newline at end of file
diff --git a/src/views/FileUpload/videoProcessor.js b/src/views/FileUpload/videoProcessor.js
new file mode 100644
index 0000000..3c6c39c
--- /dev/null
+++ b/src/views/FileUpload/videoProcessor.js
@@ -0,0 +1,146 @@
+//视频发送出错，需要继续分析
+// src/views/FileUpload/videoProcessor.js
+// 判断运行环境
+const isNode = typeof window === 'undefined' || typeof document === 'undefined';
+
+import ffmpeg from 'fluent-ffmpeg';
+import { promises as fs } from 'fs';
+import { file as tmpFile, dir as tmpDir } from 'tmp-promise';
+import { join } from 'path';
+import { createCanvas, loadImage } from 'canvas';
+
+// 添加递归删除目录的辅助函数
+async function removeDir(dir) {
+  try {
+    const items = await fs.readdir(dir);
+    for (const item of items) {
+      const path = join(dir, item);
+      const stat = await fs.stat(path);
+      if (stat.isDirectory()) {
+        await removeDir(path);
+      } else {
+        await fs.unlink(path);
+      }
+    }
+    await fs.rmdir(dir);
+  } catch (error) {
+    console.error('删除目录失败:', error);
+    throw error;
+  }
+}
+
+export const processVideoFrames = async (file, onProgress) => {
+  if (isNode) {
+    let videoPath = null;
+    let framesDir = null;
+
+    try {
+      // 创建临时文件和目录
+      const tmpVideoFile = await tmpFile({ postfix: '.mp4' });
+      const tmpFramesDir = await tmpDir();
+      videoPath = tmpVideoFile.path;
+      framesDir = tmpFramesDir.path;
+
+      // 写入视频文件
+      const videoBuffer = Buffer.from(await file.arrayBuffer());
+      await fs.writeFile(videoPath, videoBuffer);
+
+      // 提取视频帧
+      return new Promise((resolve, reject) => {
+        ffmpeg(videoPath)
+          .screenshots({
+            count: 1,
+            folder: framesDir,
+            filename: 'frame-%i.jpg',
+            size: '640x?'
+          })
+          .on('end', async () => {
+            try {
+              // 读取生成的帧
+              const frames = await fs.readdir(framesDir);
+              // 在处理视频帧时，直接返回 base64 字符串
+              const frameResults = [];
+              for (let i = 0; i < frames.length; i++) {
+                const framePath = join(framesDir, frames[i]);
+                const frameBuffer = await fs.readFile(framePath);
+                frameResults.push(frameBuffer.toString('base64'));  // 直接返回 base64 字符串
+              }
+
+              // 注释掉清理临时文件的代码
+              /*
+              try {
+                  await fs.unlink(videoPath);
+                  console.log('临时视频文件已删除');
+                  await removeDir(framesDir);
+                  console.log('临时帧目录已删除');
+              } catch (cleanupError) {
+                  console.error('清理临时文件失败:', cleanupError);
+              }
+              */
+
+              resolve(frameResults);
+            } catch (error) {
+              console.error('处理视频帧时出错:', error);
+              reject(error);
+            }
+          })
+          .on('error', async (err) => {
+            console.error('FFmpeg 错误:', err);
+            // 注释掉错误处理中的清理代码
+            /*
+            try {
+                if (videoPath) await fs.unlink(videoPath).catch(() => {});
+                if (framesDir) await removeDir(framesDir).catch(() => {});
+            } catch (cleanupError) {
+                console.error('清理临时文件失败:', cleanupError);
+            }
+            */
+            reject(err);
+          });
+      });
+    } catch (error) {
+      // 注释掉最外层错误处理中的清理代码
+      /*
+      try {
+          if (videoPath) await fs.unlink(videoPath).catch(() => {});
+          if (framesDir) await removeDir(framesDir).catch(() => {});
+      } catch (cleanupError) {
+          console.error('清理临时文件失败:', cleanupError);
+      }
+      */
+      console.error('视频处理初始化错误:', error);
+      throw error;
+    }
+  } else {
+    // 浏览器环境代码保持不变...
+  }
+};
+
+
+// 将文件转换为base64
+// 音频处理函数保持不变
+export const readFileAsBase64 = async (file, onProgress) => {
+  try {
+    const arrayBuffer = await file.arrayBuffer();
+    if (isNode) {
+      // Node.js 环境
+      return Buffer.from(arrayBuffer).toString('base64');
+    } else {
+      // 浏览器环境
+      return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+          const base64 = reader.result.split(',')[1];
+          if (onProgress) onProgress(100);
+          resolve(base64);
+        };
+        reader.readAsDataURL(new Blob([arrayBuffer]));
+      });
+    }
+  } catch (error) {
+    console.error('处理音频文件时出错:', error);
+    throw error;
+  }
+};
+
+