pcm-agents 1.0.2 → 1.0.4

package/dist/collection/components/components-oem-virtual-chat-modal/components-oem-virtual-chat-modal.js

@@ -0,0 +1,2334 @@
+import { h } from "@stencil/core";
+import { sendSSERequest, sendHttpRequest, uploadFileToBackend, fetchAgentInfo, getSupportedMimeType, convertAudioToText } from "../../utils/utils";
+import { showMessage } from "../../utils/message-utils";
+import { ErrorEventBus } from "../../utils/error-event";
+import { authStore } from "../../../store/auth.store"; // 导入 authStore
+import { configStore } from "../../../store/config.store";
+import { SentryReporter } from "../../utils/sentry-reporter";
+export class ComponentsOemVirtualChatModal {
+    /**
+     * SDK鉴权密钥
+     */
+    token;
+    /**
+     * 是否显示聊天模态框
+     */
+    isOpen = false;
+    /**
+     * 聊天消息历史
+     */
+    messages = [];
+    /**
+     * 聊天框的页面层级
+     */
+    zIndex;
+    /**
+     * 会话ID，传入继续对话，否则创建新会话
+     */
+    conversationId;
+    /**
+     * 是否正在加载回复
+     */
+    isLoading = false;
+    /**
+     * 当前正在流式输出的消息
+     */
+    currentStreamingMessage = null;
+    isLoadingHistory = false;
+    // 使用 @Element 装饰器获取组件的 host 元素
+    hostElement;
+    /**
+     * 一轮对话结束时的回调
+     */
+    streamComplete;
+    /**
+     * 新会话开始的回调，只会在一轮对话开始时触发一次
+     */
+    conversationStart;
+    /**
+     * 默认发送文本
+     */
+    defaultQuery = '你好！聘才猫';
+    /**
+     * 视频录制最大时长（秒）
+     */
+    maxRecordingTime = 120;
+    /**
+     * 录制倒计时提醒时间（秒）
+     * 当剩余时间小于此值时，显示倒计时警告
+     */
+    countdownWarningTime = 30;
+    // 添加视频录制相关状态
+    isRecording = false;
+    recordingStream = null;
+    recordedBlob = null;
+    mediaRecorder = null;
+    recordingTimeLeft = 0;
+    showRecordingUI = false;
+    recordingTimer = null;
+    recordingStartTime = 0;
+    waitingToRecord = false;
+    waitingTimer = null;
+    _visibilityChangeHandler = null;
+    waitingTimeLeft = 10; // 等待时间（秒）
+    // 添加一个新的私有属性来存储视频元素的引用
+    videoRef = null;
+    /**
+     * 当前轮数
+     */
+    currentQuestionNumber = 0;
+    /**
+     * 当聊天完成时触发
+     */
+    interviewComplete;
+    showCountdownWarning = false;
+    /**
+     * 是否以全屏模式打开，移动端建议设置为true
+     */
+    fullscreen = false;
+    // 添加新的状态来跟踪视频上传
+    isUploadingVideo = false;
+    /**
+     * 数字人视频相关状态
+     */
+    digitalHumanVideoUrl = '';
+    digitalHumanDefaultVideoUrl = '';
+    virtualmanKey = '';
+    isPlayingDigitalHumanVideo = false;
+    digitalHumanVideoReady = false;
+    digitalHumanOpeningContents = [];
+    isPlayingWelcomeVideo = false;
+    isGeneratingDigitalHumanVideo = false;
+    /**
+     * 待播放的生成视频URL（当开场白视频播放时，暂存生成的视频URL）
+     */
+    pendingGeneratedVideoUrl = '';
+    // 视频预加载缓存管理
+    preloadedVideos = new Set();
+    preloadingVideos = new Map();
+    /**
+     * 是否正在等待数字人视频播放完成
+     */
+    waitingForDigitalHuman = false;
+    /**
+     * 虚拟数字人ID，指定则开启虚拟数字人功能
+     */
+    digitalId;
+    /**
+     * 数字人开场白索引，用于选择开场白和开场视频（可选：0, 1, 2）
+     * 0、您好，我是聘才猫 AI 面试助手。很高兴为你主持这场面试！在开始前，请确保：身处安静、光线充足的环境。网络顺畅，摄像头和麦克风工作正常。现在我正在查看本次面试的相关信息，为您生成专属面试题，马上就好，请稍等片刻。</br>
+     * 1、您好，我是您的 AI 面试助手。欢迎参加本次AI面试！为了获得最佳效果，请确认：您在安静、明亮的环境中。您的网络稳定，摄像头和麦克风已开启。我们正在后台为您准备本次专属面试内容，很快开始，请稍候。<br>
+     * 2、您好，我是您的 AI 面试助手。面试马上开始。趁此片刻，请快速确认：周围安静吗？光线足够吗？网络没问题？摄像头和麦克风准备好了吗？我们正在为您加载个性化的面试环节，稍等就好！
+     */
+    openingIndex = 0;
+    /**
+     * 等待录制时间（秒）默认10
+     */
+    waitingTime = 10;
+    /**
+     * 数字人视频播放速率（0.5-2.0之间），默认1.0
+     */
+    playbackRate = 1.0;
+    /**
+     * 是否显示结束面试按钮
+     */
+    showEndInterviewButton = false;
+    /**
+     * 录制错误事件
+     */
+    recordingError;
+    /**
+     * 录制状态变化事件
+     */
+    recordingStatusChange;
+    /**
+     * SDK密钥验证失败事件
+     */
+    tokenInvalid;
+    /**
+     * 当点击模态框关闭时触发
+     */
+    modalClosed;
+    /**
+     * 自定义智能体inputs输入参数
+     */
+    customInputs = {};
+    /**
+     * 机器人ID
+     */
+    botId;
+    /**
+     * 智能体头像URL（从后端获取）
+     */
+    agentLogo = '';
+    // 添加新的状态属性来跟踪任务是否已完成
+    isTaskCompleted = false;
+    tokenInvalidListener;
+    deviceError = null;
+    /**
+     * 面试流程状态管理说明：
+     *
+     * 核心状态：
+     * - isTaskCompleted: 任务是否已完成（面试正常结束）
+     * - isEndingInterview: 是否正在执行结束面试流程（用户主动结束）
+     * - isRecording: 是否正在录制视频
+     * - waitingToRecord: 是否正在等待开始录制
+     * - waitingForDigitalHuman: 是否正在等待数字人视频播放完成
+     * - isLoading: 是否正在等待AI回复
+     * - isUploadingVideo: 是否正在上传视频
+     * - isGeneratingDigitalHumanVideo: 是否正在生成数字人视频
+     *
+     * 流程控制原则：
+     * 1. 一旦 isTaskCompleted 或 isEndingInterview 为 true，所有录制和等待流程都应停止
+     * 2. isEndingInterview 设置为 true 后，只允许发送结束面试消息
+     * 3. 结束面试按钮在 isTaskCompleted 或 isEndingInterview 为 true 时置灰禁用
+     * 4. 所有可能触发新录制的地方都需要检查这两个状态
+     */
+    // 添加二次确认相关状态
+    showConfirmModal = false;
+    skipConfirmThisInterview = false;
+    // 添加关闭确认相关状态
+    showCloseConfirmModal = false;
+    // 添加结束面试确认相关状态
+    showEndInterviewConfirmModal = false;
+    /**
+     * 标记是否正在执行结束面试流程
+     */
+    isEndingInterview = false;
+    // 添加内部状态标志，用于控制异步操作的执行
+    isComponentActive = true;
+    handleTokenChange(newToken) {
+        // 当传入的 token 变化时，更新 authStore 中的 token
+        if (newToken && newToken !== authStore.getToken()) {
+            authStore.setToken(newToken);
+        }
+    }
+    /**
+     * 公共方法：设置组件活动状态
+     * 可被外部调用来控制组件是否继续执行异步操作
+     */
+    async setComponentActive(active) {
+        console.log('设置组件活动状态:', active);
+        this.isComponentActive = active;
+    }
+    componentWillLoad() {
+        // 将 zIndex 存入配置缓存
+        if (this.zIndex) {
+            configStore.setItem('modal-zIndex', this.zIndex);
+        }
+        else {
+            // 如果没有提供 zIndex，尝试从缓存中读取
+            const cachedZIndex = configStore.getItem('modal-zIndex');
+            if (cachedZIndex) {
+                this.zIndex = cachedZIndex;
+            }
+            else {
+                this.zIndex = 1000;
+                configStore.setItem('modal-zIndex', 1000);
+            }
+        }
+        if (this.token) {
+            authStore.setToken(this.token);
+        }
+        // 添加全局token无效事件监听器
+        this.tokenInvalidListener = () => {
+            this.tokenInvalid.emit();
+        };
+        document.addEventListener('pcm-token-invalid', this.tokenInvalidListener);
+        // 监听页面可见性变化，处理关屏/切后台回来后流程卡住的问题
+        this._visibilityChangeHandler = () => {
+            if (document.visibilityState === 'visible') {
+                this.handlePageResume();
+            }
+        };
+        document.addEventListener('visibilitychange', this._visibilityChangeHandler);
+        // 确保 customInputs 是一个对象
+        if (!this.customInputs) {
+            this.customInputs = {};
+        }
+        // 如果没有设置助手头像，尝试获取智能体头像
+        if (this.botId) {
+            this.fetchAgentLogo();
+        }
+        // 添加数字人初始化日志
+        console.log('componentWillLoad - 数字人相关状态:', {
+            digitalId: this.digitalId,
+            isOpen: this.isOpen,
+            conversationId: this.conversationId,
+            virtualmanKey: this.virtualmanKey,
+        });
+        // 如果组件加载时已经是打开状态，则直接开始对话
+        if (this.isOpen) {
+            if (this.conversationId) {
+                // 在下一个事件循环中加载历史消息，避免在componentWillLoad中进行异步操作
+                setTimeout(() => this.loadHistoryMessages(), 0);
+            }
+            else {
+                // 初始化数字人功能
+                if (this.digitalId) {
+                    console.log('准备初始化数字人功能...');
+                    this.initializeDigitalHuman();
+                }
+                // 在下一个事件循环中发送初始消息，避免在componentWillLoad中进行异步操作
+                setTimeout(() => {
+                    this.sendMessageToAPI(this.defaultQuery);
+                }, 0);
+            }
+        }
+    }
+    // 添加获取智能体信息的方法
+    async fetchAgentLogo() {
+        if (!this.botId)
+            return;
+        try {
+            const agentInfo = await fetchAgentInfo(this.botId);
+            if (agentInfo && agentInfo.logo) {
+                this.agentLogo = agentInfo.logo;
+            }
+        }
+        catch (error) {
+            SentryReporter.captureError(error, {
+                action: 'fetchAgentLogo',
+                component: 'components-oem-virtual-chat-modal',
+                title: '获取智能体信息失败',
+            });
+            ErrorEventBus.emitError({
+                error: error,
+                message: '获取智能体信息失败',
+            });
+        }
+    }
+    async sendMessageToAPI(message, videoUrl) {
+        // 如果任务已完成或正在结束面试，不允许发送消息
+        if (this.isTaskCompleted && !this.isEndingInterview) {
+            console.log('任务已完成，不允许发送消息');
+            return;
+        }
+        // 发送新消息时重置状态
+        this.waitingForDigitalHuman = false;
+        this.digitalHumanVideoReady = false;
+        this.isLoading = true;
+        let answer = '';
+        let llmText = '';
+        const now = new Date();
+        const time = `${now.getHours()}:${now.getMinutes().toString().padStart(2, '0')}`;
+        // 修改消息处理逻辑，移除文件上传相关代码
+        const queryText = message.trim() || '请开始';
+        // 如果有视频URL，添加到customInputs中
+        if (videoUrl) {
+            this.customInputs = {
+                ...this.customInputs,
+                video_url: videoUrl,
+            };
+        }
+        // 如果没有设置url_callback，则使用默认值
+        if (!this.customInputs.url_callback) {
+            this.customInputs = {
+                ...this.customInputs,
+                url_callback: 'https://tagents.ylzhaopin.com/agents/api/test/callback',
+            };
+        }
+        // 创建新的消息对象
+        const newMessage = {
+            id: `temp-${Date.now()}`, // 临时ID，将被服务器返回的ID替换
+            conversation_id: this.conversationId, // 会话ID
+            inputs: this.customInputs || {}, // 输入参数
+            query: queryText, // 用户输入的消息内容
+            answer: '', // 初始为空
+            message_files: [], // 消息附件
+            feedback: {}, // 反馈
+            retriever_resources: [], // 检索资源
+            created_at: Math.floor(Date.now() / 1000).toString(), // 创建时间
+            agent_thoughts: [], // 代理思考过程
+            status: 'normal', // 消息状态
+            error: null, // 错误信息
+            // 添加组件内部使用的字段
+            time: time, // 消息时间（显示用）
+            isStreaming: true, // 是否正在流式输出
+        };
+        // 设置当前流式消息
+        this.currentStreamingMessage = newMessage;
+        // 准备请求数据
+        const requestData = {
+            response_mode: 'streaming',
+            conversation_id: this.conversationId,
+            query: queryText,
+            bot_id: this.botId, // 添加 botId 到请求数据中
+        };
+        // 合并基本输入参数和自定义输入参数
+        requestData.inputs = {
+            // 合并自定义输入参数
+            ...this.customInputs,
+        };
+        await sendSSERequest({
+            url: '/sdk/v1/chat/chat-messages',
+            method: 'POST',
+            data: requestData,
+            onMessage: data => {
+                console.log(new Date().toLocaleString());
+                console.log('收到Stream数据:', data);
+                if (data.conversation_id && !this.conversationId) {
+                    this.conversationId = data.conversation_id;
+                    this.conversationStart.emit({
+                        conversation_id: data.conversation_id,
+                        event: data.event,
+                        message_id: data.message_id,
+                        id: data.id,
+                    });
+                }
+                // 检查是否有 node_finished 事件和 LLMText
+                if (data.event === 'node_finished' && data.data.inputs && data.data.inputs.LLMText) {
+                    llmText = data.data.inputs.LLMText;
+                }
+                // 添加对任务结束的判断
+                if (data.event === 'node_finished' && data.data.title && data.data.title.includes('聘才猫任务结束')) {
+                    console.log('检测到任务结束事件:', data);
+                    // 设置标志，表示任务已结束
+                    this.isTaskCompleted = true;
+                    // 获取当前AI回复内容，优先使用LLMText，否则使用answer
+                    const aiResponse = llmText || answer || this.currentStreamingMessage?.answer || '';
+                    // 触发面试完成事件
+                    this.interviewComplete.emit({
+                        conversation_id: this.conversationId,
+                        current_question_number: this.currentQuestionNumber,
+                        ai_response: aiResponse, // 添加AI回复内容
+                    });
+                }
+                if (data.event === 'node_finished' && data.data.title && data.data.title.includes('聘才猫数字人题目')) {
+                    const digital_human_list = JSON.parse(data.data.process_data.digital_human_list);
+                    console.log('数字人题目:', digital_human_list);
+                    this.precreateDigitalHumanVideos(digital_human_list);
+                }
+                if (data.event === 'error') {
+                    const errorMessage = data.data?.message || data.message || '请求失败';
+                    this.messages = [
+                        ...this.messages,
+                        {
+                            ...newMessage,
+                            answer: errorMessage,
+                            error: data.data,
+                            isStreaming: false,
+                        },
+                    ];
+                    this.currentStreamingMessage = null;
+                    this.isLoading = false;
+                    ErrorEventBus.emitError({
+                        error: data.data,
+                        message: errorMessage,
+                    });
+                    return;
+                }
+                if (data.event === 'message') {
+                    if (data.event === 'agent_message' || data.event === 'message') {
+                        if (data.answer) {
+                            answer += data.answer;
+                            // 更新消息时保持完整的消息结构
+                            const updatedMessage = {
+                                ...this.currentStreamingMessage,
+                                answer,
+                                id: data.message_id || this.currentStreamingMessage.id,
+                                isStreaming: true,
+                                // 如果服务器返回了其他字段，也更新它们
+                                retriever_resources: data.retriever_resources || this.currentStreamingMessage.retriever_resources,
+                                agent_thoughts: data.agent_thoughts || this.currentStreamingMessage.agent_thoughts,
+                            };
+                            this.currentStreamingMessage = updatedMessage;
+                        }
+                    }
+                }
+                if (data.event === 'message_end') {
+                    this.streamComplete.emit({
+                        conversation_id: data.conversation_id || '',
+                        event: data.event,
+                        message_id: data.message_id,
+                        id: data.id,
+                    });
+                }
+            },
+            onError: error => {
+                console.error('发生错误:', error);
+                ErrorEventBus.emitError({
+                    error: error,
+                    message: '消息发送失败，请稍后再试',
+                });
+                SentryReporter.captureError(error, {
+                    action: 'sendMessageToAPI',
+                    component: 'components-oem-virtual-chat-modal',
+                    title: '消息发送失败',
+                });
+                this.messages = [
+                    ...this.messages,
+                    {
+                        ...newMessage,
+                        answer: '消息发送失败，请检查网络。',
+                        error: error,
+                        isStreaming: false,
+                    },
+                ];
+                this.currentStreamingMessage = null;
+                this.isLoading = false;
+            },
+            onComplete: async () => {
+                this.isLoading = false;
+                // 根据currentQuestionNumber判断是否清空customInputs
+                if (this.currentQuestionNumber === 0) {
+                    //  发送第一条消息后，清空指定的 customInputs 字段
+                    setTimeout(() => {
+                        if (this.customInputs) {
+                            // 只清除指定的字段，其他字段保留
+                            delete this.customInputs.job_info;
+                            delete this.customInputs.file_url;
+                            delete this.customInputs.file_name;
+                        }
+                    }, 1000); // 给一些时间让第一条消息处理完成
+                }
+                // 获取最新的AI回复内容
+                const latestAIMessage = this.currentStreamingMessage;
+                latestAIMessage.isStreaming = false;
+                if (this.digitalId && latestAIMessage && latestAIMessage.answer) {
+                    // 如果开启了数字人功能，生成数字人视频
+                    console.log('生成数字人视频:', latestAIMessage.answer);
+                    this.generateDigitalHumanVideo(latestAIMessage.answer);
+                }
+                this.currentStreamingMessage = null;
+                // 更新消息列表
+                this.messages = [...this.messages, latestAIMessage];
+                // 增加计数
+                this.currentQuestionNumber++;
+                // 如果任务已完成或正在结束面试，不执行后续流程
+                if (this.isTaskCompleted || this.isEndingInterview) {
+                    console.log('任务已完成或正在结束面试，停止后续流程');
+                    return;
+                }
+                // 如果开启了数字人，等待数字人视频播放完成
+                if (this.digitalId) {
+                    this.waitingForDigitalHuman = true;
+                    console.log('等待数字人视频播放完成...');
+                }
+            },
+        });
+    }
+    // 修改加载历史消息的方法
+    async loadHistoryMessages() {
+        if (!this.conversationId)
+            return;
+        this.isLoadingHistory = true;
+        console.log('加载历史消息...');
+        let conversationStatus = false;
+        this.digitalHumanVideoReady = true;
+        try {
+            // 首先获取会话状态
+            const conversationStatusResponse = await sendHttpRequest({
+                url: `/sdk/v1/chat/conversation`,
+                method: 'GET',
+                data: {
+                    conversation_id: this.conversationId,
+                },
+            });
+            // 处理会话状态
+            if (conversationStatusResponse.success && conversationStatusResponse.data && conversationStatusResponse.data.run_status == '结束') {
+                conversationStatus = true;
+            }
+            // 获取历史消息
+            const result = await sendHttpRequest({
+                url: '/sdk/v1/chat/messages',
+                method: 'GET',
+                data: {
+                    conversation_id: this.conversationId,
+                    bot_id: this.botId,
+                    limit: 20,
+                },
+            });
+            if (result.success && result.data) {
+                const historyData = result.data.data || [];
+                const formattedMessages = historyData.map(msg => {
+                    const time = new Date(parseInt(msg.created_at) * 1000);
+                    const hours = time.getHours().toString().padStart(2, '0');
+                    const minutes = time.getMinutes().toString().padStart(2, '0');
+                    const timeStr = `${hours}:${minutes}`;
+                    // 创建完整的消息对象，保持统一结构
+                    return {
+                        id: msg.id,
+                        conversation_id: msg.conversation_id,
+                        inputs: msg.inputs || {},
+                        query: msg.query || '',
+                        answer: msg.answer || '',
+                        message_files: msg.message_files || [],
+                        feedback: msg.feedback || {},
+                        retriever_resources: msg.retriever_resources || [],
+                        created_at: msg.created_at,
+                        agent_thoughts: msg.agent_thoughts || [],
+                        status: msg.status || 'normal',
+                        error: msg.error,
+                        // 组件内部使用的字段
+                        time: timeStr,
+                        isStreaming: false,
+                    };
+                });
+                this.messages = formattedMessages;
+                // 根据历史消息数量设置currentQuestionNumber
+                this.currentQuestionNumber = formattedMessages.length || 0;
+            }
+        }
+        catch (error) {
+            console.error('加载历史消息或会话状态失败:', error);
+            SentryReporter.captureError(error, {
+                action: 'loadHistoryMessages',
+                component: 'components-oem-virtual-chat-modal',
+                title: '加载历史消息失败',
+            });
+            ErrorEventBus.emitError({
+                error: error,
+                message: '加载历史消息失败，请刷新重试',
+            });
+        }
+        finally {
+            this.isLoadingHistory = false;
+            if (this.conversationId && this.messages.length > 0 && !conversationStatus && !this.isEndingInterview) {
+                // 不播放欢迎视频
+                this.isPlayingDigitalHumanVideo = false;
+                this.isPlayingWelcomeVideo = false;
+                this.digitalHumanVideoReady = true;
+                // 先初始化数字人，等待获取到默认视频URL后再设置
+                this.initializeDigitalHuman().then(() => {
+                    // 确保在初始化完成后设置视频URL
+                    if (this.digitalHumanDefaultVideoUrl) {
+                        this.digitalHumanVideoUrl = this.digitalHumanDefaultVideoUrl;
+                    }
+                });
+                setTimeout(() => {
+                    // 开始等待录制
+                    this.startWaitingToRecord();
+                }, 200);
+            }
+            else if (conversationStatus) {
+                // 如果会话已结束，设置任务完成状态
+                this.isTaskCompleted = true;
+                // 确保数字人视频状态正确设置
+                if (this.digitalId) {
+                    this.isPlayingDigitalHumanVideo = false;
+                    this.isPlayingWelcomeVideo = false;
+                    this.digitalHumanVideoReady = true;
+                    // 先初始化数字人，等待获取到默认视频URL后再设置
+                    this.initializeDigitalHuman().then(() => {
+                        // 确保在初始化完成后设置视频URL
+                        if (this.digitalHumanDefaultVideoUrl) {
+                            this.digitalHumanVideoUrl = this.digitalHumanDefaultVideoUrl;
+                        }
+                    });
+                }
+            }
+        }
+    }
+    // 开始等待录制
+    startWaitingToRecord() {
+        // 如果任务已完成或正在结束面试，不开始录制流程
+        if (this.isTaskCompleted || this.isEndingInterview) {
+            console.log('任务已完成或正在结束面试，不开始录制流程');
+            return;
+        }
+        // 清除可能存在的计时器
+        if (this.waitingTimer) {
+            clearInterval(this.waitingTimer);
+        }
+        if (this.recordingTimer) {
+            clearInterval(this.recordingTimer);
+        }
+        this.waitingToRecord = true;
+        this.waitingTimeLeft = this.waitingTime;
+        this.waitingTimer = setInterval(() => {
+            this.waitingTimeLeft--;
+            if (this.waitingTimeLeft <= 0) {
+                clearInterval(this.waitingTimer);
+                this.waitingTimer = null;
+                this.waitingToRecord = false;
+                this.startRecording();
+            }
+        }, 1000);
+    }
+    // 开始录制视频
+    async startRecording() {
+        // 如果任务已完成或正在结束面试，不开始录制
+        if (this.isTaskCompleted || this.isEndingInterview) {
+            console.log('任务已完成或正在结束面试，不开始录制');
+            return;
+        }
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({
+                audio: true,
+                video: {
+                    width: { ideal: 1280 },
+                    height: { ideal: 720 },
+                    frameRate: { ideal: 30 },
+                },
+            });
+            // 如果成功获取到媒体流，清除之前的设备错误
+            this.deviceError = null;
+            this.recordingStream = stream;
+            this.showRecordingUI = true;
+            this.showCountdownWarning = false;
+            // 重置视频引用
+            this.videoRef = null;
+            // 确保视频元素获取到流
+            this.setupVideoPreview(stream);
+            // 检测浏览器支持的MIME类型
+            const mimeType = getSupportedMimeType();
+            // 创建MediaRecorder实例
+            let mediaRecorder;
+            try {
+                mediaRecorder = new MediaRecorder(stream, {
+                    mimeType: mimeType,
+                    videoBitsPerSecond: 800000, // 800kbps 视频比特率限制
+                    audioBitsPerSecond: 64000, // 64kbps 音频比特率限制
+                });
+            }
+            catch (e) {
+                // 如果指定MIME类型失败，尝试使用默认设置
+                console.warn('指定的MIME类型不受支持，使用默认设置:', e);
+                try {
+                    mediaRecorder = new MediaRecorder(stream, {
+                        videoBitsPerSecond: 800000, // 即使降级也保持比特率限制
+                        audioBitsPerSecond: 64000,
+                    });
+                }
+                catch (recorderError) {
+                    // 最后的降级选项，不设置任何参数
+                    try {
+                        mediaRecorder = new MediaRecorder(stream);
+                    }
+                    catch (finalError) {
+                        // 通知父组件录制器创建失败
+                        this.recordingError.emit({
+                            type: 'recorder_creation_failed',
+                            message: '无法创建媒体录制器，您的浏览器可能不支持此功能',
+                            details: finalError,
+                        });
+                        this.showRecordingUI = false;
+                        return;
+                    }
+                }
+            }
+            this.mediaRecorder = mediaRecorder;
+            const chunks = [];
+            mediaRecorder.ondataavailable = event => {
+                if (event.data.size > 0) {
+                    chunks.push(event.data);
+                }
+            };
+            mediaRecorder.onerror = event => {
+                // 通知父组件录制过程中发生错误
+                this.recordingError.emit({
+                    type: 'recording_error',
+                    message: '录制过程中发生错误',
+                    details: event,
+                });
+                this.stopRecording();
+            };
+            mediaRecorder.onstop = () => {
+                try {
+                    // 根据实际使用的MIME类型创建Blob
+                    const blobType = mimeType || 'video/mp4';
+                    const blob = new Blob(chunks, { type: blobType });
+                    if (blob.size === 0) {
+                        // 通知父组件录制的视频为空
+                        this.recordingError.emit({
+                            type: 'empty_recording',
+                            message: '录制的视频为空',
+                        });
+                        this.showRecordingUI = false;
+                        return;
+                    }
+                    this.recordedBlob = blob;
+                    // 通知父组件录制已完成
+                    this.recordingStatusChange.emit({
+                        status: 'stopped',
+                        details: {
+                            duration: Math.floor((Date.now() - this.recordingStartTime) / 1000),
+                            size: blob.size,
+                            type: blob.type,
+                        },
+                    });
+                    this.uploadRecordedVideo();
+                }
+                catch (error) {
+                    // 通知父组件处理录制视频时出错
+                    this.recordingError.emit({
+                        type: 'processing_error',
+                        message: '处理录制视频时出错',
+                        details: error,
+                    });
+                    this.showRecordingUI = false;
+                    SentryReporter.captureError(error, {
+                        action: 'uploadRecordedVideo',
+                        component: 'pcm-hr-chat-modal',
+                        title: '处理录制视频时出错',
+                    });
+                }
+            };
+            // 开始录制
+            try {
+                mediaRecorder.start();
+                this.isRecording = true;
+                this.recordingStartTime = Date.now();
+                this.recordingTimeLeft = this.maxRecordingTime;
+                // 通知父组件录制已开始
+                this.recordingStatusChange.emit({
+                    status: 'started',
+                    details: {
+                        maxDuration: this.maxRecordingTime,
+                        mimeType: mediaRecorder.mimeType,
+                    },
+                });
+            }
+            catch (startError) {
+                // 通知父组件开始录制失败
+                this.recordingError.emit({
+                    type: 'start_failed',
+                    message: '开始录制失败，请检查您的设备权限',
+                    details: startError,
+                });
+                this.showRecordingUI = false;
+                SentryReporter.captureError(startError, {
+                    action: 'startRecording',
+                    component: 'pcm-hr-chat-modal',
+                    title: '开始录制失败',
+                });
+                return;
+            }
+            // 设置录制计时器
+            this.recordingTimer = setInterval(() => {
+                const elapsedTime = Math.floor((Date.now() - this.recordingStartTime) / 1000);
+                this.recordingTimeLeft = Math.max(0, this.maxRecordingTime - elapsedTime);
+                // 检查是否需要显示倒计时警告
+                if (this.recordingTimeLeft <= this.countdownWarningTime && !this.showCountdownWarning) {
+                    this.showCountdownWarning = true;
+                }
+                // 时间到自动停止录制
+                if (this.recordingTimeLeft <= 0) {
+                    this.stopRecording();
+                }
+            }, 1000);
+        }
+        catch (error) {
+            console.error('无法访问摄像头或麦克风:', error);
+            // 设置设备错误状态
+            let errorMessage = '设备访问失败';
+            if (error.name === 'NotAllowedError') {
+                errorMessage = '请允许访问摄像头和麦克风权限';
+            }
+            else if (error.name === 'NotFoundError') {
+                errorMessage = '未检测到摄像头或麦克风设备';
+            }
+            else if (error.name === 'NotReadableError') {
+                errorMessage = '您的浏览器不支持视频录制，请切换到微信或Chrome、Edge使用';
+            }
+            else if (error.name === 'OverconstrainedError') {
+                errorMessage = '摄像头不支持指定的配置';
+            }
+            else {
+                errorMessage = '无法访问摄像头或麦克风，请检查设备连接';
+            }
+            this.deviceError = errorMessage;
+            this.showRecordingUI = false;
+            ErrorEventBus.emitError({
+                error: error,
+                message: errorMessage,
+            });
+            SentryReporter.captureError(error, {
+                action: 'startRecording',
+                component: 'components-oem-virtual-chat-modal',
+                title: errorMessage,
+            });
+        }
+    }
+    // 添加新方法来设置视频预览
+    setupVideoPreview(stream) {
+        // 延迟执行以确保DOM已更新
+        setTimeout(() => {
+            const videoElement = this.hostElement.shadowRoot?.querySelector('.user-video-preview');
+            if (videoElement && stream) {
+                // 先尝试使用标准方法
+                try {
+                    videoElement.srcObject = stream;
+                    videoElement.play().catch(err => {
+                        console.error('视频播放失败:', err);
+                        SentryReporter.captureError(err, {
+                            action: 'setupVideoPreview',
+                            component: 'components-oem-virtual-chat-modal',
+                            title: '视频播放失败',
+                        });
+                        ErrorEventBus.emitError({
+                            error: err,
+                            message: '视频播放失败',
+                        });
+                    });
+                }
+                catch (e) {
+                    console.warn('设置srcObject失败，尝试替代方法:', e);
+                    // 对于不支持srcObject的旧浏览器，使用URL.createObjectURL
+                    try {
+                        // 使用类型断言解决TypeScript错误
+                        const objectUrl = URL.createObjectURL(stream);
+                        videoElement.src = objectUrl;
+                        // 确保在视频元素不再使用时释放URL
+                        videoElement.onended = () => {
+                            URL.revokeObjectURL(objectUrl);
+                        };
+                    }
+                    catch (urlError) {
+                        console.error('创建对象URL失败:', urlError);
+                        SentryReporter.captureError(urlError, {
+                            action: 'setupVideoPreview',
+                            component: 'components-oem-virtual-chat-modal',
+                            title: '创建对象URL失败',
+                        });
+                        ErrorEventBus.emitError({
+                            error: urlError,
+                            message: '创建对象URL失败',
+                        });
+                    }
+                }
+            }
+            else {
+                console.warn('未找到视频元素或媒体流无效');
+            }
+        }, 100);
+    }
+    // 停止录制
+    stopRecording() {
+        if (this.mediaRecorder && this.isRecording) {
+            this.mediaRecorder.stop();
+            this.isRecording = false;
+            // 清理计时器
+            if (this.recordingTimer) {
+                clearInterval(this.recordingTimer);
+                this.recordingTimer = null;
+            }
+            // 停止并释放媒体流
+            if (this.recordingStream) {
+                this.recordingStream.getTracks().forEach(track => track.stop());
+                this.recordingStream = null;
+            }
+            // 清理视频引用
+            this.videoRef = null;
+        }
+        // 清理待播放的视频URL（即使没有正在录制，也需要清理待播放状态）
+        this.pendingGeneratedVideoUrl = '';
+    }
+    // 处理停止录制按钮点击
+    handleStopRecording = () => {
+        // 如果已经设置了跳过确认，直接停止录制
+        if (this.skipConfirmThisInterview) {
+            this.stopRecording();
+            return;
+        }
+        // 否则显示确认模态框
+        this.showConfirmModal = true;
+    };
+    // 处理"本次面试不再提醒"复选框变化
+    handleSkipConfirmChange = (event) => {
+        const checkbox = event.target;
+        this.skipConfirmThisInterview = checkbox.checked;
+    };
+    // 处理确认模态框的取消事件
+    handleConfirmModalCancel = () => {
+        this.showConfirmModal = false;
+    };
+    // 处理确认模态框的OK事件
+    handleConfirmModalOk = () => {
+        this.showConfirmModal = false;
+        this.stopRecording();
+    };
+    // 处理确认模态框的Cancel事件
+    handleConfirmModalCancelEvent = () => {
+        this.showConfirmModal = false;
+    };
+    // 上传录制的视频
+    async uploadRecordedVideo() {
+        if (!this.recordedBlob)
+            return;
+        try {
+            this.isUploadingVideo = true; // 开始上传时设置状态
+            this.showRecordingUI = false; // 隐藏视频预览
+            // 根据Blob类型确定文件扩展名
+            const fileExtension = this.recordedBlob.type.includes('webm') ? 'webm' : 'mp4';
+            const fileName = `answer.${fileExtension}`;
+            // 创建File对象
+            const file = new File([this.recordedBlob], fileName, { type: this.recordedBlob.type });
+            // 使用uploadFileToBackend上传文件
+            const fileInfo = await uploadFileToBackend(file, {}, {
+                tags: ['other'],
+            });
+            // 使用 cos_key 作为视频标识符
+            // 调用音频转文字API
+            const transcriptionText = await convertAudioToText(fileInfo.cos_key);
+            // 检查是否是结束面试流程
+            if (this.isEndingInterview) {
+                console.log('视频上传完成，现在发送结束面试消息');
+                // 如果是结束面试流程，发送结束面试消息
+                await this.sendEndInterviewMessage();
+            }
+            else {
+                // 正常流程：发送"下一题"请求，可以附带转录文本
+                this.sendMessageToAPI(transcriptionText || '下一题', fileInfo.cos_key);
+            }
+        }
+        catch (error) {
+            console.error('视频上传或处理错误:', error);
+            this.isEndingInterview = false; // 出错时重置标志
+            SentryReporter.captureError(error, {
+                action: 'uploadRecordedVideo',
+                component: 'components-oem-virtual-chat-modal',
+                title: '视频上传或处理失败',
+            });
+            ErrorEventBus.emitError({
+                error: error,
+                message: '视频上传或处理失败',
+            });
+        }
+        finally {
+            this.isUploadingVideo = false; // 上传完成后重置状态
+            this.showRecordingUI = false;
+            this.recordedBlob = null;
+        }
+    }
+    // 处理关闭按钮点击
+    handleCloseClick = () => {
+        // 显示关闭确认对话框
+        this.showCloseConfirmModal = true;
+    };
+    // 处理关闭确认对话框的确认事件
+    handleCloseConfirmOk = () => {
+        this.showCloseConfirmModal = false;
+        this.stopRecording();
+        this.modalClosed.emit();
+    };
+    // 处理关闭确认对话框的取消事件
+    handleCloseConfirmCancel = () => {
+        this.showCloseConfirmModal = false;
+    };
+    // 确保组件卸载时释放资源
+    disconnectedCallback() {
+        document.removeEventListener('pcm-token-invalid', this.tokenInvalidListener);
+        // 清理页面可见性监听器
+        if (this._visibilityChangeHandler) {
+            document.removeEventListener('visibilitychange', this._visibilityChangeHandler);
+            this._visibilityChangeHandler = null;
+        }
+        // 清理其他计时器
+        if (this.waitingTimer) {
+            clearInterval(this.waitingTimer);
+            this.waitingTimer = null;
+        }
+        if (this.recordingTimer) {
+            clearInterval(this.recordingTimer);
+            this.recordingTimer = null;
+        }
+        // 停止录制
+        this.stopRecording();
+        // 清理视频预加载缓存
+        this.preloadedVideos.clear();
+        this.preloadingVideos.clear();
+        // 清理待播放的视频URL
+        this.pendingGeneratedVideoUrl = '';
+    }
+    /**
+     * 预创建数字人视频
+     */
+    async precreateDigitalHumanVideos(digital_human_list) {
+        if (!this.virtualmanKey) {
+            console.warn('VirtualmanKey尚未加载，无法预创建视频。');
+            // 可以在此处添加逻辑，等待virtualmanKey加载后再执行
+            return;
+        }
+        for (const text of digital_human_list) {
+            if (!text || !text.trim())
+                continue;
+            try {
+                // 注意：这里只创建任务，不等待视频生成完成
+                await sendHttpRequest({
+                    url: '/sdk/v1/virtual-human/create-video',
+                    method: 'POST',
+                    data: {
+                        VirtualmanKey: this.virtualmanKey,
+                        InputSsml: text,
+                        SpeechParam: {
+                            Speed: 1,
+                        },
+                        VideoParam: {
+                            Format: 'TransparentWebm',
+                        },
+                        DriverType: 'Text',
+                    },
+                });
+            }
+            catch (error) {
+                console.error(`为文本 "${text}" 创建视频任务失败:`, error);
+                // 可以选择性地报告错误
+                SentryReporter.captureError(error, {
+                    action: 'precreateDigitalHumanVideos',
+                    component: 'components-oem-virtual-chat-modal',
+                    title: `为文本 "${text}" 创建视频任务失败`,
+                });
+            }
+        }
+        console.log('数字人视频预创建任务已全部发送。');
+    }
+    /**
+     * 初始化数字人功能
+     */
+    async initializeDigitalHuman() {
+        if (!this.digitalId)
+            return;
+        try {
+            console.log('初始化数字人功能，digitalId:', this.digitalId);
+            const response = await sendHttpRequest({
+                url: '/sdk/v1/virtual-human/avatar-detail',
+                method: 'POST',
+                data: {
+                    avatar_id: this.digitalId
+                }
+            });
+            if (response.success) {
+                const { placeholder_video_url, virtualman_key, opening_contents } = response.data;
+                if (placeholder_video_url) {
+                    this.digitalHumanDefaultVideoUrl = placeholder_video_url;
+                    this.digitalHumanVideoUrl = placeholder_video_url;
+                }
+                if (virtualman_key) {
+                    this.virtualmanKey = virtualman_key;
+                }
+                // 处理开场白内容（JSON格式）
+                if (opening_contents && Array.isArray(opening_contents) && opening_contents.length > 0) {
+                    this.digitalHumanOpeningContents = opening_contents;
+                    // 验证并调整开场白索引
+                    const validIndex = Math.max(0, Math.min(2, this.openingIndex || 0)); // 限制索引范围0-2
+                    const selectedOpeningContent = this.digitalHumanOpeningContents[validIndex] || this.digitalHumanOpeningContents[0];
+                    // 按顺序准备预加载列表：1.选择的欢迎视频 2.默认占位视频 3.其他视频
+                    const orderedVideosToPreload = [];
+                    // 1. 首先加载选择的欢迎视频
+                    if (selectedOpeningContent.video_url) {
+                        orderedVideosToPreload.push(selectedOpeningContent.video_url);
+                    }
+                    // 2. 然后加载默认占位视频（如果不同于选择的欢迎视频）
+                    if (placeholder_video_url && placeholder_video_url !== selectedOpeningContent.video_url) {
+                        orderedVideosToPreload.push(placeholder_video_url);
+                    }
+                    // 使用顺序预加载
+                    this.handleVideoUrlReceivedSequential(orderedVideosToPreload, '数字人初始化(顺序)');
+                    // 播放选择的欢迎视频 - 检查是否已经在继续对话模式下设置了状态
+                    if (selectedOpeningContent.video_url && !this.digitalHumanVideoReady) {
+                        console.log('播放数字人欢迎视频:', selectedOpeningContent.video_url, '索引:', validIndex);
+                        this.playDigitalHumanVideo(selectedOpeningContent.video_url, true);
+                    }
+                }
+                else {
+                    // 没有欢迎视频，只预加载默认占位视频
+                    if (placeholder_video_url) {
+                        this.handleVideoUrlReceivedSequential([placeholder_video_url], '数字人初始化(仅默认视频)');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('初始化数字人失败:', error);
+            SentryReporter.captureError(error, {
+                action: 'initializeDigitalHuman',
+                component: 'components-oem-virtual-chat-modal',
+                title: '数字人初始化失败',
+            });
+        }
+    }
+    /**
+     * 生成数字人视频
+     */
+    async generateDigitalHumanVideo(text) {
+        // 如果组件已停用，直接跳过生成视频
+        if (!this.isComponentActive) {
+            console.warn('组件已停用，跳过数字人视频生成');
+            return;
+        }
+        if (!text.trim() || !this.virtualmanKey) {
+            // 条件不满足时，取消等待状态并直接开始录制流程
+            if (this.waitingForDigitalHuman && !this.isTaskCompleted) {
+                console.log('数字人视频生成条件不满足，直接开始录制流程');
+                this.waitingForDigitalHuman = false;
+                this.startWaitingToRecord();
+            }
+            return;
+        }
+        console.log('开始生成数字人视频，文本内容：', text);
+        // 设置正在生成视频的状态
+        this.isGeneratingDigitalHumanVideo = true;
+        try {
+            // 创建视频任务
+            const createResponse = await sendHttpRequest({
+                url: '/sdk/v1/virtual-human/create-video',
+                method: 'POST',
+                data: {
+                    VirtualmanKey: this.virtualmanKey,
+                    InputSsml: text,
+                    SpeechParam: {
+                        Speed: 1
+                    },
+                    VideoParam: {
+                        Format: 'TransparentWebm',
+                    },
+                    DriverType: "Text",
+                }
+            });
+            console.log('数字人视频创建响应:', createResponse);
+            if (!createResponse.success) {
+                showMessage(createResponse.message, 'error');
+                throw new Error(`创建视频任务失败: ${createResponse.message}`);
+            }
+            const taskId = createResponse.data.Payload.TaskId;
+            console.log('视频任务创建成功，TaskId:', taskId);
+            // 轮询查询进度
+            const videoUrl = await this.pollVideoProgress(taskId);
+            // 轮询完成后，再次检查组件是否仍处于活动状态
+            if (!this.isComponentActive) {
+                console.warn('组件已停用，跳过视频播放');
+                return;
+            }
+            if (videoUrl) {
+                // 立即预加载新生成的视频（单个视频，不需要顺序处理）
+                await this.preloadVideo(videoUrl);
+                // 预加载后再次检查组件状态
+                if (!this.isComponentActive) {
+                    console.warn('组件已停用，跳过视频播放');
+                    return;
+                }
+                // 检查是否正在播放开场白视频
+                if (this.isPlayingWelcomeVideo) {
+                    // 如果正在播放开场白视频，保存生成的视频URL，等待开场白播放完成
+                    console.log('正在播放开场白视频，暂存生成的视频URL，等待开场白播放完成');
+                    this.pendingGeneratedVideoUrl = videoUrl;
+                }
+                else {
+                    // 否则立即播放生成的视频
+                    await this.playDigitalHumanVideo(videoUrl);
+                    console.log('数字人视频生成完成，视频URL:', videoUrl);
+                }
+            }
+            else {
+                // 如果没有获取到视频URL，抛出错误
+                throw new Error('未能获取到数字人视频URL');
+            }
+        }
+        catch (error) {
+            console.error('数字人视频生成失败:', error);
+            SentryReporter.captureError(error, {
+                action: 'generateDigitalHumanVideo',
+                component: 'components-oem-virtual-chat-modal',
+                title: '数字人视频生成失败',
+            });
+            // 数字人视频生成失败时，取消等待状态并直接开始录制流程
+            if (this.waitingForDigitalHuman && !this.isTaskCompleted) {
+                console.log('数字人视频生成失败，直接开始录制流程');
+                this.waitingForDigitalHuman = false;
+                this.startWaitingToRecord();
+            }
+        }
+        finally {
+            // 无论成功还是失败，都重置生成状态
+            this.isGeneratingDigitalHumanVideo = false;
+        }
+    }
+    /**
+     * 轮询查询视频生成进度
+     */
+    async pollVideoProgress(taskId) {
+        const maxAttempts = 45;
+        const pollInterval = 2000;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const response = await sendHttpRequest({
+                    url: '/sdk/v1/virtual-human/query-progress',
+                    method: 'POST',
+                    data: {
+                        TaskId: taskId
+                    }
+                });
+                if (!response.success) {
+                    throw new Error(`查询进度失败: ${response.message}`);
+                }
+                const payload = response.data.Payload;
+                if (payload.Status === 'SUCCESS' && payload.Progress === 100) {
+                    return payload.MediaUrl;
+                }
+                else if (payload.Status === 'FAILED') {
+                    throw new Error(`视频生成失败: ${payload.FailMessage}`);
+                }
+                await new Promise(resolve => setTimeout(resolve, pollInterval));
+            }
+            catch (error) {
+                console.error('轮询视频进度失败:', error);
+                break;
+            }
+        }
+        throw new Error('视频生成超时');
+    }
+    /**
+     * 播放数字人视频
+     */
+    async playDigitalHumanVideo(videoUrl, isWelcomeVideo = false) {
+        console.log('开始播放数字人视频:', videoUrl, '是否为欢迎视频:', isWelcomeVideo);
+        try {
+            // 确保视频已预加载（如果未预加载则立即预加载）
+            await this.preloadVideo(videoUrl);
+            // 只通过状态来控制video元素
+            this.digitalHumanVideoUrl = videoUrl;
+            this.isPlayingDigitalHumanVideo = true;
+            this.digitalHumanVideoReady = true;
+            this.isPlayingWelcomeVideo = isWelcomeVideo;
+        }
+        catch (error) {
+            console.error('播放数字人视频失败:', error);
+            // 数字人视频播放失败时，取消等待状态并直接开始录制流程
+            if (this.waitingForDigitalHuman && !this.isTaskCompleted) {
+                console.log('数字人视频播放失败，直接开始录制流程');
+                this.waitingForDigitalHuman = false;
+                this.startWaitingToRecord();
+            }
+        }
+    }
+    /**
+     * 智能视频预加载管理器
+     * 确保每个视频只预加载一次，避免重复请求
+     */
+    async preloadVideo(videoUrl) {
+        if (!videoUrl || !videoUrl.trim()) {
+            return Promise.resolve();
+        }
+        const normalizedUrl = videoUrl.trim();
+        const fileName = normalizedUrl.split('/').pop() || normalizedUrl;
+        // 如果已经预加载过，直接返回
+        if (this.preloadedVideos.has(normalizedUrl)) {
+            console.log(`💾 视频已预加载，跳过: ${fileName.substring(0, 30)}${fileName.length > 30 ? '...' : ''}`);
+            return Promise.resolve();
+        }
+        // 如果正在预加载中，返回现有的Promise
+        if (this.preloadingVideos.has(normalizedUrl)) {
+            console.log(`🔄 视频正在预加载中，等待完成: ${fileName.substring(0, 30)}${fileName.length > 30 ? '...' : ''}`);
+            return this.preloadingVideos.get(normalizedUrl);
+        }
+        // 创建新的预加载Promise
+        const preloadPromise = this.executeVideoPreload(normalizedUrl);
+        this.preloadingVideos.set(normalizedUrl, preloadPromise);
+        try {
+            await preloadPromise;
+            // 预加载成功，添加到已预加载集合
+            this.preloadedVideos.add(normalizedUrl);
+            console.log(`🎯 视频预加载成功: ${fileName.substring(0, 30)}${fileName.length > 30 ? '...' : ''}`);
+        }
+        catch (error) {
+            console.error(`💥 视频预加载失败: ${fileName.substring(0, 30)}${fileName.length > 30 ? '...' : ''}`, error);
+            // 预加载失败时不抛出错误，避免阻塞后续流程
+        }
+        finally {
+            // 清理正在预加载的记录
+            this.preloadingVideos.delete(normalizedUrl);
+        }
+    }
+    /**
+     * 执行实际的视频预加载操作
+     */
+    async executeVideoPreload(videoUrl) {
+        return new Promise((resolve, reject) => {
+            const preloadVideo = document.createElement('video');
+            preloadVideo.preload = 'auto';
+            preloadVideo.src = videoUrl;
+            preloadVideo.muted = true; // 确保可以自动播放
+            preloadVideo.crossOrigin = 'anonymous'; // 处理跨域问题
+            let isResolved = false;
+            const handleSuccess = () => {
+                if (isResolved)
+                    return;
+                isResolved = true;
+                cleanup();
+                console.log('视频预加载完成:', videoUrl);
+                resolve();
+            };
+            const handleError = (event) => {
+                if (isResolved)
+                    return;
+                isResolved = true;
+                cleanup();
+                console.error('视频预加载失败:', videoUrl, event);
+                reject(new Error('视频预加载失败'));
+            };
+            const cleanup = () => {
+                preloadVideo.removeEventListener('canplaythrough', handleSuccess);
+                preloadVideo.removeEventListener('loadeddata', handleSuccess);
+                preloadVideo.removeEventListener('error', handleError);
+                preloadVideo.removeEventListener('abort', handleError);
+                preloadVideo.src = '';
+            };
+            // 监听多种成功事件，提高兼容性
+            preloadVideo.addEventListener('canplaythrough', handleSuccess);
+            preloadVideo.addEventListener('loadeddata', handleSuccess);
+            // 监听错误事件
+            preloadVideo.addEventListener('error', handleError);
+            preloadVideo.addEventListener('abort', handleError);
+            // 设置超时机制，避免长时间等待
+            setTimeout(() => {
+                if (!isResolved) {
+                    console.warn('视频预加载超时:', videoUrl);
+                    handleError('timeout');
+                }
+            }, 15000); // 15秒超时
+            // 开始加载
+            preloadVideo.load();
+        });
+    }
+    /**
+     * 顺序预加载多个视频
+     * 上一个视频加载完毕后立刻加载下一个视频
+     */
+    async sequentialPreloadVideos(videoUrls) {
+        if (!videoUrls || videoUrls.length === 0) {
+            return;
+        }
+        const validUrls = videoUrls.filter(url => url && url.trim());
+        if (validUrls.length === 0) {
+            return;
+        }
+        console.log('🎬 开始顺序预加载视频:', validUrls);
+        console.log('📋 预加载计划:');
+        validUrls.forEach((url, index) => {
+            const fileName = url.split('/').pop() || url;
+            console.log(`  ${index + 1}. ${fileName.substring(0, 50)}${fileName.length > 50 ? '...' : ''}`);
+        });
+        for (let i = 0; i < validUrls.length; i++) {
+            const url = validUrls[i];
+            const fileName = url.split('/').pop() || url;
+            try {
+                console.log(`⏳ [${i + 1}/${validUrls.length}] 正在预加载: ${fileName.substring(0, 50)}${fileName.length > 50 ? '...' : ''}`);
+                const startTime = Date.now();
+                await this.preloadVideo(url);
+                const duration = Date.now() - startTime;
+                console.log(`✅ [${i + 1}/${validUrls.length}] 预加载完成 (${duration}ms): ${fileName.substring(0, 50)}${fileName.length > 50 ? '...' : ''}`);
+            }
+            catch (error) {
+                console.warn(`❌ [${i + 1}/${validUrls.length}] 预加载失败: ${fileName.substring(0, 50)}${fileName.length > 50 ? '...' : ''}`, error);
+                // 即使单个视频失败，也继续加载下一个
+            }
+        }
+        console.log('🎉 所有视频顺序预加载处理完成');
+    }
+    /**
+     * 顺序视频URL处理器
+     * 一旦获得视频URL，按顺序预加载
+     */
+    handleVideoUrlReceivedSequential(videoUrls, context = '') {
+        if (!videoUrls || videoUrls.length === 0)
+            return;
+        const validUrls = videoUrls.filter(url => url && url.trim());
+        if (validUrls.length === 0)
+            return;
+        console.log(`📥 收到${validUrls.length}个视频URL，将按顺序预加载 (${context})`);
+        // 异步顺序预加载，不阻塞主流程
+        this.sequentialPreloadVideos(validUrls).catch(error => {
+            console.warn(`⚠️ 顺序预加载视频失败 (${context}):`, error);
+        });
+    }
+    /**
+     * 处理页面从后台恢复（关屏/切后台回来）
+     * 检测并恢复可能卡住的流程
+     */
+    handlePageResume() {
+        // 如果任务已完成或未打开，不需要处理
+        if (this.isTaskCompleted || !this.isOpen || this.isEndingInterview) {
+            return;
+        }
+        console.log('页面恢复可见，检查流程状态:', {
+            waitingForDigitalHuman: this.waitingForDigitalHuman,
+            isPlayingDigitalHumanVideo: this.isPlayingDigitalHumanVideo,
+            waitingToRecord: this.waitingToRecord,
+            isRecording: this.isRecording,
+            showRecordingUI: this.showRecordingUI,
+        });
+        // 场景1: 数字人视频正在播放但可能被浏览器暂停/中断
+        // 尝试恢复视频播放，如果3秒后仍未结束则跳过
+        if (this.isPlayingDigitalHumanVideo) {
+            const videoEl = this.hostElement.shadowRoot?.querySelector('.digital-human-background-video');
+            if (videoEl) {
+                // 尝试恢复播放
+                const playPromise = videoEl.play();
+                if (playPromise) {
+                    playPromise.catch(() => {
+                        console.warn('恢复数字人视频播放失败，跳过视频');
+                        this.skipDigitalHumanVideo();
+                    });
+                }
+                // 设置安全超时：如果3秒后视频还没结束，直接跳过
+                setTimeout(() => {
+                    if (this.isPlayingDigitalHumanVideo) {
+                        console.warn('数字人视频恢复后3秒仍未结束，强制跳过');
+                        this.skipDigitalHumanVideo();
+                    }
+                }, 3000);
+            }
+            else {
+                // 视频元素不存在，直接跳过
+                this.skipDigitalHumanVideo();
+            }
+            return;
+        }
+        // 场景2: 等待数字人但视频已经不在播放状态（ended事件丢失）
+        if (this.waitingForDigitalHuman && !this.isPlayingDigitalHumanVideo) {
+            console.warn('检测到waitingForDigitalHuman卡住（视频未在播放），直接开始录制流程');
+            this.waitingForDigitalHuman = false;
+            this.startWaitingToRecord();
+            return;
+        }
+        // 场景3: 正在录制中，检查MediaStream是否仍然有效
+        if (this.isRecording && this.recordingStream) {
+            const tracks = this.recordingStream.getTracks();
+            const allEnded = tracks.length > 0 && tracks.every(track => track.readyState === 'ended');
+            if (allEnded) {
+                console.warn('检测到录制的MediaStream已被系统回收，停止录制');
+                this.deviceError = '设备被系统中断，请重新录制';
+                this.stopRecording();
+            }
+        }
+    }
+    /**
+     * 跳过当前数字人视频播放，直接进入录制流程
+     */
+    skipDigitalHumanVideo() {
+        this.digitalHumanVideoUrl = this.digitalHumanDefaultVideoUrl;
+        this.isPlayingDigitalHumanVideo = false;
+        this.isPlayingWelcomeVideo = false;
+        if (this.waitingForDigitalHuman && !this.isTaskCompleted && !this.isEndingInterview) {
+            this.waitingForDigitalHuman = false;
+            this.startWaitingToRecord();
+        }
+    }
+    /**
+     * 处理数字人视频播放结束
+     */
+    handleVideoElementEnded = async () => {
+        if (this.isPlayingDigitalHumanVideo) {
+            console.log('数字人视频播放完成，是否为欢迎视频:', this.isPlayingWelcomeVideo);
+            // 只通过状态来控制video元素，恢复默认视频
+            this.digitalHumanVideoUrl = this.digitalHumanDefaultVideoUrl;
+            this.isPlayingDigitalHumanVideo = false;
+            const wasWelcomeVideo = this.isPlayingWelcomeVideo;
+            this.isPlayingWelcomeVideo = false;
+            // 如果是开场白视频播放完成，检查是否有待播放的生成视频
+            if (wasWelcomeVideo && this.pendingGeneratedVideoUrl) {
+                console.log('开场白视频播放完成，开始播放生成的视频:', this.pendingGeneratedVideoUrl);
+                const videoUrl = this.pendingGeneratedVideoUrl;
+                this.pendingGeneratedVideoUrl = ''; // 清空待播放视频URL
+                await this.playDigitalHumanVideo(videoUrl);
+                return; // 播放生成的视频，不执行后续的录制流程
+            }
+            // 只有非欢迎视频播放完成后，才开始录制流程
+            // 如果任务已完成或正在结束面试，不开始录制流程
+            if (this.waitingForDigitalHuman && !this.isTaskCompleted && !this.isEndingInterview && !wasWelcomeVideo) {
+                this.waitingForDigitalHuman = false;
+                this.startWaitingToRecord();
+            }
+        }
+    };
+    /**
+     * 处理面试结束按钮点击 - 显示二次确认模态框
+     */
+    handleInterviewEnd = () => {
+        // 如果已经在结束流程中或任务已完成，不允许再次点击
+        if (this.isEndingInterview || this.isTaskCompleted) {
+            console.log('已在结束流程中或任务已完成，忽略点击');
+            return;
+        }
+        console.log('点击结束面试按钮，显示确认模态框');
+        this.showEndInterviewConfirmModal = true;
+    };
+    /**
+     * 确认结束面试
+     */
+    handleConfirmEndInterview = async () => {
+        try {
+            console.log('用户确认结束面试');
+            this.showEndInterviewConfirmModal = false;
+            // 设置结束面试标志
+            this.isEndingInterview = true;
+            // 停止所有可能正在进行的流程
+            // 1. 清除等待录制计时器
+            if (this.waitingTimer) {
+                clearInterval(this.waitingTimer);
+                this.waitingTimer = null;
+            }
+            this.waitingToRecord = false;
+            // 2. 清除等待数字人标志
+            this.waitingForDigitalHuman = false;
+            // 3. 如果正在录制，直接停止录制（不显示确认框）
+            if (this.isRecording) {
+                console.log('正在录制，直接停止录制并上传视频');
+                this.stopRecording(); // 直接调用 stopRecording，不通过 handleStopRecording
+                // uploadRecordedVideo 会在上传完成后检查 isEndingInterview 标志
+                // 并发送结束面试消息
+            }
+            else {
+                // 如果没有录制，直接发送结束面试消息
+                await this.sendEndInterviewMessage();
+            }
+        }
+        catch (error) {
+            console.error('点击结束发送消息失败:', error);
+            this.isEndingInterview = false;
+            SentryReporter.captureError(error, {
+                action: 'handleConfirmEndInterview',
+                component: 'components-oem-virtual-chat-modal',
+                title: '点击结束发送消息失败',
+            });
+            ErrorEventBus.emitError({
+                error: error,
+                message: '点击结束发送消息失败',
+            });
+        }
+    };
+    /**
+     * 发送结束面试消息
+     */
+    sendEndInterviewMessage = async () => {
+        try {
+            const endMessage = '请结束面试';
+            console.log('面试结束消息已发送:', {
+                conversation_id: this.conversationId,
+                message: endMessage,
+            });
+            // 发送消息到API
+            await this.sendMessageToAPI(endMessage);
+            // 重置标志
+            this.isEndingInterview = false;
+        }
+        catch (error) {
+            console.error('发送结束面试消息失败:', error);
+            this.isEndingInterview = false;
+            throw error;
+        }
+    };
+    /**
+     * 取消结束面试
+     */
+    handleCancelEndInterview = () => {
+        console.log('用户取消结束面试');
+        this.showEndInterviewConfirmModal = false;
+    };
+    /**
+     * 计算已回答的题数
+     */
+    getAnsweredQuestionCount = () => {
+        // 统计用户已经回答的问题数量（有answer的消息）
+        return this.messages.filter(msg => msg.answer && msg.answer.trim()).length;
+    };
+    renderChatHistory() {
+        // 如果正在播放欢迎视频，优先显示欢迎语
+        if (this.isPlayingWelcomeVideo) {
+            // 验证并调整开场白索引
+            const validIndex = Math.max(0, Math.min(2, this.openingIndex || 0)); // 限制索引范围0-2
+            const selectedOpeningContent = this.digitalHumanOpeningContents[validIndex] || this.digitalHumanOpeningContents[0];
+            const welcomeText = selectedOpeningContent.text;
+            return (h("div", { class: "ai-message-item" }, h("div", { class: "ai-message-content" }, welcomeText)));
+        }
+        // 如果正在生成数字人视频，显示查看面试信息的提示
+        if (this.isGeneratingDigitalHumanVideo || this.isLoading) {
+            return (h("div", { class: "ai-message-item" }, h("div", { class: "ai-message-content" }, "\u8BF7\u7A0D\u7B49\uFF0C\u6211\u67E5\u770B\u4E00\u4E0B\u672C\u6B21\u9762\u8BD5\u7684\u4FE1\u606F...")));
+        }
+        // 优先显示正在流式输出的消息
+        if (this.currentStreamingMessage && this.currentStreamingMessage.answer) {
+            return (h("div", { class: "ai-message-item streaming" }, h("div", { class: "ai-message-content", innerHTML: this.currentStreamingMessage.answer }), this.currentStreamingMessage.isStreaming && (h("div", { class: "typing-indicator" }, h("span", null), h("span", null), h("span", null)))));
+        }
+        // 找到最后一条有AI回复的消息
+        const lastMessageWithAnswer = [...this.messages].reverse().find(msg => msg.answer && msg.answer.trim());
+        if (lastMessageWithAnswer) {
+            return (h("div", { class: "ai-message-item" }, h("div", { class: "ai-message-content", innerHTML: lastMessageWithAnswer.answer })));
+        }
+        return (h("div", { class: "ai-message-item" }, h("div", { class: "ai-message-content" }, "\u8BF7\u7A0D\u7B49\uFF0C\u6211\u67E5\u770B\u4E00\u4E0B\u672C\u6B21\u9762\u8BD5\u7684\u4FE1\u606F...")));
+    }
+    render() {
+        if (!this.isOpen)
+            return null;
+        const modalStyle = {
+            zIndex: String(this.zIndex),
+        };
+        const containerClass = {
+            'modal-container': true,
+            'fullscreen': this.fullscreen,
+            'digital-human-mode': !!this.digitalId,
+        };
+        const overlayClass = {
+            'modal-overlay': true,
+            'fullscreen-overlay': this.fullscreen,
+        };
+        return (h("div", { class: overlayClass, style: modalStyle }, h("div", { class: containerClass }, h("button", { class: "close-button", onClick: this.handleCloseClick }, h("svg", { viewBox: "0 0 24 24", width: "20", height: "20", fill: "currentColor" }, h("path", { d: "M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z" }))), this.digitalId && this.digitalHumanVideoUrl && (h("div", { class: "digital-human-background" }, h("video", { autoplay: true, playsinline: true, loop: !this.isPlayingDigitalHumanVideo, muted: !this.isPlayingDigitalHumanVideo, src: this.digitalHumanVideoUrl, class: "digital-human-background-video", onEnded: this.handleVideoElementEnded, onPlay: e => {
+                // 浏览器切换 src 后可能重置 playbackRate，在 play 事件里补设一次
+                const el = e.target;
+                const isDefaultVideo = this.digitalHumanVideoUrl === this.digitalHumanDefaultVideoUrl;
+                el.playbackRate = isDefaultVideo ? 1.0 : this.playbackRate;
+            }, ref: el => {
+                if (el) {
+                    // 只有非默认占位视频才应用语速控制
+                    const isDefaultVideo = this.digitalHumanVideoUrl === this.digitalHumanDefaultVideoUrl;
+                    el.playbackRate = isDefaultVideo ? 1.0 : this.playbackRate;
+                    // 微信环境下，确保视频URL变化时重新加载
+                    // 如果src已经设置但视频未加载，手动触发load
+                    if (el.src && el.readyState === 0) {
+                        el.load();
+                    }
+                }
+            } }))), this.renderVideoPreview(), h("div", { class: "modal-content-layer" }, h("div", { class: "main-content" }, h("div", { class: "chat-history-section" }, this.renderChatHistory()), this.showEndInterviewButton && !this.isTaskCompleted && this.conversationId && (h("div", { class: "end-interview-button-container" }, h("button", { class: "end-interview-button", onClick: this.handleInterviewEnd, disabled: this.isEndingInterview || !this.isRecording, title: this.isEndingInterview ? '正在结束面试...' : !this.isRecording ? '请在录制时点击' : '结束面试' }, this.isEndingInterview ? '正在结束...' : '结束面试'))), this.renderRecordingStatusBar())), h("div", { style: { position: 'relative', zIndex: '100' } }, h("components-confirm-modal", { isOpen: this.showConfirmModal, modalTitle: "\u786E\u8BA4\u5B8C\u6210\u56DE\u7B54\uFF1F", okText: "\u786E\u8BA4\u5B8C\u6210", cancelText: "\u7EE7\u7EED\u5F55\u5236", okType: "danger", onOk: this.handleConfirmModalOk, onCancel: this.handleConfirmModalCancelEvent, onClosed: this.handleConfirmModalCancel }, h("div", { style: { marginBottom: '16px' } }, h("div", { style: {
+                fontSize: '14px',
+                color: '#1890ff',
+                fontWeight: '500',
+                marginBottom: '16px',
+                textAlign: 'center',
+            } }, "\u5F53\u524D\u5F55\u5236\u65F6\u957F\uFF1A", (() => {
+            const elapsedSeconds = this.recordingStartTime > 0 ? Math.floor((Date.now() - this.recordingStartTime) / 1000) : 0;
+            const minutes = Math.floor(elapsedSeconds / 60);
+            const seconds = elapsedSeconds % 60;
+            return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+        })()), h("div", { style: {
+                display: 'flex',
+                alignItems: 'center',
+                gap: '8px',
+                padding: '12px 16px',
+                background: '#fff7e6',
+                border: '1px solid #ffec99',
+                borderRadius: '6px',
+                color: '#d46b08',
+                fontSize: '14px',
+                marginBottom: '16px',
+            } }, h("svg", { viewBox: "0 0 24 24", width: "20", height: "20", fill: "currentColor" }, h("path", { d: "M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" })), h("span", null, "\u6CE8\u610F\uFF1A\u5F55\u5236\u4ECD\u5728\u8FDB\u884C\u4E2D")), h("div", { style: {
+                fontSize: '16px',
+                color: '#595959',
+                lineHeight: '1.5',
+                marginBottom: '16px',
+            } }, "\u70B9\u51FB\"\u786E\u8BA4\u5B8C\u6210\"\u5C06\u7ED3\u675F\u672C\u9898\u56DE\u7B54"), h("label", { style: {
+                display: 'flex',
+                alignItems: 'center',
+                gap: '8px',
+                cursor: 'pointer',
+                padding: '8px 0',
+                userSelect: 'none',
+            } }, h("input", { type: "checkbox", style: {
+                width: '16px',
+                height: '16px',
+                accentColor: '#1890ff',
+                cursor: 'pointer',
+                margin: '0',
+            }, checked: this.skipConfirmThisInterview, onChange: this.handleSkipConfirmChange }), h("span", { style: {
+                fontSize: '14px',
+                color: '#595959',
+                cursor: 'pointer',
+                lineHeight: '1.4',
+            } }, "\u672C\u6B21\u9762\u8BD5\u4E0D\u518D\u63D0\u9192"))))), h("div", { style: { position: 'relative', zIndex: '100' } }, h("components-confirm-modal", { isOpen: this.showCloseConfirmModal, modalTitle: "\u786E\u8BA4\u5173\u95ED\uFF1F", okText: "\u786E\u8BA4\u5173\u95ED", cancelText: "\u53D6\u6D88", okType: "danger", onOk: this.handleCloseConfirmOk, onCancel: this.handleCloseConfirmCancel, onClosed: this.handleCloseConfirmCancel }, h("div", { style: { marginBottom: '16px' } }, h("div", { style: {
+                fontSize: '16px',
+                color: '#595959',
+                lineHeight: '1.5',
+                marginBottom: '16px',
+            } }, this.isTaskCompleted ? '面试已结束，确认要关闭吗？' : '您的面试未完成，确认要关闭吗？')))), h("div", { style: { position: 'relative', zIndex: '100' } }, h("components-confirm-modal", { isOpen: this.showEndInterviewConfirmModal, modalTitle: "\u786E\u8BA4\u7ED3\u675F\u9762\u8BD5\uFF1F", okText: "\u786E\u8BA4\u7ED3\u675F", cancelText: "\u53D6\u6D88", okType: "danger", onOk: this.handleConfirmEndInterview, onCancel: this.handleCancelEndInterview, onClosed: this.handleCancelEndInterview }, h("div", { style: { marginBottom: '16px' } }, (() => {
+            const answeredCount = this.getAnsweredQuestionCount();
+            return (h("div", null, h("div", { style: {
+                    fontSize: '14px',
+                    color: '#1890ff',
+                    fontWeight: '500',
+                    marginBottom: '16px',
+                    textAlign: 'center',
+                } }, "\u5F53\u524D\u7B2C ", answeredCount, " \u9898"), answeredCount < 3 && (h("div", { style: {
+                    display: 'flex',
+                    alignItems: 'flex-start',
+                    gap: '8px',
+                    padding: '12px 16px',
+                    background: '#fff2e8',
+                    border: '1px solid #ffbb96',
+                    borderRadius: '6px',
+                    color: '#d4380d',
+                    fontSize: '14px',
+                    marginBottom: '16px',
+                } }, h("svg", { viewBox: "0 0 24 24", width: "20", height: "20", fill: "currentColor", style: { flexShrink: '0', marginTop: '2px' } }, h("path", { d: "M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" })), h("span", null, h("strong", null, "\u8B66\u544A\uFF1A"), "\u5F53\u524D\u5DF2\u56DE\u7B54\u9898\u6570\u5C0F\u4E8E 3 \u9898\uFF0C\u7ED3\u675F\u9762\u8BD5\u53EF\u80FD\u65E0\u6CD5\u6B63\u5E38\u5B8C\u6210\u9762\u8BD5\u6D41\u7A0B\uFF0C\u5EFA\u8BAE\u7EE7\u7EED\u5B8C\u6210\u66F4\u591A\u9898\u76EE\u540E\u518D\u7ED3\u675F\u9762\u8BD5\u3002"))), h("div", { style: {
+                    fontSize: '14px',
+                    color: '#595959',
+                    lineHeight: '1.6',
+                    textAlign: 'center',
+                } }, "\u786E\u8BA4\u8981\u7ED3\u675F\u9762\u8BD5\u5417\uFF1F\u7ED3\u675F\u540E\u5C06\u751F\u6210\u9762\u8BD5\u62A5\u544A\u3002")));
+        })()))))));
+    }
+    renderVideoPreview() {
+        if (!this.showRecordingUI) {
+            return null;
+        }
+        return (h("div", { class: "recording-preview-top-right" }, h("video", { class: "user-video-preview", autoPlay: true, playsInline: true, muted: true, style: { transform: 'scaleX(-1)' }, ref: el => {
+                if (el && this.recordingStream && !this.videoRef) {
+                    this.videoRef = el;
+                }
+            } })));
+    }
+    renderRecordingStatusBar() {
+        if (this.showRecordingUI) {
+            const minutes = Math.floor(this.recordingTimeLeft / 60)
+                .toString()
+                .padStart(2, '0');
+            const seconds = (this.recordingTimeLeft % 60).toString().padStart(2, '0');
+            return (h("div", { class: "recording-status-bar" }, h("div", { class: "audio-waveform" }, h("div", { class: "waveform-bar" }), h("div", { class: "waveform-bar" }), h("div", { class: "waveform-bar" }), h("div", { class: "waveform-bar" }), h("div", { class: "waveform-bar" }), h("div", { class: "waveform-bar" }), h("div", { class: "waveform-bar" }), h("div", { class: "waveform-bar" })), h("span", { class: "recording-timer" }, minutes, ":", seconds), h("button", { class: "finish-recording-btn", onClick: () => this.handleStopRecording() }, h("img", { src: "https://pcm-resource-1312611446.cos.ap-guangzhou.myqcloud.com/sdk/icon/gou.png", width: "16", height: "16", alt: "\u5B8C\u6210", style: { filter: 'brightness(0) invert(1)' } }))));
+        }
+        return h("div", { class: "recording-status-bar" }, this.renderStatusIndicator());
+    }
+    renderStatusIndicator() {
+        // 优先显示设备错误
+        if (this.deviceError) {
+            return (h("div", { class: "status-indicator-text error" }, h("svg", { viewBox: "0 0 24 24", width: "16", height: "16", fill: "currentColor" }, h("path", { d: "M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" })), h("span", null, this.deviceError)));
+        }
+        // 任务完成
+        if (this.isTaskCompleted) {
+            return (h("div", { class: "status-indicator-text" }, h("span", null, "\u9762\u8BD5\u5DF2\u5B8C\u6210")));
+        }
+        // 正在生成数字人视频
+        if (this.waitingForDigitalHuman && this.digitalId) {
+            return (h("div", { class: "status-indicator-text loading" }, h("div", { class: "loading-spinner-small" }), h("span", null, "\u9762\u8BD5\u5B98\u601D\u8003\u4E2D...")));
+        }
+        // 上传视频中
+        if (this.isUploadingVideo) {
+            return (h("div", { class: "status-indicator-text loading" }, h("div", { class: "loading-spinner-small" }), h("span", null, "\u6B63\u5728\u63D0\u4EA4\u56DE\u7B54...")));
+        }
+        // 等待题目
+        if (this.isLoading || this.currentStreamingMessage) {
+            return (h("div", { class: "status-indicator-text loading" }, h("div", { class: "loading-spinner-small" }), h("span", null, "\u9898\u76EE\u751F\u6210\u4E2D...")));
+        }
+        // 等待录制
+        if (this.waitingToRecord) {
+            return (h("div", { class: "status-indicator-text" }, h("span", null, this.waitingTimeLeft, " \u79D2\u540E\u5F00\u59CB\u60A8\u7684\u56DE\u7B54")));
+        }
+        // 准备就绪
+        return (h("div", { class: "status-indicator-text ready" }, h("img", { src: "https://pcm-resource-1312611446.cos.ap-guangzhou.myqcloud.com/sdk/icon/gou.png", width: "16", height: "16", alt: "\u51C6\u5907\u5C31\u7EEA" }), h("span", null, "\u51C6\u5907\u5C31\u7EEA")));
+    }
+    static get is() { return "components-oem-virtual-chat-modal"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["components-oem-virtual-chat-modal.css", "../../global/host.css"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["components-oem-virtual-chat-modal.css", "../../global/host.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "token": {
+                "type": "string",
+                "attribute": "token",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "SDK\u9274\u6743\u5BC6\u94A5"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "isOpen": {
+                "type": "boolean",
+                "attribute": "is-open",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u662F\u5426\u663E\u793A\u804A\u5929\u6A21\u6001\u6846"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "zIndex": {
+                "type": "number",
+                "attribute": "z-index",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u804A\u5929\u6846\u7684\u9875\u9762\u5C42\u7EA7"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "conversationId": {
+                "type": "string",
+                "attribute": "conversation-id",
+                "mutable": true,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u4F1A\u8BDDID\uFF0C\u4F20\u5165\u7EE7\u7EED\u5BF9\u8BDD\uFF0C\u5426\u5219\u521B\u5EFA\u65B0\u4F1A\u8BDD"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "defaultQuery": {
+                "type": "string",
+                "attribute": "default-query",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u9ED8\u8BA4\u53D1\u9001\u6587\u672C"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "'\u4F60\u597D\uFF01\u8058\u624D\u732B'"
+            },
+            "maxRecordingTime": {
+                "type": "number",
+                "attribute": "max-recording-time",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u89C6\u9891\u5F55\u5236\u6700\u5927\u65F6\u957F\uFF08\u79D2\uFF09"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "120"
+            },
+            "countdownWarningTime": {
+                "type": "number",
+                "attribute": "countdown-warning-time",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u5F55\u5236\u5012\u8BA1\u65F6\u63D0\u9192\u65F6\u95F4\uFF08\u79D2\uFF09\r\n\u5F53\u5269\u4F59\u65F6\u95F4\u5C0F\u4E8E\u6B64\u503C\u65F6\uFF0C\u663E\u793A\u5012\u8BA1\u65F6\u8B66\u544A"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "30"
+            },
+            "fullscreen": {
+                "type": "boolean",
+                "attribute": "fullscreen",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u662F\u5426\u4EE5\u5168\u5C4F\u6A21\u5F0F\u6253\u5F00\uFF0C\u79FB\u52A8\u7AEF\u5EFA\u8BAE\u8BBE\u7F6E\u4E3Atrue"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "digitalId": {
+                "type": "string",
+                "attribute": "digital-id",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u865A\u62DF\u6570\u5B57\u4EBAID\uFF0C\u6307\u5B9A\u5219\u5F00\u542F\u865A\u62DF\u6570\u5B57\u4EBA\u529F\u80FD"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "openingIndex": {
+                "type": "number",
+                "attribute": "opening-index",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u6570\u5B57\u4EBA\u5F00\u573A\u767D\u7D22\u5F15\uFF0C\u7528\u4E8E\u9009\u62E9\u5F00\u573A\u767D\u548C\u5F00\u573A\u89C6\u9891\uFF08\u53EF\u9009\uFF1A0, 1, 2\uFF09\r\n0\u3001\u60A8\u597D\uFF0C\u6211\u662F\u8058\u624D\u732B AI \u9762\u8BD5\u52A9\u624B\u3002\u5F88\u9AD8\u5174\u4E3A\u4F60\u4E3B\u6301\u8FD9\u573A\u9762\u8BD5\uFF01\u5728\u5F00\u59CB\u524D\uFF0C\u8BF7\u786E\u4FDD\uFF1A\u8EAB\u5904\u5B89\u9759\u3001\u5149\u7EBF\u5145\u8DB3\u7684\u73AF\u5883\u3002\u7F51\u7EDC\u987A\u7545\uFF0C\u6444\u50CF\u5934\u548C\u9EA6\u514B\u98CE\u5DE5\u4F5C\u6B63\u5E38\u3002\u73B0\u5728\u6211\u6B63\u5728\u67E5\u770B\u672C\u6B21\u9762\u8BD5\u7684\u76F8\u5173\u4FE1\u606F\uFF0C\u4E3A\u60A8\u751F\u6210\u4E13\u5C5E\u9762\u8BD5\u9898\uFF0C\u9A6C\u4E0A\u5C31\u597D\uFF0C\u8BF7\u7A0D\u7B49\u7247\u523B\u3002</br>\r\n1\u3001\u60A8\u597D\uFF0C\u6211\u662F\u60A8\u7684 AI \u9762\u8BD5\u52A9\u624B\u3002\u6B22\u8FCE\u53C2\u52A0\u672C\u6B21AI\u9762\u8BD5\uFF01\u4E3A\u4E86\u83B7\u5F97\u6700\u4F73\u6548\u679C\uFF0C\u8BF7\u786E\u8BA4\uFF1A\u60A8\u5728\u5B89\u9759\u3001\u660E\u4EAE\u7684\u73AF\u5883\u4E2D\u3002\u60A8\u7684\u7F51\u7EDC\u7A33\u5B9A\uFF0C\u6444\u50CF\u5934\u548C\u9EA6\u514B\u98CE\u5DF2\u5F00\u542F\u3002\u6211\u4EEC\u6B63\u5728\u540E\u53F0\u4E3A\u60A8\u51C6\u5907\u672C\u6B21\u4E13\u5C5E\u9762\u8BD5\u5185\u5BB9\uFF0C\u5F88\u5FEB\u5F00\u59CB\uFF0C\u8BF7\u7A0D\u5019\u3002<br>\r\n2\u3001\u60A8\u597D\uFF0C\u6211\u662F\u60A8\u7684 AI \u9762\u8BD5\u52A9\u624B\u3002\u9762\u8BD5\u9A6C\u4E0A\u5F00\u59CB\u3002\u8D81\u6B64\u7247\u523B\uFF0C\u8BF7\u5FEB\u901F\u786E\u8BA4\uFF1A\u5468\u56F4\u5B89\u9759\u5417\uFF1F\u5149\u7EBF\u8DB3\u591F\u5417\uFF1F\u7F51\u7EDC\u6CA1\u95EE\u9898\uFF1F\u6444\u50CF\u5934\u548C\u9EA6\u514B\u98CE\u51C6\u5907\u597D\u4E86\u5417\uFF1F\u6211\u4EEC\u6B63\u5728\u4E3A\u60A8\u52A0\u8F7D\u4E2A\u6027\u5316\u7684\u9762\u8BD5\u73AF\u8282\uFF0C\u7A0D\u7B49\u5C31\u597D\uFF01"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "0"
+            },
+            "waitingTime": {
+                "type": "number",
+                "attribute": "waiting-time",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u7B49\u5F85\u5F55\u5236\u65F6\u95F4\uFF08\u79D2\uFF09\u9ED8\u8BA410"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "10"
+            },
+            "playbackRate": {
+                "type": "number",
+                "attribute": "playback-rate",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u6570\u5B57\u4EBA\u89C6\u9891\u64AD\u653E\u901F\u7387\uFF080.5-2.0\u4E4B\u95F4\uFF09\uFF0C\u9ED8\u8BA41.0"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "1.0"
+            },
+            "showEndInterviewButton": {
+                "type": "boolean",
+                "attribute": "show-end-interview-button",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u662F\u5426\u663E\u793A\u7ED3\u675F\u9762\u8BD5\u6309\u94AE"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "customInputs": {
+                "type": "unknown",
+                "attribute": "custom-inputs",
+                "mutable": true,
+                "complexType": {
+                    "original": "Record<string, any>",
+                    "resolved": "{ [x: string]: any; }",
+                    "references": {
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "\u81EA\u5B9A\u4E49\u667A\u80FD\u4F53inputs\u8F93\u5165\u53C2\u6570"
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "{}"
+            },
+            "botId": {
+                "type": "string",
+                "attribute": "bot-id",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u673A\u5668\u4EBAID"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "messages": {},
+            "isLoading": {},
+            "currentStreamingMessage": {},
+            "isLoadingHistory": {},
+            "isRecording": {},
+            "recordingStream": {},
+            "recordedBlob": {},
+            "mediaRecorder": {},
+            "recordingTimeLeft": {},
+            "showRecordingUI": {},
+            "recordingTimer": {},
+            "recordingStartTime": {},
+            "waitingToRecord": {},
+            "waitingTimer": {},
+            "waitingTimeLeft": {},
+            "currentQuestionNumber": {},
+            "showCountdownWarning": {},
+            "isUploadingVideo": {},
+            "digitalHumanVideoUrl": {},
+            "digitalHumanDefaultVideoUrl": {},
+            "virtualmanKey": {},
+            "isPlayingDigitalHumanVideo": {},
+            "digitalHumanVideoReady": {},
+            "digitalHumanOpeningContents": {},
+            "isPlayingWelcomeVideo": {},
+            "isGeneratingDigitalHumanVideo": {},
+            "pendingGeneratedVideoUrl": {},
+            "waitingForDigitalHuman": {},
+            "agentLogo": {},
+            "isTaskCompleted": {},
+            "deviceError": {},
+            "showConfirmModal": {},
+            "skipConfirmThisInterview": {},
+            "showCloseConfirmModal": {},
+            "showEndInterviewConfirmModal": {},
+            "isEndingInterview": {},
+            "isComponentActive": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "streamComplete",
+                "name": "streamComplete",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u4E00\u8F6E\u5BF9\u8BDD\u7ED3\u675F\u65F6\u7684\u56DE\u8C03"
+                },
+                "complexType": {
+                    "original": "StreamCompleteEventData",
+                    "resolved": "StreamCompleteEventData",
+                    "references": {
+                        "StreamCompleteEventData": {
+                            "location": "import",
+                            "path": "../../interfaces/events",
+                            "id": "src/interfaces/events.ts::StreamCompleteEventData"
+                        }
+                    }
+                }
+            }, {
+                "method": "conversationStart",
+                "name": "conversationStart",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u65B0\u4F1A\u8BDD\u5F00\u59CB\u7684\u56DE\u8C03\uFF0C\u53EA\u4F1A\u5728\u4E00\u8F6E\u5BF9\u8BDD\u5F00\u59CB\u65F6\u89E6\u53D1\u4E00\u6B21"
+                },
+                "complexType": {
+                    "original": "ConversationStartEventData",
+                    "resolved": "ConversationStartEventData",
+                    "references": {
+                        "ConversationStartEventData": {
+                            "location": "import",
+                            "path": "../../interfaces/events",
+                            "id": "src/interfaces/events.ts::ConversationStartEventData"
+                        }
+                    }
+                }
+            }, {
+                "method": "interviewComplete",
+                "name": "interviewComplete",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u5F53\u804A\u5929\u5B8C\u6210\u65F6\u89E6\u53D1"
+                },
+                "complexType": {
+                    "original": "InterviewCompleteEventData",
+                    "resolved": "InterviewCompleteEventData",
+                    "references": {
+                        "InterviewCompleteEventData": {
+                            "location": "import",
+                            "path": "../../interfaces/events",
+                            "id": "src/interfaces/events.ts::InterviewCompleteEventData"
+                        }
+                    }
+                }
+            }, {
+                "method": "recordingError",
+                "name": "recordingError",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u5F55\u5236\u9519\u8BEF\u4E8B\u4EF6"
+                },
+                "complexType": {
+                    "original": "RecordingErrorEventData",
+                    "resolved": "RecordingErrorEventData",
+                    "references": {
+                        "RecordingErrorEventData": {
+                            "location": "import",
+                            "path": "../../interfaces/events",
+                            "id": "src/interfaces/events.ts::RecordingErrorEventData"
+                        }
+                    }
+                }
+            }, {
+                "method": "recordingStatusChange",
+                "name": "recordingStatusChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u5F55\u5236\u72B6\u6001\u53D8\u5316\u4E8B\u4EF6"
+                },
+                "complexType": {
+                    "original": "RecordingStatusChangeEventData",
+                    "resolved": "RecordingStatusChangeEventData",
+                    "references": {
+                        "RecordingStatusChangeEventData": {
+                            "location": "import",
+                            "path": "../../interfaces/events",
+                            "id": "src/interfaces/events.ts::RecordingStatusChangeEventData"
+                        }
+                    }
+                }
+            }, {
+                "method": "tokenInvalid",
+                "name": "tokenInvalid",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "SDK\u5BC6\u94A5\u9A8C\u8BC1\u5931\u8D25\u4E8B\u4EF6"
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "modalClosed",
+                "name": "modalClosed",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "\u5F53\u70B9\u51FB\u6A21\u6001\u6846\u5173\u95ED\u65F6\u89E6\u53D1"
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "setComponentActive": {
+                "complexType": {
+                    "signature": "(active: boolean) => Promise<void>",
+                    "parameters": [{
+                            "name": "active",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "\u516C\u5171\u65B9\u6CD5\uFF1A\u8BBE\u7F6E\u7EC4\u4EF6\u6D3B\u52A8\u72B6\u6001\r\n\u53EF\u88AB\u5916\u90E8\u8C03\u7528\u6765\u63A7\u5236\u7EC4\u4EF6\u662F\u5426\u7EE7\u7EED\u6267\u884C\u5F02\u6B65\u64CD\u4F5C",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "hostElement"; }
+    static get watchers() {
+        return [{
+                "propName": "token",
+                "methodName": "handleTokenChange"
+            }];
+    }
+}
+//# sourceMappingURL=components-oem-virtual-chat-modal.js.map