2082 lines
70 KiB
TypeScript
2082 lines
70 KiB
TypeScript
// @ts-nocheck
|
||
import { debugLog } from './common';
|
||
|
||
const debugNotifyLog = (...args: any[]) => {
|
||
void args;
|
||
};
|
||
const keyNotifyLog = (...args: any[]) => {
|
||
console.log(...args);
|
||
};
|
||
const jsonDebug = (...args: any[]) => {
|
||
console.log('[JSONDEBUG]', ...args);
|
||
};
|
||
const userMDebug = (...args: any[]) => {
|
||
console.log('[USERMDEBUG]', ...args);
|
||
};
|
||
const RESTORE_DEBUG_PREFIX = '[RESTORE_DEBUG]';
|
||
let restoreDebugCount = 0;
|
||
const RESTORE_DEBUG_MAX = 800;
|
||
const RESTORE_DEBUG_EVENTS = new Set([
|
||
'restore:start',
|
||
'restore:running-task-found',
|
||
'restore:history-empty',
|
||
'restore:task-detail-events',
|
||
'restore:rebuild-decision',
|
||
'restore:rebuild-polling-started',
|
||
'restore:polling-started-follow',
|
||
'restore:thinking-chunk-auto-start',
|
||
'restore:text-chunk-auto-start',
|
||
'restore:error',
|
||
'event:drop-duplicate',
|
||
'event:drop-conversation-mismatch'
|
||
]);
|
||
|
||
function isRestoreDebugEnabled() {
|
||
if (typeof window === 'undefined') return true;
|
||
try {
|
||
const explicit = (window as any).__RESTORE_DEBUG__;
|
||
if (explicit === false || explicit === '0') return false;
|
||
if (explicit === true || explicit === '1') return true;
|
||
const localFlag = window.localStorage?.getItem('restoreDebug');
|
||
if (localFlag === '0' || localFlag === 'false') return false;
|
||
if (localFlag === '1' || localFlag === 'true') return true;
|
||
return true;
|
||
} catch {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
function restoreDebugLog(event: string, payload: Record<string, any> = {}) {
|
||
if (!isRestoreDebugEnabled()) return;
|
||
if (!RESTORE_DEBUG_EVENTS.has(event)) return;
|
||
if (restoreDebugCount >= RESTORE_DEBUG_MAX) return;
|
||
restoreDebugCount += 1;
|
||
if (restoreDebugCount === RESTORE_DEBUG_MAX) {
|
||
console.warn(RESTORE_DEBUG_PREFIX, 'log-limit-reached', { max: RESTORE_DEBUG_MAX });
|
||
return;
|
||
}
|
||
console.log(RESTORE_DEBUG_PREFIX, event, payload);
|
||
}
|
||
|
||
function isSystemAutoUserMessagePayload(data: any): boolean {
|
||
if (!data || typeof data !== 'object') {
|
||
return false;
|
||
}
|
||
const meta = data.metadata || {};
|
||
return !!(
|
||
data.is_auto_generated ||
|
||
meta.is_auto_generated ||
|
||
data.auto_message_type ||
|
||
meta.auto_message_type ||
|
||
data.sub_agent_notice ||
|
||
meta.sub_agent_notice ||
|
||
data.background_command_notice ||
|
||
meta.background_command_notice
|
||
);
|
||
}
|
||
|
||
function isEmptyAssistantPlaceholderMessage(message: any): boolean {
|
||
if (!message || message.role !== 'assistant') {
|
||
return false;
|
||
}
|
||
const actions = Array.isArray(message.actions) ? message.actions : [];
|
||
return actions.length === 0 && !!message.awaitingFirstContent;
|
||
}
|
||
|
||
function getOptimisticUserEchoTarget(messages: any[]): any | null {
|
||
if (!Array.isArray(messages) || messages.length === 0) {
|
||
return null;
|
||
}
|
||
const lastIndex = messages.length - 1;
|
||
const last = messages[lastIndex];
|
||
if (last?.role === 'user') {
|
||
return last;
|
||
}
|
||
if (isEmptyAssistantPlaceholderMessage(last) && lastIndex > 0) {
|
||
const prev = messages[lastIndex - 1];
|
||
if (prev?.role === 'user') {
|
||
return prev;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 任务轮询事件处理器
|
||
* 将从 REST API 轮询获取的事件转换为前端状态更新
|
||
*/
|
||
export const taskPollingMethods = {
|
||
scheduleTodoListRefresh(delayMs = 120) {
|
||
const delay = Number.isFinite(delayMs) ? Math.max(0, Number(delayMs)) : 120;
|
||
if (this._todoRefreshTimer) {
|
||
clearTimeout(this._todoRefreshTimer);
|
||
this._todoRefreshTimer = null;
|
||
}
|
||
this._todoRefreshTimer = setTimeout(() => {
|
||
this._todoRefreshTimer = null;
|
||
if (typeof this.fetchTodoList === 'function') {
|
||
Promise.resolve(this.fetchTodoList()).catch(() => {});
|
||
}
|
||
}, delay);
|
||
},
|
||
|
||
cleanupTrailingEmptyAssistantPlaceholder(reason = 'unspecified') {
|
||
if (!Array.isArray(this.messages) || !this.messages.length) {
|
||
return false;
|
||
}
|
||
const last = this.messages[this.messages.length - 1];
|
||
if (!isEmptyAssistantPlaceholderMessage(last)) {
|
||
return false;
|
||
}
|
||
this.messages.pop();
|
||
if (typeof this.currentMessageIndex === 'number') {
|
||
this.currentMessageIndex = this.messages.length - 1;
|
||
}
|
||
userMDebug('taskPolling.cleanupTrailingEmptyAssistantPlaceholder:removed', {
|
||
reason,
|
||
messagesLengthAfter: this.messages.length,
|
||
currentMessageIndex: this.currentMessageIndex
|
||
});
|
||
return true;
|
||
},
|
||
|
||
stopWaitingTaskProbe() {
|
||
if (this.waitingTaskProbeTimer) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] stopWaitingTaskProbe');
|
||
clearInterval(this.waitingTaskProbeTimer);
|
||
this.waitingTaskProbeTimer = null;
|
||
}
|
||
},
|
||
|
||
async tryResumeWaitingNoticeTask() {
|
||
if (!this.waitingForSubAgent || !this.currentConversationId) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] tryResumeWaitingNoticeTask:skip', {
|
||
waitingForSubAgent: this.waitingForSubAgent,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
return false;
|
||
}
|
||
try {
|
||
const { useTaskStore } = await import('../../stores/task');
|
||
const taskStore = useTaskStore();
|
||
if (taskStore.hasActiveTask) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] tryResumeWaitingNoticeTask:already-active', {
|
||
taskId: taskStore.currentTaskId,
|
||
status: taskStore.taskStatus
|
||
});
|
||
return true;
|
||
}
|
||
|
||
const resp = await fetch('/api/tasks');
|
||
if (!resp.ok) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] tryResumeWaitingNoticeTask:tasks-api-not-ok', {
|
||
status: resp.status
|
||
});
|
||
return false;
|
||
}
|
||
const result = await resp.json().catch(() => ({}));
|
||
const tasks = Array.isArray(result?.data) ? result.data : [];
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] tryResumeWaitingNoticeTask:tasks', {
|
||
currentConversationId: this.currentConversationId,
|
||
count: tasks.length,
|
||
running: tasks
|
||
.filter((t: any) => t?.status === 'running')
|
||
.map((t: any) => ({
|
||
task_id: t?.task_id,
|
||
conversation_id: t?.conversation_id,
|
||
status: t?.status
|
||
}))
|
||
});
|
||
const runningTask = tasks.find(
|
||
(task: any) =>
|
||
task?.status === 'running' && task?.conversation_id === this.currentConversationId
|
||
);
|
||
if (!runningTask?.task_id) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] tryResumeWaitingNoticeTask:no-matched-task');
|
||
return false;
|
||
}
|
||
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] tryResumeWaitingNoticeTask:resume', {
|
||
task_id: runningTask.task_id
|
||
});
|
||
keyNotifyLog('[DEBUG_NOTIFY_KEY][ui] tryResumeWaitingNoticeTask:resume', {
|
||
task_id: runningTask.task_id,
|
||
conversationId: this.currentConversationId
|
||
});
|
||
// 关键修复：切到新的通知任务前，清空旧任务事件去重索引。
|
||
// 否则新任务 event idx 与旧任务重叠时会被误判为“重复事件”而丢失 user_message。
|
||
if (typeof this.clearProcessedEvents === 'function') {
|
||
this.clearProcessedEvents();
|
||
}
|
||
taskStore.resumeTask(runningTask.task_id, {
|
||
status: 'running',
|
||
resetOffset: true,
|
||
eventHandler: (event: any) => this.handleTaskEvent(event)
|
||
});
|
||
return true;
|
||
} catch (error) {
|
||
console.warn('[TaskPolling] 接管等待任务失败:', error);
|
||
return false;
|
||
}
|
||
},
|
||
|
||
startWaitingTaskProbe() {
|
||
if (this.waitingTaskProbeTimer) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] startWaitingTaskProbe:already-started');
|
||
return;
|
||
}
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] startWaitingTaskProbe');
|
||
keyNotifyLog('[DEBUG_NOTIFY_KEY][ui] startWaitingTaskProbe', {
|
||
conversationId: this.currentConversationId
|
||
});
|
||
this.waitingTaskProbeTimer = setInterval(async () => {
|
||
if (!this.waitingForSubAgent) {
|
||
this.stopWaitingTaskProbe();
|
||
return;
|
||
}
|
||
const resumed = await this.tryResumeWaitingNoticeTask();
|
||
if (resumed) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] waitingTaskProbe:resumed-and-stop');
|
||
keyNotifyLog('[DEBUG_NOTIFY_KEY][ui] waitingTaskProbe:resumed-and-stop');
|
||
this.stopWaitingTaskProbe();
|
||
}
|
||
}, 1000);
|
||
},
|
||
|
||
/**
|
||
* 处理任务事件（从轮询获取）
|
||
*/
|
||
handleTaskEvent(event: any) {
|
||
if (!event || !event.type) {
|
||
return;
|
||
}
|
||
|
||
const eventType = event.type;
|
||
const eventData = event.data || {};
|
||
const eventIdx = event.idx;
|
||
if (eventType === 'task_complete' || eventType === 'task_stopped' || eventType === 'error') {
|
||
jsonDebug('task-event', {
|
||
eventType,
|
||
eventIdx,
|
||
currentConversationId: this.currentConversationId,
|
||
eventConversationId: eventData?.conversation_id,
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested,
|
||
waitingForSubAgent: this.waitingForSubAgent,
|
||
waitingForBackgroundCommand: this.waitingForBackgroundCommand,
|
||
errorType: eventData?.error_type,
|
||
errorMessage: eventData?.message
|
||
});
|
||
}
|
||
if (
|
||
eventType === 'system_message' ||
|
||
eventType === 'sub_agent_waiting' ||
|
||
(eventType === 'user_message' && eventData?.sub_agent_notice)
|
||
) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][event] 捕获关键事件', {
|
||
eventType,
|
||
eventIdx,
|
||
eventData
|
||
});
|
||
keyNotifyLog('[DEBUG_NOTIFY_KEY][event] key-event', {
|
||
eventType,
|
||
idx: eventIdx,
|
||
task_id: eventData?.task_id,
|
||
sub_agent_notice: !!eventData?.sub_agent_notice,
|
||
has_running_sub_agents: eventData?.has_running_sub_agents,
|
||
has_running_background_commands: eventData?.has_running_background_commands
|
||
});
|
||
}
|
||
|
||
// 事件去重检查
|
||
if (typeof eventIdx === 'number') {
|
||
if (!this._processedEventIndices) {
|
||
this._processedEventIndices = new Set();
|
||
}
|
||
|
||
if (this._processedEventIndices.has(eventIdx)) {
|
||
if (
|
||
[
|
||
'ai_message_start',
|
||
'thinking_start',
|
||
'thinking_chunk',
|
||
'thinking_end',
|
||
'text_start',
|
||
'text_chunk',
|
||
'text_end'
|
||
].includes(eventType)
|
||
) {
|
||
restoreDebugLog('event:drop-duplicate', {
|
||
eventType,
|
||
eventIdx,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
}
|
||
debugLog(`[TaskPolling] 跳过重复事件 #${eventIdx}`);
|
||
return;
|
||
}
|
||
|
||
this._processedEventIndices.add(eventIdx);
|
||
|
||
// 限制 Set 大小（保留最近 1000 个）
|
||
if (this._processedEventIndices.size > 1000) {
|
||
const firstIdx = Math.min(...this._processedEventIndices);
|
||
this._processedEventIndices.delete(firstIdx);
|
||
}
|
||
}
|
||
|
||
// 检查事件的 conversation_id 是否匹配当前对话
|
||
// 如果不匹配，忽略该事件（避免切换对话后旧任务的事件显示到新对话中）
|
||
const crossConversationAllowed = new Set([
|
||
'shallow_compression',
|
||
'conversation_resolved',
|
||
'compression_finished'
|
||
]);
|
||
if (
|
||
!crossConversationAllowed.has(eventType) &&
|
||
eventData.conversation_id &&
|
||
this.currentConversationId
|
||
) {
|
||
if (eventData.conversation_id !== this.currentConversationId) {
|
||
if (
|
||
[
|
||
'ai_message_start',
|
||
'thinking_start',
|
||
'thinking_chunk',
|
||
'thinking_end',
|
||
'text_start',
|
||
'text_chunk',
|
||
'text_end'
|
||
].includes(eventType)
|
||
) {
|
||
restoreDebugLog('event:drop-conversation-mismatch', {
|
||
eventType,
|
||
eventIdx,
|
||
eventConversationId: eventData.conversation_id,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
}
|
||
console.log(`[DEBUG_AWAITING] 忽略不匹配的事件`, {
|
||
eventType,
|
||
eventIdx,
|
||
eventConversationId: eventData.conversation_id,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
debugLog(
|
||
`[TaskPolling] 忽略不匹配的事件 #${eventIdx}: ${eventType}, 事件对话=${eventData.conversation_id}, 当前对话=${this.currentConversationId}`
|
||
);
|
||
return;
|
||
}
|
||
}
|
||
|
||
debugLog(`[TaskPolling] 处理事件 #${eventIdx}: ${eventType}`, eventData);
|
||
|
||
console.log(`[DEBUG_AWAITING] 处理事件`, {
|
||
eventType,
|
||
eventIdx,
|
||
eventConversationId: eventData.conversation_id,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
|
||
// 根据事件类型调用对应的处理方法
|
||
switch (eventType) {
|
||
case 'ai_message_start':
|
||
this.handleAiMessageStart(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'thinking_start':
|
||
this.handleThinkingStart(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'thinking_chunk':
|
||
this.handleThinkingChunk(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'thinking_end':
|
||
this.handleThinkingEnd(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'text_start':
|
||
this.handleTextStart(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'text_chunk':
|
||
this.handleTextChunk(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'text_end':
|
||
this.handleTextEnd(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'tool_preparing':
|
||
this.handleToolPreparing(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'tool_start':
|
||
this.handleToolStart(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'tool_intent':
|
||
this.handleToolIntent(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'tool_update_action':
|
||
case 'update_action':
|
||
this.handleToolUpdateAction(eventData, eventIdx);
|
||
break;
|
||
case 'tool_approval_required':
|
||
this.handleToolApprovalRequired(eventData, eventIdx);
|
||
break;
|
||
case 'tool_approval_resolved':
|
||
this.handleToolApprovalResolved(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'append_payload':
|
||
this.handleAppendPayload(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'modify_payload':
|
||
this.handleModifyPayload(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'task_complete':
|
||
this.handleTaskComplete(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'task_stopped':
|
||
this.handleTaskStopped(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'error':
|
||
this.handleTaskError(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'token_update':
|
||
this.handleTokenUpdate(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'conversation_changed':
|
||
this.handleConversationChanged(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'conversation_resolved':
|
||
this.handleConversationResolved(eventData, eventIdx);
|
||
break;
|
||
case 'compression_state':
|
||
this.handleCompressionState(eventData, eventIdx);
|
||
break;
|
||
case 'compression_finished':
|
||
this.handleCompressionFinished(eventData, eventIdx);
|
||
break;
|
||
case 'shallow_compression':
|
||
this.handleShallowCompression(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'user_message':
|
||
debugNotifyLog('[DEBUG_NOTIFY][event] dispatch:user_message', {
|
||
idx: eventIdx,
|
||
data: eventData
|
||
});
|
||
this.handleUserMessage(eventData, eventIdx);
|
||
break;
|
||
|
||
case 'system_message':
|
||
this.handleSystemMessage(eventData, eventIdx);
|
||
break;
|
||
|
||
default:
|
||
debugLog(`[TaskPolling] 未知事件类型: ${eventType}`);
|
||
}
|
||
|
||
// 注意：不要在这里清除 _rebuildingFromScratch 标记
|
||
// 该标记应该在恢复完所有历史事件后才清除
|
||
},
|
||
|
||
handleAiMessageStart(data: any, eventIdx: number) {
|
||
const lastMessage = this.messages[this.messages.length - 1];
|
||
console.log('[DEBUG_AWAITING] ===== handleAiMessageStart =====', {
|
||
eventIdx,
|
||
lastMessageRole: lastMessage?.role,
|
||
lastMessageAwaitingFirstContent: lastMessage?.awaitingFirstContent,
|
||
lastMessageGeneratingLabel: lastMessage?.generatingLabel
|
||
});
|
||
|
||
debugLog('[TaskPolling] AI消息开始, idx:', eventIdx);
|
||
console.log('[AiMessageStart] 开始处理', {
|
||
eventIdx,
|
||
messagesLength: this.messages.length,
|
||
lastMessageRole: this.messages[this.messages.length - 1]?.role,
|
||
streamingMessage: this.streamingMessage,
|
||
taskInProgress: this.taskInProgress,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
|
||
if (this.waitingForSubAgent) {
|
||
this.waitingForSubAgent = false;
|
||
}
|
||
|
||
// 检查是否已经有 assistant 消息
|
||
const hasAssistantMessage = lastMessage && lastMessage.role === 'assistant';
|
||
|
||
console.log('[AiMessageStart] 最后一条消息状态', {
|
||
hasAssistantMessage,
|
||
lastMessageActionsLength: lastMessage?.actions?.length || 0,
|
||
lastMessageAwaitingFirstContent: lastMessage?.awaitingFirstContent,
|
||
lastMessageGeneratingLabel: lastMessage?.generatingLabel
|
||
});
|
||
|
||
// 判断是否是刷新恢复的情况：
|
||
// 1. 有assistant消息
|
||
// 2. 且最后一条 assistant 仍处于“未完成流式状态”（而不是普通已完成消息）
|
||
// 3. 且任务确实仍在进行中
|
||
const lastActions = Array.isArray(lastMessage?.actions) ? lastMessage.actions : [];
|
||
const hasUnfinishedAction = lastActions.some((action: any) => {
|
||
if (!action) return false;
|
||
if (action.streaming) return true;
|
||
if (action.type === 'tool' && action.tool) {
|
||
const status = String(action.tool.status || '').toLowerCase();
|
||
return ['preparing', 'running', 'pending', 'queued', 'awaiting_approval'].includes(status);
|
||
}
|
||
return false;
|
||
});
|
||
const hasNoActionsYet = !lastActions.length;
|
||
const isRefreshRestore =
|
||
hasAssistantMessage &&
|
||
(hasNoActionsYet || hasUnfinishedAction || lastMessage.awaitingFirstContent === true) &&
|
||
(this.taskInProgress || this.streamingMessage);
|
||
|
||
userMDebug('taskPolling.handleAiMessageStart:decision', {
|
||
eventIdx,
|
||
hasAssistantMessage,
|
||
hasNoActionsYet,
|
||
hasUnfinishedAction,
|
||
awaitingFirstContent: !!lastMessage?.awaitingFirstContent,
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
isRefreshRestore
|
||
});
|
||
|
||
console.log('[AiMessageStart] 场景判断', {
|
||
isRefreshRestore,
|
||
streamingMessage: this.streamingMessage,
|
||
hasActions: !!(lastMessage?.actions && lastMessage.actions.length > 0),
|
||
awaitingFirstContent: lastMessage?.awaitingFirstContent,
|
||
taskInProgress: this.taskInProgress
|
||
});
|
||
|
||
if (isRefreshRestore) {
|
||
console.log('[AiMessageStart] 场景=刷新恢复，复用现有assistant消息');
|
||
debugLog('[TaskPolling] 刷新恢复场景，复用现有 assistant 消息');
|
||
// 只更新状态，不创建新消息
|
||
this.taskInProgress = true;
|
||
this.stopRequested = false;
|
||
this.streamingMessage = true;
|
||
|
||
// 确保 awaitingFirstContent 被正确设置
|
||
const hasContent = lastMessage.actions && lastMessage.actions.length > 0;
|
||
if (!hasContent) {
|
||
lastMessage.awaitingFirstContent = true;
|
||
lastMessage.generatingLabel = lastMessage.generatingLabel || '思考中...';
|
||
console.log('[AiMessageStart] 设置等待动画', {
|
||
awaitingFirstContent: true,
|
||
generatingLabel: lastMessage.generatingLabel
|
||
});
|
||
} else {
|
||
// 如果已有内容，确保等待动画不显示
|
||
lastMessage.awaitingFirstContent = false;
|
||
lastMessage.generatingLabel = '';
|
||
console.log('[AiMessageStart] 关闭等待动画（已有内容）');
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 其他情况：创建新的 assistant 消息
|
||
console.log('[AiMessageStart] 场景=创建新消息');
|
||
debugLog('[TaskPolling] 创建新的 assistant 消息');
|
||
this.monitorResetSpeech();
|
||
this.cleanupStaleToolActions();
|
||
this.taskInProgress = true;
|
||
this.chatStartAssistantMessage();
|
||
this.stopRequested = false;
|
||
this.streamingMessage = true;
|
||
|
||
const newMessage = this.messages[this.messages.length - 1];
|
||
console.log('[AiMessageStart] 新消息创建完成', {
|
||
role: newMessage?.role,
|
||
awaitingFirstContent: newMessage?.awaitingFirstContent,
|
||
generatingLabel: newMessage?.generatingLabel,
|
||
actionsLength: newMessage?.actions?.length || 0,
|
||
messagesLength: this.messages.length
|
||
});
|
||
|
||
// 如果是从头重建，标记消息为静默恢复
|
||
if (this._rebuildingFromScratch) {
|
||
if (newMessage && newMessage.role === 'assistant') {
|
||
debugLog('[TaskPolling] 标记消息为静默恢复（从头重建）');
|
||
newMessage.awaitingFirstContent = false;
|
||
newMessage.generatingLabel = '';
|
||
console.log('[AiMessageStart] 从头重建，关闭等待动画');
|
||
}
|
||
}
|
||
|
||
// 强制触发Vue响应式更新
|
||
this.$forceUpdate();
|
||
console.log('[AiMessageStart] 已调用$forceUpdate');
|
||
|
||
this.$nextTick(() => {
|
||
console.log('[AiMessageStart] nextTick回调执行');
|
||
this.conditionalScrollToBottom();
|
||
});
|
||
},
|
||
|
||
handleThinkingStart(data: any, eventIdx: number) {
|
||
console.log('[ThinkingStart] 开始处理', { eventIdx });
|
||
debugLog('[TaskPolling] 思考开始, idx:', eventIdx);
|
||
const ignoreThinking = this.runMode === 'fast' || this.thinkingMode === false;
|
||
if (ignoreThinking) {
|
||
this.monitorEndModelOutput();
|
||
console.log('[ThinkingStart] 忽略思考（fast模式或关闭思考）');
|
||
return;
|
||
}
|
||
|
||
// 防御性检查：如果没有assistant消息，先创建一个
|
||
const lastMessage = this.messages[this.messages.length - 1];
|
||
if (!lastMessage || lastMessage.role !== 'assistant') {
|
||
console.log('[DEBUG_AWAITING] ThinkingStart 检测到缺少assistant消息，自动创建');
|
||
this.chatStartAssistantMessage();
|
||
}
|
||
|
||
this.monitorShowThinking();
|
||
|
||
const result = this.chatStartThinkingAction();
|
||
|
||
if (result && result.blockId) {
|
||
const blockId = result.blockId;
|
||
|
||
const lastMessage = this.messages[this.messages.length - 1];
|
||
|
||
// 有内容了，关闭等待动画
|
||
if (lastMessage && lastMessage.role === 'assistant') {
|
||
console.log('[ThinkingStart] 关闭等待动画', {
|
||
beforeAwaitingFirstContent: lastMessage.awaitingFirstContent,
|
||
beforeGeneratingLabel: lastMessage.generatingLabel
|
||
});
|
||
lastMessage.awaitingFirstContent = false;
|
||
lastMessage.generatingLabel = '';
|
||
}
|
||
|
||
// 只在非历史恢复时展开思考块
|
||
if (!this._rebuildingFromScratch) {
|
||
this.chatExpandBlock(blockId);
|
||
}
|
||
|
||
this.conditionalScrollToBottom();
|
||
this.chatSetThinkingLock(blockId, true);
|
||
|
||
// 强制触发 actions 数组的响应式更新
|
||
if (lastMessage && lastMessage.actions) {
|
||
lastMessage.actions = [...lastMessage.actions];
|
||
}
|
||
|
||
this.$forceUpdate();
|
||
}
|
||
},
|
||
|
||
handleThinkingChunk(data: any) {
|
||
if (this.runMode === 'fast' || this.thinkingMode === false) {
|
||
return;
|
||
}
|
||
let thinkingAction = this.chatAppendThinkingChunk(data.content);
|
||
// 兜底：刷新恢复时可能只能拿到 chunk 事件（start 事件已被服务端窗口截断）
|
||
// 此时补建一个 thinking action，避免思考内容丢失。
|
||
if (!thinkingAction && data?.content) {
|
||
const started = this.chatStartThinkingAction();
|
||
thinkingAction = this.chatAppendThinkingChunk(data.content);
|
||
restoreDebugLog('restore:thinking-chunk-auto-start', {
|
||
startedBlockId: started?.blockId || null,
|
||
contentLength: String(data.content || '').length,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
}
|
||
if (thinkingAction) {
|
||
this.$forceUpdate();
|
||
this.$nextTick(() => {
|
||
if (thinkingAction && thinkingAction.blockId) {
|
||
this.scrollThinkingToBottom(thinkingAction.blockId);
|
||
}
|
||
this.conditionalScrollToBottom();
|
||
});
|
||
}
|
||
this.monitorShowThinking();
|
||
},
|
||
|
||
handleThinkingEnd(data: any) {
|
||
debugLog('[TaskPolling] 思考结束');
|
||
if (this.runMode === 'fast' || this.thinkingMode === false) {
|
||
return;
|
||
}
|
||
const blockId = this.chatCompleteThinkingAction(data.full_content);
|
||
if (blockId) {
|
||
// 解锁思考块
|
||
this.chatSetThinkingLock(blockId, false);
|
||
|
||
// 只在非历史恢复时延迟折叠思考块
|
||
if (!this._rebuildingFromScratch) {
|
||
// 延迟折叠思考块（给用户一点时间看到思考完成）
|
||
setTimeout(() => {
|
||
this.chatCollapseBlock(blockId);
|
||
this.$forceUpdate();
|
||
}, 1000);
|
||
} else {
|
||
// 历史恢复时立即折叠，不需要动画
|
||
this.chatCollapseBlock(blockId);
|
||
}
|
||
|
||
this.$nextTick(() => this.scrollThinkingToBottom(blockId));
|
||
}
|
||
this.$forceUpdate();
|
||
this.monitorEndModelOutput();
|
||
},
|
||
|
||
handleTextStart() {
|
||
console.log('[TextStart] 开始处理');
|
||
debugLog('[TaskPolling] 文本开始');
|
||
|
||
// 防御性检查：如果没有assistant消息，先创建一个
|
||
const lastMessage = this.messages[this.messages.length - 1];
|
||
if (!lastMessage || lastMessage.role !== 'assistant') {
|
||
console.log('[DEBUG_AWAITING] TextStart 检测到缺少assistant消息，自动创建');
|
||
this.chatStartAssistantMessage();
|
||
}
|
||
|
||
this.chatStartTextAction();
|
||
|
||
// 有内容了，关闭等待动画
|
||
const currentMessage = this.messages[this.messages.length - 1];
|
||
if (currentMessage && currentMessage.role === 'assistant') {
|
||
console.log('[TextStart] 关闭等待动画', {
|
||
beforeAwaitingFirstContent: currentMessage.awaitingFirstContent,
|
||
beforeGeneratingLabel: currentMessage.generatingLabel
|
||
});
|
||
currentMessage.awaitingFirstContent = false;
|
||
currentMessage.generatingLabel = '';
|
||
}
|
||
|
||
this.$forceUpdate();
|
||
},
|
||
|
||
handleTextChunk(data: any) {
|
||
if (data && typeof data.content === 'string' && data.content.length) {
|
||
let textAction = this.chatAppendTextChunk(data.content);
|
||
// 兜底：刷新恢复时可能只有 text_chunk（缺少 text_start），需要自动补建 text action
|
||
if (!textAction) {
|
||
this.chatStartTextAction();
|
||
textAction = this.chatAppendTextChunk(data.content);
|
||
restoreDebugLog('restore:text-chunk-auto-start', {
|
||
contentLength: data.content.length,
|
||
appendedAfterStart: !!textAction,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
}
|
||
this.$forceUpdate();
|
||
this.conditionalScrollToBottom();
|
||
const speech = data.content.replace(/\r/g, '');
|
||
if (speech) {
|
||
this.monitorShowSpeech(speech);
|
||
}
|
||
}
|
||
},
|
||
|
||
handleTextEnd(data: any) {
|
||
debugLog('[TaskPolling] 文本结束');
|
||
const full = data?.full_content || '';
|
||
this.chatCompleteTextAction(full);
|
||
this.$forceUpdate();
|
||
this.monitorEndModelOutput();
|
||
},
|
||
|
||
handleToolPreparing(data: any) {
|
||
console.log('[ToolPreparing] 开始处理', { name: data.name, id: data.id });
|
||
debugLog('[TaskPolling] 工具准备中:', data.name);
|
||
|
||
if (this.dropToolEvents) {
|
||
console.log('[ToolPreparing] dropToolEvents=true，跳过');
|
||
return;
|
||
}
|
||
|
||
const msg = this.chatEnsureAssistantMessage();
|
||
if (!msg) {
|
||
console.log('[ToolPreparing] 无法获取assistant消息');
|
||
return;
|
||
}
|
||
|
||
if (msg.awaitingFirstContent) {
|
||
console.log('[ToolPreparing] 关闭等待动画', {
|
||
beforeAwaitingFirstContent: msg.awaitingFirstContent,
|
||
beforeGeneratingLabel: msg.generatingLabel
|
||
});
|
||
msg.awaitingFirstContent = false;
|
||
msg.generatingLabel = '';
|
||
}
|
||
|
||
const action = {
|
||
id: data.id,
|
||
type: 'tool',
|
||
tool: {
|
||
id: data.id,
|
||
name: data.name,
|
||
arguments: {},
|
||
argumentSnapshot: null,
|
||
argumentLabel: '',
|
||
status: 'preparing',
|
||
result: null,
|
||
message: data.message || `准备调用 ${data.name}...`,
|
||
intent_full: data.intent || '',
|
||
intent_rendered: data.intent || ''
|
||
},
|
||
timestamp: Date.now()
|
||
};
|
||
|
||
msg.actions.push(action);
|
||
this.preparingTools.set(data.id, action);
|
||
this.toolRegisterAction(action, data.id);
|
||
this.toolTrackAction(data.name, action);
|
||
|
||
this.$forceUpdate();
|
||
this.conditionalScrollToBottom();
|
||
|
||
if (this.monitorPreviewTool) {
|
||
this.monitorPreviewTool(data);
|
||
}
|
||
},
|
||
|
||
handleToolStart(data: any) {
|
||
debugLog('[TaskPolling] 工具开始:', data.name);
|
||
|
||
if (this.dropToolEvents) {
|
||
return;
|
||
}
|
||
|
||
let action = null;
|
||
if (data.preparing_id && this.preparingTools.has(data.preparing_id)) {
|
||
action = this.preparingTools.get(data.preparing_id);
|
||
this.preparingTools.delete(data.preparing_id);
|
||
} else {
|
||
action = this.toolFindAction(data.id, data.preparing_id, data.execution_id);
|
||
}
|
||
|
||
if (!action) {
|
||
const msg = this.chatEnsureAssistantMessage();
|
||
if (!msg) {
|
||
return;
|
||
}
|
||
action = {
|
||
id: data.id,
|
||
type: 'tool',
|
||
tool: {
|
||
id: data.id,
|
||
name: data.name,
|
||
arguments: {},
|
||
argumentSnapshot: null,
|
||
argumentLabel: '',
|
||
status: 'running',
|
||
result: null
|
||
},
|
||
timestamp: Date.now()
|
||
};
|
||
msg.actions.push(action);
|
||
}
|
||
|
||
action.tool.status = 'running';
|
||
action.tool.arguments = data.arguments;
|
||
action.tool.argumentSnapshot = this.cloneToolArguments(data.arguments);
|
||
action.tool.argumentLabel = this.buildToolLabel(action.tool.argumentSnapshot);
|
||
action.tool.message = null;
|
||
action.tool.id = data.id;
|
||
action.tool.executionId = data.id;
|
||
|
||
this.toolRegisterAction(action, data.id);
|
||
this.toolTrackAction(data.name, action);
|
||
this.$forceUpdate();
|
||
this.conditionalScrollToBottom();
|
||
|
||
if (this.monitorQueueTool) {
|
||
this.monitorQueueTool(data);
|
||
}
|
||
},
|
||
|
||
handleToolIntent(data: any) {
|
||
debugLog('[TaskPolling] 工具意图:', data.name, data.intent);
|
||
|
||
if (this.dropToolEvents) {
|
||
return;
|
||
}
|
||
|
||
// 查找对应的工具 action
|
||
const action = this.toolFindAction(data.id, data.preparing_id, data.execution_id);
|
||
|
||
if (action && action.tool) {
|
||
const newIntent = data.intent || '';
|
||
|
||
// 如果 intent 没有变化，跳过
|
||
if (action.tool.intent_full === newIntent) {
|
||
return;
|
||
}
|
||
|
||
// 停止之前的打字机效果
|
||
if (action.tool._intentTyping) {
|
||
action.tool._intentTyping = false;
|
||
if (action.tool._intentTimer) {
|
||
clearTimeout(action.tool._intentTimer);
|
||
action.tool._intentTimer = null;
|
||
}
|
||
}
|
||
|
||
// 更新完整 intent
|
||
action.tool.intent_full = newIntent;
|
||
|
||
// 判断是否是历史恢复：只有从头重建时才直接显示
|
||
const isHistoryRestore = this._rebuildingFromScratch;
|
||
|
||
if (isHistoryRestore) {
|
||
// 历史恢复，直接显示完整 intent
|
||
action.tool.intent_rendered = newIntent;
|
||
debugLog('[TaskPolling] 历史恢复，直接显示 intent');
|
||
} else {
|
||
// 新工具块，逐字符显示
|
||
debugLog('[TaskPolling] 新工具块，开始打字机效果');
|
||
action.tool.intent_rendered = '';
|
||
action.tool._intentTyping = true;
|
||
|
||
// 计算每个字符的间隔时间
|
||
// 总时长1秒，但最少0.5秒
|
||
const totalDuration = Math.max(500, Math.min(1000, newIntent.length * 50));
|
||
const charInterval = totalDuration / newIntent.length;
|
||
|
||
let charIndex = 0;
|
||
const typeNextChar = () => {
|
||
if (charIndex < newIntent.length && action.tool._intentTyping) {
|
||
action.tool.intent_rendered += newIntent[charIndex];
|
||
charIndex++;
|
||
this.$forceUpdate();
|
||
action.tool._intentTimer = setTimeout(typeNextChar, charInterval);
|
||
} else {
|
||
action.tool._intentTyping = false;
|
||
action.tool.intent_rendered = newIntent; // 确保完整
|
||
action.tool._intentTimer = null;
|
||
this.$forceUpdate();
|
||
}
|
||
};
|
||
|
||
action.tool._intentTimer = setTimeout(typeNextChar, 50); // 延迟50ms开始
|
||
}
|
||
|
||
// 更新 arguments 和 label
|
||
if (action.tool.arguments) {
|
||
action.tool.arguments.intent = newIntent;
|
||
action.tool.argumentSnapshot = this.cloneToolArguments(action.tool.arguments);
|
||
action.tool.argumentLabel = this.buildToolLabel(action.tool.argumentSnapshot);
|
||
}
|
||
|
||
this.$forceUpdate();
|
||
debugLog('[TaskPolling] 已更新工具意图:', data.name);
|
||
} else {
|
||
debugLog('[TaskPolling] 未找到对应的工具 action:', data.id);
|
||
}
|
||
},
|
||
|
||
handleToolUpdateAction(data: any) {
|
||
if (this.dropToolEvents) {
|
||
return;
|
||
}
|
||
|
||
debugLog('[TaskPolling] 更新action:', data.id, 'status:', data.status);
|
||
|
||
let targetAction = this.toolFindAction(data.id, data.preparing_id, data.execution_id);
|
||
if (!targetAction && data.preparing_id && this.preparingTools.has(data.preparing_id)) {
|
||
targetAction = this.preparingTools.get(data.preparing_id);
|
||
}
|
||
|
||
if (!targetAction) {
|
||
return;
|
||
}
|
||
|
||
if (data.status) {
|
||
targetAction.tool.status = data.status;
|
||
}
|
||
if (data.result !== undefined) {
|
||
targetAction.tool.result = data.result;
|
||
|
||
// 处理个性化设置工具 - 刷新个人空间数据
|
||
if (targetAction.tool && targetAction.tool.name === 'manage_personalization') {
|
||
let result = data.result;
|
||
if (typeof result === 'string') {
|
||
try {
|
||
result = JSON.parse(result);
|
||
} catch (e) {
|
||
/* ignore */
|
||
}
|
||
}
|
||
// 处理主题变更
|
||
if (result?.theme_changed === true && result.new_theme) {
|
||
const theme = result.new_theme;
|
||
if (typeof window !== 'undefined' && window.localStorage) {
|
||
window.localStorage.setItem('agents_ui_theme', theme);
|
||
}
|
||
document.documentElement.setAttribute('data-theme', theme);
|
||
document.body.setAttribute('data-theme', theme);
|
||
}
|
||
// 任何字段更新后都刷新个人空间数据
|
||
(async () => {
|
||
try {
|
||
const { usePersonalizationStore } = await import('../../stores/personalization');
|
||
const personalizationStore = usePersonalizationStore();
|
||
// 强制刷新个人空间数据
|
||
await personalizationStore.fetchPersonalization();
|
||
} catch (e) {
|
||
// 静默处理，不影响主流程
|
||
console.debug('[TaskPolling] 刷新个人空间数据失败:', e);
|
||
}
|
||
})();
|
||
}
|
||
}
|
||
if (data.message !== undefined) {
|
||
targetAction.tool.message = data.message;
|
||
}
|
||
if (data.content !== undefined) {
|
||
targetAction.tool.content = data.content;
|
||
}
|
||
|
||
// 待办工具执行完成后主动刷新左侧待办列表（网页端不再依赖 websocket todo_updated）
|
||
if (data.status === 'completed') {
|
||
const toolName = String(targetAction?.tool?.name || '').toLowerCase();
|
||
if (
|
||
toolName.startsWith('todo_') ||
|
||
toolName === 'todo_create' ||
|
||
toolName === 'todo_update_task'
|
||
) {
|
||
this.scheduleTodoListRefresh(80);
|
||
}
|
||
}
|
||
|
||
this.$forceUpdate();
|
||
this.conditionalScrollToBottom();
|
||
|
||
if (this.monitorResolveTool && data.status === 'completed') {
|
||
this.monitorResolveTool(data);
|
||
}
|
||
},
|
||
|
||
handleToolApprovalRequired(data: any) {
|
||
const approval = data?.approval;
|
||
if (!approval || !approval.approval_id) {
|
||
return;
|
||
}
|
||
if (!Array.isArray(this.pendingToolApprovals)) {
|
||
this.pendingToolApprovals = [];
|
||
}
|
||
const idx = this.pendingToolApprovals.findIndex(
|
||
(item: any) => item && item.approval_id === approval.approval_id
|
||
);
|
||
if (idx >= 0) {
|
||
this.pendingToolApprovals.splice(idx, 1, approval);
|
||
} else {
|
||
this.pendingToolApprovals.push(approval);
|
||
}
|
||
this.rightCollapsed = false;
|
||
if (this.rightWidth < this.minPanelWidth) {
|
||
this.rightWidth = this.minPanelWidth;
|
||
}
|
||
if (this.isMobileViewport && this.activeMobileOverlay !== 'approval') {
|
||
this.openMobileOverlay('approval');
|
||
}
|
||
this.$forceUpdate();
|
||
},
|
||
|
||
handleToolApprovalResolved(data: any) {
|
||
const approvalId = data?.approval_id;
|
||
if (!approvalId || !Array.isArray(this.pendingToolApprovals)) {
|
||
return;
|
||
}
|
||
this.pendingToolApprovals = this.pendingToolApprovals.filter(
|
||
(item: any) => item && item.approval_id !== approvalId
|
||
);
|
||
// 电脑端：审批完成后自动折叠面板
|
||
if (!this.pendingToolApprovals.length && !this.isMobileViewport) {
|
||
this.rightCollapsed = true;
|
||
}
|
||
this.$forceUpdate();
|
||
},
|
||
|
||
handleAppendPayload(data: any) {
|
||
debugLog('[TaskPolling] 文件追加:', data.path);
|
||
this.chatAddAppendPayloadAction(data);
|
||
this.$forceUpdate();
|
||
this.conditionalScrollToBottom();
|
||
},
|
||
|
||
handleModifyPayload(data: any) {
|
||
debugLog('[TaskPolling] 文件修改:', data.path);
|
||
this.chatAddModifyPayloadAction(data);
|
||
this.$forceUpdate();
|
||
this.conditionalScrollToBottom();
|
||
},
|
||
|
||
markLatestUserWorkCompleted() {
|
||
if (!Array.isArray(this.messages) || this.messages.length === 0) {
|
||
return;
|
||
}
|
||
for (let i = this.messages.length - 1; i >= 0; i -= 1) {
|
||
const msg = this.messages[i];
|
||
if (!msg || msg.role !== 'user') {
|
||
continue;
|
||
}
|
||
msg.metadata = msg.metadata || {};
|
||
msg.metadata.work_timer = msg.metadata.work_timer || {};
|
||
const timer = msg.metadata.work_timer;
|
||
if (timer.status === 'completed' && typeof timer.duration_ms === 'number') {
|
||
return;
|
||
}
|
||
const nowIso = new Date().toISOString();
|
||
const startedAt = timer.started_at || msg.timestamp || nowIso;
|
||
const startMs = Date.parse(startedAt);
|
||
const endMs = Date.now();
|
||
const durationMs = Number.isFinite(startMs) ? Math.max(0, endMs - startMs) : 0;
|
||
timer.status = 'completed';
|
||
timer.started_at = startedAt;
|
||
timer.finished_at = nowIso;
|
||
timer.duration_ms = durationMs;
|
||
return;
|
||
}
|
||
},
|
||
|
||
handleTaskComplete(data: any) {
|
||
const pendingToolsBefore =
|
||
typeof this.hasPendingToolActions === 'function' ? this.hasPendingToolActions() : null;
|
||
jsonDebug('handleTaskComplete:before', {
|
||
data,
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested,
|
||
pendingToolsBefore,
|
||
preparingToolsSize: this.preparingTools?.size ?? null,
|
||
activeToolsSize: this.activeTools?.size ?? null,
|
||
waitingForSubAgent: this.waitingForSubAgent,
|
||
waitingForBackgroundCommand: this.waitingForBackgroundCommand
|
||
});
|
||
const hasRunningSubAgents = !!data?.has_running_sub_agents;
|
||
const hasRunningBackgroundCommands = !!data?.has_running_background_commands;
|
||
if (hasRunningSubAgents) {
|
||
debugLog('[TaskPolling] 任务完成，但仍有后台子智能体运行');
|
||
} else {
|
||
debugLog('[TaskPolling] 任务完成');
|
||
}
|
||
|
||
// 同步处理状态更新
|
||
this.streamingMessage = false;
|
||
this.stopRequested = false;
|
||
if (!hasRunningSubAgents) {
|
||
this.markLatestUserWorkCompleted();
|
||
}
|
||
|
||
if (hasRunningSubAgents) {
|
||
this.taskInProgress = true;
|
||
this.waitingForSubAgent = true;
|
||
this.waitingForBackgroundCommand = hasRunningBackgroundCommands;
|
||
// 关键修复：主任务结束后将切到新的通知任务，先清空旧任务事件索引去重表。
|
||
this.clearProcessedEvents();
|
||
this.startWaitingTaskProbe();
|
||
} else {
|
||
this.cleanupTrailingEmptyAssistantPlaceholder('task_complete');
|
||
// 主任务已结束：若有遗留工具块处于 running/preparing，会导致发送按钮继续显示“停止”。
|
||
// 这里统一清理遗留中的工具状态，避免前端忙碌态卡死。
|
||
if (typeof this.clearPendingTools === 'function') {
|
||
this.clearPendingTools('task_complete');
|
||
}
|
||
this.taskInProgress = false;
|
||
this.waitingForSubAgent = false;
|
||
this.waitingForBackgroundCommand = false;
|
||
this.stopWaitingTaskProbe();
|
||
this.clearTaskState(); // 清理任务状态
|
||
}
|
||
|
||
this.$forceUpdate();
|
||
|
||
// 只更新统计，不重新加载历史
|
||
if (this.currentConversationId) {
|
||
setTimeout(() => {
|
||
this.fetchConversationTokenStatistics();
|
||
this.updateCurrentContextTokens();
|
||
}, 500);
|
||
}
|
||
this.scheduleTodoListRefresh(100);
|
||
const pendingToolsAfter =
|
||
typeof this.hasPendingToolActions === 'function' ? this.hasPendingToolActions() : null;
|
||
jsonDebug('handleTaskComplete:after', {
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested,
|
||
pendingToolsAfter,
|
||
preparingToolsSize: this.preparingTools?.size ?? null,
|
||
activeToolsSize: this.activeTools?.size ?? null,
|
||
waitingForSubAgent: this.waitingForSubAgent,
|
||
waitingForBackgroundCommand: this.waitingForBackgroundCommand
|
||
});
|
||
},
|
||
|
||
handleTaskStopped(data: any, eventIdx: number) {
|
||
jsonDebug('handleTaskStopped:before', {
|
||
eventIdx,
|
||
data,
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested
|
||
});
|
||
debugLog('[TaskPolling] 任务已停止, idx:', eventIdx, data);
|
||
|
||
this.markLatestUserWorkCompleted();
|
||
this.cleanupTrailingEmptyAssistantPlaceholder('task_stopped');
|
||
this.streamingMessage = false;
|
||
this.taskInProgress = false;
|
||
this.stopRequested = false;
|
||
this.waitingForSubAgent = false;
|
||
this.waitingForBackgroundCommand = false;
|
||
this.stopWaitingTaskProbe();
|
||
|
||
if (typeof this.clearPendingTools === 'function') {
|
||
this.clearPendingTools('task_stopped');
|
||
}
|
||
this.scheduleTodoListRefresh(100);
|
||
this.$forceUpdate();
|
||
|
||
this.clearTaskState();
|
||
jsonDebug('handleTaskStopped:after', {
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested
|
||
});
|
||
},
|
||
|
||
// 新增统一清理方法
|
||
clearTaskState() {
|
||
this.stopWaitingTaskProbe();
|
||
(async () => {
|
||
const { useTaskStore } = await import('../../stores/task');
|
||
const taskStore = useTaskStore();
|
||
taskStore.clearTask(); // 使用 clearTask 而不是 stopPolling
|
||
})();
|
||
|
||
if (typeof this.clearProcessedEvents === 'function') {
|
||
this.clearProcessedEvents();
|
||
}
|
||
},
|
||
|
||
handleUserMessage(data: any) {
|
||
const message = (data?.message || data?.content || '').trim();
|
||
if (!message) {
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] handleUserMessage:empty', { data });
|
||
return;
|
||
}
|
||
debugLog('[TaskPolling] 收到用户消息事件');
|
||
debugNotifyLog('[DEBUG_NOTIFY][ui] handleUserMessage', {
|
||
messagePreview: message.slice(0, 120),
|
||
sub_agent_notice: !!data?.sub_agent_notice,
|
||
background_command_notice: !!data?.background_command_notice,
|
||
task_id: data?.task_id,
|
||
has_running_sub_agents: data?.has_running_sub_agents,
|
||
has_running_background_commands: data?.has_running_background_commands
|
||
});
|
||
keyNotifyLog('[DEBUG_NOTIFY_KEY][ui] handleUserMessage', {
|
||
messagePreview: message.slice(0, 80),
|
||
task_id: data?.task_id,
|
||
sub_agent_notice: !!data?.sub_agent_notice,
|
||
background_command_notice: !!data?.background_command_notice
|
||
});
|
||
const isAutoUserMessage = isSystemAutoUserMessagePayload(data);
|
||
if (!isAutoUserMessage) {
|
||
const incomingImages = Array.isArray(data?.images) ? data.images : [];
|
||
const incomingVideos = Array.isArray(data?.videos) ? data.videos : [];
|
||
const incomingMediaRefs = Array.isArray(data?.media_refs)
|
||
? data.media_refs
|
||
: Array.isArray(data?.mediaRefs)
|
||
? data.mediaRefs
|
||
: [];
|
||
const last = getOptimisticUserEchoTarget(this.messages || []);
|
||
const isLikelyOptimisticEcho = !!(
|
||
last &&
|
||
last.role === 'user' &&
|
||
String(last.content || '').trim() === message &&
|
||
JSON.stringify(last.images || []) === JSON.stringify(incomingImages || []) &&
|
||
JSON.stringify(last.videos || []) === JSON.stringify(incomingVideos || [])
|
||
);
|
||
if (isLikelyOptimisticEcho) {
|
||
last.media_refs = incomingMediaRefs;
|
||
last.metadata = {
|
||
...(last.metadata || {}),
|
||
media_refs: incomingMediaRefs
|
||
};
|
||
} else {
|
||
this.chatAddUserMessage(message, incomingImages, incomingVideos, incomingMediaRefs);
|
||
}
|
||
this.taskInProgress = true;
|
||
this.streamingMessage = false;
|
||
this.stopRequested = false;
|
||
} else {
|
||
debugLog('[TaskPolling] 跳过自动代发 user_message 渲染', {
|
||
messagePreview: message.slice(0, 80),
|
||
data
|
||
});
|
||
}
|
||
if (data?.sub_agent_notice) {
|
||
if (typeof data?.has_running_sub_agents === 'boolean') {
|
||
this.waitingForSubAgent = data.has_running_sub_agents;
|
||
} else if (typeof data?.remaining_count === 'number') {
|
||
this.waitingForSubAgent = data.remaining_count > 0;
|
||
}
|
||
if (typeof data?.has_running_background_commands === 'boolean') {
|
||
this.waitingForBackgroundCommand = data.has_running_background_commands;
|
||
} else if (data?.background_command_notice) {
|
||
this.waitingForBackgroundCommand = this.waitingForSubAgent;
|
||
}
|
||
if (this.waitingForSubAgent) {
|
||
this.startWaitingTaskProbe();
|
||
} else {
|
||
this.stopWaitingTaskProbe();
|
||
}
|
||
}
|
||
this.$forceUpdate();
|
||
this.conditionalScrollToBottom();
|
||
},
|
||
|
||
handleSystemMessage(data: any) {
|
||
const content = (data?.content || data?.message || '').trim();
|
||
userMDebug('taskPolling.handleSystemMessage:incoming', {
|
||
raw: data,
|
||
normalizedContent: content,
|
||
currentConversationId: this.currentConversationId,
|
||
currentMessagesLength: Array.isArray(this.messages) ? this.messages.length : -1
|
||
});
|
||
if (!content) {
|
||
userMDebug('taskPolling.handleSystemMessage:empty-skip');
|
||
return;
|
||
}
|
||
this.cleanupTrailingEmptyAssistantPlaceholder('before_system_message_append');
|
||
this.appendSystemAction(content);
|
||
userMDebug('taskPolling.handleSystemMessage:after-append', {
|
||
currentMessagesLength: Array.isArray(this.messages) ? this.messages.length : -1,
|
||
lastRole: this.messages?.[this.messages.length - 1]?.role || null,
|
||
lastActions:
|
||
this.messages?.[this.messages.length - 1]?.actions?.map((a: any) => a?.type) || []
|
||
});
|
||
},
|
||
|
||
handleTaskError(data: any) {
|
||
jsonDebug('handleTaskError:incoming', {
|
||
data,
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested
|
||
});
|
||
const shouldRetry = Boolean(data?.retry);
|
||
if (shouldRetry) {
|
||
const retryIn = Number(data?.retry_in) || 5;
|
||
const attempt = Number(data?.attempt) || 1;
|
||
const maxAttempts = Number(data?.max_attempts) || attempt;
|
||
|
||
debugLog('[TaskPolling] API错误，等待自动重试', {
|
||
retryIn,
|
||
attempt,
|
||
maxAttempts,
|
||
message: data?.message
|
||
});
|
||
|
||
this.stopRequested = false;
|
||
this.taskInProgress = true;
|
||
this.streamingMessage = true;
|
||
this.$forceUpdate();
|
||
|
||
this.uiPushToast({
|
||
title: '即将重试',
|
||
message: `将在 ${retryIn} 秒后重试（第 ${attempt}/${maxAttempts} 次）`,
|
||
type: 'info',
|
||
duration: Math.max(retryIn, 1) * 1000
|
||
});
|
||
return;
|
||
}
|
||
|
||
const errorMessage = data.message || '未知错误';
|
||
const errorType = data.error_type || 'unknown';
|
||
const isToolArgumentParseError =
|
||
errorType === 'parameter_format_error' || /工具参数解析失败/.test(String(errorMessage || ''));
|
||
|
||
// 工具参数解析失败属于“单个工具调用失败”，后端会继续执行主任务。
|
||
// 这里不能停止轮询，否则会出现“后端继续跑、前端不再更新”的假死状态。
|
||
if (isToolArgumentParseError) {
|
||
console.warn('[TaskPolling] 工具参数解析失败（非致命），继续轮询任务:', data);
|
||
jsonDebug('handleTaskError:tool-args-parse-error-ignored', {
|
||
errorType,
|
||
errorMessage,
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested
|
||
});
|
||
this.uiPushToast({
|
||
title: '工具调用失败',
|
||
message: errorMessage,
|
||
type: 'warning',
|
||
duration: 6000
|
||
});
|
||
// 保持当前运行态，不在这里强制置为“工作中”，避免后续任务结束时状态粘住
|
||
this.stopRequested = false;
|
||
this.$forceUpdate();
|
||
return;
|
||
}
|
||
|
||
let title = '任务执行失败';
|
||
let message = errorMessage;
|
||
|
||
// 根据错误类型提供友好提示
|
||
if (errorType === 'api_error') {
|
||
title = 'API 调用失败';
|
||
message = `模型服务异常：${errorMessage}`;
|
||
} else if (errorType === 'timeout') {
|
||
title = '任务超时';
|
||
message = '任务执行时间过长，已自动停止';
|
||
} else if (errorType === 'quota_exceeded') {
|
||
title = '配额不足';
|
||
message = '您的使用配额已用尽';
|
||
}
|
||
|
||
console.error('[TaskPolling] 任务错误:', data.message);
|
||
this.uiPushToast({
|
||
title,
|
||
message,
|
||
type: 'error',
|
||
duration: 8000
|
||
});
|
||
|
||
// 清理状态
|
||
this.markLatestUserWorkCompleted();
|
||
this.streamingMessage = false;
|
||
this.taskInProgress = false;
|
||
this.stopRequested = false;
|
||
this.$forceUpdate();
|
||
jsonDebug('handleTaskError:fatal-after-state-update', {
|
||
errorType,
|
||
errorMessage,
|
||
taskInProgress: this.taskInProgress,
|
||
streamingMessage: this.streamingMessage,
|
||
stopRequested: this.stopRequested
|
||
});
|
||
|
||
// 停止轮询
|
||
(async () => {
|
||
const { useTaskStore } = await import('../../stores/task');
|
||
const taskStore = useTaskStore();
|
||
taskStore.stopPolling();
|
||
})();
|
||
},
|
||
|
||
handleTokenUpdate(data: any) {
|
||
if (data.conversation_id === this.currentConversationId) {
|
||
this.currentConversationTokens.cumulative_input_tokens = data.cumulative_input_tokens || 0;
|
||
this.currentConversationTokens.cumulative_output_tokens = data.cumulative_output_tokens || 0;
|
||
this.currentConversationTokens.cumulative_total_tokens = data.cumulative_total_tokens || 0;
|
||
|
||
if (typeof data.current_context_tokens === 'number') {
|
||
this.resourceSetCurrentContextTokens(data.current_context_tokens);
|
||
} else {
|
||
this.updateCurrentContextTokens();
|
||
}
|
||
|
||
this.$forceUpdate();
|
||
}
|
||
},
|
||
|
||
handleConversationChanged(data: any, eventIdx: number) {
|
||
debugLog('[TaskPolling] 对话标题已更新, idx:', eventIdx, data);
|
||
|
||
if (data && data.conversation_id === this.currentConversationId) {
|
||
// 更新当前对话标题
|
||
if (data.title) {
|
||
this.currentConversationTitle = data.title;
|
||
debugLog('[TaskPolling] 更新当前对话标题:', data.title);
|
||
}
|
||
|
||
// 更新对话列表中的标题
|
||
if (data.title && Array.isArray(this.conversations)) {
|
||
const conv = this.conversations.find((c) => c && c.id === data.conversation_id);
|
||
if (conv) {
|
||
conv.title = data.title;
|
||
debugLog('[TaskPolling] 更新对话列表中的标题:', data.title);
|
||
}
|
||
}
|
||
|
||
this.$forceUpdate();
|
||
}
|
||
},
|
||
|
||
handleConversationResolved(data: any) {
|
||
if (data && data.conversation_id) {
|
||
this.currentConversationId = data.conversation_id;
|
||
if (data.title) {
|
||
this.currentConversationTitle = data.title;
|
||
}
|
||
this.promoteConversationToTop(data.conversation_id);
|
||
|
||
const pathFragment = this.stripConversationPrefix(data.conversation_id);
|
||
const currentPath = window.location.pathname.replace(/^\/+/, '');
|
||
if (data.created) {
|
||
history.pushState({ conversationId: data.conversation_id }, '', `/${pathFragment}`);
|
||
} else if (currentPath !== pathFragment) {
|
||
history.replaceState({ conversationId: data.conversation_id }, '', `/${pathFragment}`);
|
||
}
|
||
}
|
||
},
|
||
|
||
handleCompressionState(data: any) {
|
||
if (!data || typeof data !== 'object') {
|
||
return;
|
||
}
|
||
const wasInProgress = !!this.compressionInProgress;
|
||
this.compressionInProgress = !!data.in_progress;
|
||
this.compressionMode = data.mode || '';
|
||
this.compressionStage = data.stage || '';
|
||
if (this.compressionInProgress && !wasInProgress) {
|
||
const modeLabel = this.compressionMode === 'manual' ? '手动' : '自动';
|
||
if (this.compressionToastId) {
|
||
this.uiDismissToast(this.compressionToastId);
|
||
this.compressionToastId = null;
|
||
}
|
||
this.compressionToastId = this.uiPushToast({
|
||
title: '压缩中',
|
||
message: `对话正在${modeLabel}压缩，请稍候…`,
|
||
type: 'info',
|
||
duration: null,
|
||
closable: false
|
||
});
|
||
}
|
||
if (!this.compressionInProgress) {
|
||
this.compressionError = data.error || '';
|
||
if (this.compressionToastId) {
|
||
this.uiDismissToast(this.compressionToastId);
|
||
this.compressionToastId = null;
|
||
}
|
||
}
|
||
},
|
||
|
||
async handleCompressionFinished(data: any) {
|
||
if (this.compressionToastId) {
|
||
this.uiDismissToast(this.compressionToastId);
|
||
this.compressionToastId = null;
|
||
}
|
||
this.compressionInProgress = false;
|
||
this.compressionMode = '';
|
||
this.compressionStage = '';
|
||
this.compressionError = '';
|
||
const newId = data?.conversation_id;
|
||
if (newId && newId !== this.currentConversationId) {
|
||
await this.loadConversation(newId, { force: true });
|
||
}
|
||
this.conversationsOffset = 0;
|
||
if (typeof this.loadConversationsList === 'function') {
|
||
await this.loadConversationsList();
|
||
}
|
||
this.uiPushToast({
|
||
title: '压缩完成',
|
||
message: '已自动切换到压缩后的新对话',
|
||
type: 'success',
|
||
duration: 2400
|
||
});
|
||
},
|
||
|
||
handleShallowCompression(data: any, eventIdx?: number) {
|
||
const count = Number(data?.compressed_count || 0);
|
||
if (count <= 0) {
|
||
return;
|
||
}
|
||
debugLog('[TaskPolling] 自动浅层压缩触发, idx:', eventIdx, data);
|
||
this.uiPushToast({
|
||
title: '自动浅层压缩',
|
||
message: `已自动压缩 ${count} 条较早工具结果`,
|
||
type: 'info',
|
||
duration: 2500
|
||
});
|
||
},
|
||
|
||
/**
|
||
* 清理已处理的事件索引
|
||
*/
|
||
clearProcessedEvents() {
|
||
if (this._processedEventIndices) {
|
||
this._processedEventIndices.clear();
|
||
}
|
||
},
|
||
|
||
/**
|
||
* 恢复任务状态（页面刷新后调用）
|
||
*/
|
||
async restoreTaskState() {
|
||
// 清理已处理的事件索引
|
||
this.clearProcessedEvents();
|
||
restoreDebugLog('restore:start', {
|
||
currentConversationId: this.currentConversationId,
|
||
streamingMessage: this.streamingMessage,
|
||
taskInProgress: this.taskInProgress,
|
||
historyLoading: this.historyLoading,
|
||
historyLoadingFor: this.historyLoadingFor,
|
||
messagesLen: Array.isArray(this.messages) ? this.messages.length : -1
|
||
});
|
||
|
||
try {
|
||
const { useTaskStore } = await import('../../stores/task');
|
||
const taskStore = useTaskStore();
|
||
|
||
// 如果已经在流式输出中，不重复恢复
|
||
if (this.streamingMessage || this.taskInProgress) {
|
||
restoreDebugLog('restore:skip-already-running', {
|
||
streamingMessage: this.streamingMessage,
|
||
taskInProgress: this.taskInProgress,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
debugLog('[TaskPolling] 任务已在进行中，跳过恢复', {
|
||
streamingMessage: this.streamingMessage,
|
||
taskInProgress: this.taskInProgress,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 查找运行中的任务
|
||
const runningTask = await taskStore.loadRunningTask(this.currentConversationId);
|
||
|
||
if (!runningTask) {
|
||
restoreDebugLog('restore:no-running-task', {
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
debugLog('[TaskPolling] 没有运行中的任务', {
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
this._restoreTaskStateWaitCount = 0;
|
||
await this.restoreSubAgentWaitingState();
|
||
return;
|
||
}
|
||
|
||
debugLog('[TaskPolling] 发现运行中的任务，开始恢复状态', {
|
||
taskId: runningTask?.task_id,
|
||
status: runningTask?.status,
|
||
conversationId: runningTask?.conversation_id
|
||
});
|
||
restoreDebugLog('restore:running-task-found', {
|
||
taskId: runningTask?.task_id,
|
||
status: runningTask?.status,
|
||
taskConversationId: runningTask?.conversation_id,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
|
||
// 检查历史是否已加载
|
||
const hasMessages = Array.isArray(this.messages) && this.messages.length > 0;
|
||
const historyLoadingSameConversation =
|
||
!!this.historyLoading && this.historyLoadingFor === this.currentConversationId;
|
||
|
||
if (!hasMessages) {
|
||
this._restoreTaskStateWaitCount = (this._restoreTaskStateWaitCount || 0) + 1;
|
||
const waitedTooLong = this._restoreTaskStateWaitCount >= 8; // ~4s
|
||
restoreDebugLog('restore:history-empty', {
|
||
waitCount: this._restoreTaskStateWaitCount,
|
||
waitedTooLong,
|
||
historyLoading: this.historyLoading,
|
||
historyLoadingFor: this.historyLoadingFor,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
if (historyLoadingSameConversation && !waitedTooLong) {
|
||
debugLog('[TaskPolling] 历史未加载，等待历史加载完成', {
|
||
waitCount: this._restoreTaskStateWaitCount,
|
||
historyLoading: this.historyLoading,
|
||
historyLoadingFor: this.historyLoadingFor
|
||
});
|
||
setTimeout(() => {
|
||
this.restoreTaskState();
|
||
}, 500);
|
||
return;
|
||
}
|
||
// 兜底：即使历史未成功拉取，也允许直接通过任务事件重放恢复界面，
|
||
// 避免 show_html 流式阶段刷新后“本次请求内容完全消失”。
|
||
debugLog('[TaskPolling] 历史为空，启用事件重放兜底恢复', {
|
||
waitCount: this._restoreTaskStateWaitCount,
|
||
historyLoading: this.historyLoading,
|
||
historyLoadingFor: this.historyLoadingFor
|
||
});
|
||
} else {
|
||
this._restoreTaskStateWaitCount = 0;
|
||
}
|
||
|
||
debugLog('[TaskPolling] 开始精细恢复', {
|
||
hasMessages,
|
||
historyLoading: this.historyLoading,
|
||
historyLoadingFor: this.historyLoadingFor
|
||
});
|
||
|
||
// 获取任务的所有事件
|
||
const detailResponse = await fetch(`/api/tasks/${taskStore.currentTaskId}`);
|
||
if (!detailResponse.ok) {
|
||
debugLog('[TaskPolling] 获取任务详情失败');
|
||
return;
|
||
}
|
||
|
||
const detailResult = await detailResponse.json();
|
||
if (!detailResult.success || !detailResult.data.events) {
|
||
restoreDebugLog('restore:task-detail-invalid', {
|
||
ok: !!detailResult?.success,
|
||
hasData: !!detailResult?.data,
|
||
hasEvents: !!detailResult?.data?.events
|
||
});
|
||
debugLog('[TaskPolling] 任务详情无效');
|
||
return;
|
||
}
|
||
|
||
const allEvents = detailResult.data.events;
|
||
debugLog(`[TaskPolling] 获取到 ${allEvents.length} 个事件`);
|
||
restoreDebugLog('restore:task-detail-events', {
|
||
total: allEvents.length,
|
||
firstIdx: allEvents[0]?.idx,
|
||
firstType: allEvents[0]?.type,
|
||
lastIdx: allEvents[allEvents.length - 1]?.idx,
|
||
lastType: allEvents[allEvents.length - 1]?.type
|
||
});
|
||
|
||
// 找到最后一条消息
|
||
const lastMessage = this.messages[this.messages.length - 1];
|
||
const isAssistantMessage = lastMessage && lastMessage.role === 'assistant';
|
||
|
||
// console.log('[TaskPolling] 最后一条消息:', {
|
||
// exists: !!lastMessage,
|
||
// role: lastMessage?.role,
|
||
// actionsCount: lastMessage?.actions?.length || 0,
|
||
// isAssistant: isAssistantMessage
|
||
// });
|
||
|
||
// 先分析事件状态（用于判定是否强制重建）
|
||
let inThinking = false;
|
||
let inText = false;
|
||
let hasTextChunkEvent = false;
|
||
|
||
for (let i = 0; i < allEvents.length; i++) {
|
||
const event = allEvents[i];
|
||
if (event.type === 'thinking_start') {
|
||
inThinking = true;
|
||
} else if (event.type === 'thinking_end') {
|
||
inThinking = false;
|
||
}
|
||
if (event.type === 'text_start') {
|
||
inText = true;
|
||
} else if (event.type === 'text_end') {
|
||
inText = false;
|
||
}
|
||
if (event.type === 'text_chunk') {
|
||
hasTextChunkEvent = true;
|
||
}
|
||
}
|
||
|
||
// 检查是否需要从头重建
|
||
// 1. 最后一条不是 assistant 消息
|
||
// 2. 最后一条是空的 assistant 消息
|
||
// 3. 事件数量远大于历史中的 actions 数量（说明历史不完整）
|
||
// 4. 任务正处于文本流式阶段（刷新时易丢分段内容，强制重放全部事件）
|
||
const historyActionsCount = lastMessage?.actions?.length || 0;
|
||
const eventCount = allEvents.length;
|
||
const historyIncomplete = eventCount > historyActionsCount + 5; // 允许5个事件的误差
|
||
const forceRebuildForStreamingText = inText || hasTextChunkEvent;
|
||
|
||
// 刷新恢复场景下，优先强制从头重放当前任务事件，避免“有运行中任务但界面无输出”
|
||
const forceRebuildOnRefresh = true;
|
||
|
||
const needsRebuild =
|
||
forceRebuildOnRefresh ||
|
||
!isAssistantMessage ||
|
||
(isAssistantMessage && (!lastMessage.actions || lastMessage.actions.length === 0)) ||
|
||
historyIncomplete ||
|
||
forceRebuildForStreamingText;
|
||
restoreDebugLog('restore:rebuild-decision', {
|
||
needsRebuild,
|
||
forceRebuildOnRefresh,
|
||
isAssistantMessage,
|
||
historyActionsCount,
|
||
eventCount,
|
||
historyIncomplete,
|
||
inText,
|
||
hasTextChunkEvent,
|
||
forceRebuildForStreamingText
|
||
});
|
||
|
||
if (needsRebuild) {
|
||
// if (historyIncomplete) {
|
||
// console.log('[TaskPolling] 历史不完整，从头重建:', {
|
||
// historyActionsCount,
|
||
// eventCount,
|
||
// diff: eventCount - historyActionsCount
|
||
// });
|
||
// }
|
||
debugLog('[TaskPolling] 需要从头重建 assistant 响应');
|
||
|
||
// 清空所有消息，准备从头重建
|
||
// 保留用户消息，只删除最后的 assistant 消息
|
||
if (isAssistantMessage) {
|
||
debugLog('[TaskPolling] 删除不完整的 assistant 消息');
|
||
this.messages.pop();
|
||
}
|
||
|
||
this.streamingMessage = true;
|
||
this.taskInProgress = true;
|
||
this.$forceUpdate();
|
||
|
||
// 重置偏移量为 0，从头获取所有事件来重建 assistant 消息
|
||
taskStore.lastEventIndex = 0;
|
||
debugLog('[TaskPolling] 重置偏移量为 0，从头开始轮询');
|
||
|
||
// 标记正在从头重建，用于后续处理
|
||
this._rebuildingFromScratch = true;
|
||
this._rebuildingEventCount = allEvents.length; // 记录当前事件总数
|
||
|
||
(window as any).__taskEventHandler = (event: any) => {
|
||
this.handleTaskEvent(event);
|
||
};
|
||
|
||
taskStore.startPolling((event: any) => {
|
||
this.handleTaskEvent(event);
|
||
});
|
||
restoreDebugLog('restore:rebuild-polling-started', {
|
||
lastEventIndex: taskStore.lastEventIndex,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
|
||
// 延迟清除重建标记，确保所有历史事件都处理完毕
|
||
setTimeout(() => {
|
||
debugLog('[TaskPolling] 历史事件处理完毕，清除重建标记');
|
||
this._rebuildingFromScratch = false;
|
||
this._rebuildingEventCount = 0;
|
||
}, 2000);
|
||
|
||
return;
|
||
}
|
||
|
||
// console.log('[TaskPolling] 分析结果:', {
|
||
// inThinking,
|
||
// inText,
|
||
// totalEvents: allEvents.length,
|
||
// lastEventType: allEvents[allEvents.length - 1]?.type,
|
||
// lastEventIdx: allEvents[allEvents.length - 1]?.idx
|
||
// });
|
||
|
||
// 恢复思考块状态
|
||
if (lastMessage.actions) {
|
||
// console.log('[TaskPolling] 历史中的 actions 详情:', lastMessage.actions.map((a, idx) => ({
|
||
// index: idx,
|
||
// type: a.type,
|
||
// id: a.id,
|
||
// hasContent: !!a.content,
|
||
// contentLength: a.content?.length || 0,
|
||
// toolName: a.tool?.name,
|
||
// hasBlockId: !!a.blockId,
|
||
// blockId: a.blockId,
|
||
// collapsed: a.collapsed,
|
||
// streaming: a.streaming
|
||
// })));
|
||
|
||
const thinkingActions = lastMessage.actions.filter((a) => a.type === 'thinking');
|
||
// console.log('[TaskPolling] 思考块数量:', thinkingActions.length);
|
||
|
||
if (inThinking && thinkingActions.length > 0) {
|
||
// 正在思考中，检查最后一个思考块是否正在流式输出
|
||
const lastThinking = thinkingActions[thinkingActions.length - 1];
|
||
|
||
// 只有当思考块正在流式输出时才设置锁定状态（但不展开）
|
||
if (lastThinking.streaming && lastThinking.blockId) {
|
||
// console.log('[TaskPolling] 找到正在流式输出的思考块，设置锁定状态:', lastThinking.blockId);
|
||
this.$nextTick(() => {
|
||
this.chatSetThinkingLock(lastThinking.blockId, true);
|
||
});
|
||
}
|
||
}
|
||
|
||
// 确保所有思考块都是折叠状态
|
||
for (const thinking of thinkingActions) {
|
||
if (thinking.blockId) {
|
||
thinking.collapsed = true;
|
||
}
|
||
}
|
||
|
||
// 检查思考块状态（在设置之后）（已禁用）
|
||
// thinkingActions.forEach((thinking, idx) => {
|
||
// console.log(`[TaskPolling] 思考块 ${idx} (设置后):`, {
|
||
// hasBlockId: !!thinking.blockId,
|
||
// blockId: thinking.blockId,
|
||
// collapsed: thinking.collapsed,
|
||
// contentLength: thinking.content?.length || 0
|
||
// });
|
||
// });
|
||
|
||
// 恢复文本块状态
|
||
const textActions = lastMessage.actions.filter((a) => a.type === 'text');
|
||
// console.log('[TaskPolling] 文本块数量:', textActions.length);
|
||
|
||
if (inText && textActions.length > 0) {
|
||
const lastText = textActions[textActions.length - 1];
|
||
// console.log('[TaskPolling] 标记文本块为流式状态');
|
||
lastText.streaming = true;
|
||
}
|
||
|
||
// 注册历史中的工具块到 toolActionIndex
|
||
// 这样后续的 update_action 事件可以找到对应的块进行状态更新
|
||
const toolActions = lastMessage.actions.filter((a) => a.type === 'tool');
|
||
// console.log('[TaskPolling] 工具块数量:', toolActions.length);
|
||
|
||
for (const toolAction of toolActions) {
|
||
if (toolAction.tool && toolAction.tool.id) {
|
||
// console.log('[TaskPolling] 注册工具块:', {
|
||
// id: toolAction.tool.id,
|
||
// name: toolAction.tool.name,
|
||
// status: toolAction.tool.status
|
||
// });
|
||
// 注册到 toolActionIndex
|
||
this.toolRegisterAction(toolAction, toolAction.tool.id);
|
||
// 如果有 executionId，也注册
|
||
if (toolAction.tool.executionId) {
|
||
this.toolRegisterAction(toolAction, toolAction.tool.executionId);
|
||
}
|
||
// 追踪工具调用
|
||
if (toolAction.tool.name) {
|
||
this.toolTrackAction(toolAction.tool.name, toolAction);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 标记状态为进行中
|
||
this.streamingMessage = true;
|
||
this.taskInProgress = true;
|
||
|
||
// 设置 currentMessageIndex 指向最后一条 assistant 消息
|
||
// 这样后续添加的 action 会添加到正确的消息中
|
||
const lastMessageIndex = this.messages.length - 1;
|
||
if (lastMessage && lastMessage.role === 'assistant') {
|
||
this.currentMessageIndex = lastMessageIndex;
|
||
// console.log('[TaskPolling] 设置 currentMessageIndex 为:', lastMessageIndex);
|
||
}
|
||
|
||
// 强制更新界面
|
||
this.$forceUpdate();
|
||
|
||
// 滚动到底部
|
||
this.$nextTick(() => {
|
||
this.conditionalScrollToBottom();
|
||
});
|
||
|
||
// 注册事件处理器到全局
|
||
(window as any).__taskEventHandler = (event: any) => {
|
||
this.handleTaskEvent(event);
|
||
};
|
||
|
||
// 启动轮询（从当前偏移量开始，只处理新事件）
|
||
debugLog('[TaskPolling] 启动轮询，起始偏移量:', taskStore.lastEventIndex);
|
||
|
||
taskStore.startPolling((event: any) => {
|
||
this.handleTaskEvent(event);
|
||
});
|
||
restoreDebugLog('restore:polling-started-follow', {
|
||
lastEventIndex: taskStore.lastEventIndex,
|
||
currentConversationId: this.currentConversationId
|
||
});
|
||
|
||
this.uiPushToast({
|
||
title: '任务恢复',
|
||
message: '检测到进行中的任务，已恢复连接',
|
||
type: 'info',
|
||
duration: 3000
|
||
});
|
||
} catch (error) {
|
||
restoreDebugLog('restore:error', {
|
||
message: error?.message || String(error)
|
||
});
|
||
console.error('[TaskPolling] 恢复任务状态失败:', error);
|
||
}
|
||
},
|
||
|
||
/**
|
||
* 恢复子智能体等待状态（页面刷新后调用）
|
||
*/
|
||
async restoreSubAgentWaitingState(retry = 0) {
|
||
try {
|
||
if (!this.currentConversationId) {
|
||
if (retry < 5) {
|
||
setTimeout(() => {
|
||
this.restoreSubAgentWaitingState(retry + 1);
|
||
}, 300);
|
||
}
|
||
return;
|
||
}
|
||
|
||
const response = await fetch('/api/sub_agents');
|
||
if (!response.ok) {
|
||
debugLog('[TaskPolling] 获取子智能体状态失败');
|
||
return;
|
||
}
|
||
const result = await response.json();
|
||
if (!result.success) {
|
||
debugLog('[TaskPolling] 子智能体状态响应无效');
|
||
return;
|
||
}
|
||
|
||
const tasks = Array.isArray(result.data) ? result.data : [];
|
||
debugLog('[TaskPolling] 子智能体状态响应', {
|
||
total: tasks.length,
|
||
currentConversationId: this.currentConversationId,
|
||
tasks: tasks.map((task: any) => ({
|
||
task_id: task?.task_id,
|
||
status: task?.status,
|
||
run_in_background: task?.run_in_background,
|
||
notice_pending: task?.notice_pending,
|
||
conversation_id: task?.conversation_id
|
||
}))
|
||
});
|
||
const terminalStatuses = new Set(['completed', 'failed', 'timeout', 'terminated']);
|
||
const relevant = tasks.filter((task: any) => {
|
||
if (task && task.conversation_id && task.conversation_id !== this.currentConversationId) {
|
||
return false;
|
||
}
|
||
return true;
|
||
});
|
||
|
||
const running = relevant.filter(
|
||
(task: any) => task?.run_in_background && !terminalStatuses.has(task?.status)
|
||
);
|
||
const pendingNotice = relevant.filter((task: any) => task?.notice_pending);
|
||
|
||
if (running.length || pendingNotice.length) {
|
||
debugLog('[TaskPolling] 恢复子智能体等待状态', {
|
||
running: running.length,
|
||
pendingNotice: pendingNotice.length,
|
||
runningTasks: running.map((task: any) => ({
|
||
task_id: task?.task_id,
|
||
status: task?.status
|
||
})),
|
||
pendingTasks: pendingNotice.map((task: any) => ({
|
||
task_id: task?.task_id,
|
||
status: task?.status
|
||
}))
|
||
});
|
||
this.waitingForSubAgent = true;
|
||
this.waitingForBackgroundCommand = false;
|
||
this.taskInProgress = true;
|
||
this.streamingMessage = false;
|
||
this.stopRequested = false;
|
||
this.startWaitingTaskProbe();
|
||
this.$forceUpdate();
|
||
}
|
||
} catch (error) {
|
||
console.error('[TaskPolling] 恢复子智能体等待状态失败:', error);
|
||
}
|
||
}
|
||
};
|