929 lines
35 KiB
Vue
929 lines
35 KiB
Vue
<template>
|
||
<div class="chat">
|
||
<div ref="scrollContainer" class="chat_scroll_box" @scroll="handleScroll">
|
||
<div class="msg_list">
|
||
<div v-for="(session, id) in messagesList" :key='id'>
|
||
<div v-if="session.role == 'user'">
|
||
<usermsg :content="session.content"></usermsg>
|
||
</div>
|
||
<div v-if="session.role == 'assistant'">
|
||
<botmsg :content="session.content" :session="session" :user-query="getUserQuery(id)" @scroll-bottom="scrollToBottom"
|
||
:isFirstEnter="isFirstEnter"></botmsg>
|
||
</div>
|
||
</div>
|
||
<div v-if="loading"
|
||
style="height: 41px;display: flex;align-items: center;padding-left: 4px;">
|
||
<div class="loading-typing">
|
||
<span></span>
|
||
<span></span>
|
||
<span></span>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div style="min-height: 115px; margin: 16px auto 4px;width: 100%;max-width: 800px;">
|
||
<InputField
|
||
@send-msg="(query, modelId) => sendMsg(query, modelId)"
|
||
@stop-generation="handleStopGeneration"
|
||
:isReplying="isReplying"
|
||
:sessionId="session_id"
|
||
:assistantMessageId="currentAssistantMessageId"
|
||
></InputField>
|
||
</div>
|
||
</div>
|
||
<KnowledgeBaseEditorModal
|
||
:visible="uiStore.showKBEditorModal"
|
||
:mode="uiStore.kbEditorMode"
|
||
:kb-id="uiStore.currentKBId || undefined"
|
||
:initial-type="uiStore.kbEditorType"
|
||
@update:visible="(val) => val ? null : uiStore.closeKBEditor()"
|
||
@success="handleKBEditorSuccess"
|
||
/>
|
||
</template>
|
||
<script setup>
|
||
import { storeToRefs } from 'pinia';
|
||
import { ref, onMounted, onUnmounted, nextTick, watch, reactive, onBeforeUnmount } from 'vue';
|
||
import { useRoute, useRouter, onBeforeRouteLeave, onBeforeRouteUpdate } from 'vue-router';
|
||
import InputField from '../../components/Input-field.vue';
|
||
import botmsg from './components/botmsg.vue';
|
||
import usermsg from './components/usermsg.vue';
|
||
import { getMessageList, generateSessionsTitle, getSession } from "@/api/chat/index";
|
||
import { useStream } from '../../api/chat/streame'
|
||
import { useMenuStore } from '@/stores/menu';
|
||
import { useSettingsStore } from '@/stores/settings';
|
||
import { MessagePlugin } from 'tdesign-vue-next';
|
||
import { useI18n } from 'vue-i18n';
|
||
import { useUIStore } from '@/stores/ui';
|
||
import KnowledgeBaseEditorModal from '@/views/knowledge/KnowledgeBaseEditorModal.vue';
|
||
import { useKnowledgeBaseCreationNavigation } from '@/hooks/useKnowledgeBaseCreationNavigation';
|
||
const usemenuStore = useMenuStore();
|
||
const useSettingsStoreInstance = useSettingsStore();
|
||
const uiStore = useUIStore();
|
||
const { navigateToKnowledgeBaseList } = useKnowledgeBaseCreationNavigation();
|
||
const { t } = useI18n();
|
||
const { menuArr, isFirstSession, firstQuery } = storeToRefs(usemenuStore);
|
||
const { output, onChunk, isStreaming, isLoading, error, startStream, stopStream } = useStream();
|
||
const route = useRoute();
|
||
const router = useRouter();
|
||
const session_id = ref(route.params.chatid);
|
||
const sessionData = ref(null);
|
||
const created_at = ref('');
|
||
const limit = ref(20);
|
||
const messagesList = reactive([]);
|
||
const isReplying = ref(false);
|
||
const currentAssistantMessageId = ref(''); // 当前正在生成的 assistant message ID
|
||
const scrollLock = ref(false);
|
||
const isNeedTitle = ref(false);
|
||
const isFirstEnter = ref(true);
|
||
const loading = ref(false);
|
||
let fullContent = ref('')
|
||
let userquery = ref('')
|
||
const scrollContainer = ref(null)
|
||
const handleKBEditorSuccess = (kbId) => {
|
||
navigateToKnowledgeBaseList(kbId)
|
||
}
|
||
|
||
const getUserQuery = (index) => {
|
||
if (index <= 0) {
|
||
return '';
|
||
}
|
||
const previous = messagesList[index - 1];
|
||
if (previous && previous.role === 'user') {
|
||
return previous.content || '';
|
||
}
|
||
return '';
|
||
};
|
||
watch([() => route.params], (newvalue) => {
|
||
isFirstEnter.value = true;
|
||
if (newvalue[0].chatid) {
|
||
if (!firstQuery.value) {
|
||
scrollLock.value = false;
|
||
}
|
||
messagesList.splice(0);
|
||
session_id.value = newvalue[0].chatid;
|
||
|
||
// 切换会话时,重置状态(加载历史消息不应显示loading)
|
||
loading.value = false;
|
||
isReplying.value = false;
|
||
currentAssistantMessageId.value = '';
|
||
|
||
checkmenuTitle(session_id.value)
|
||
let data = {
|
||
session_id: session_id.value,
|
||
created_at: '',
|
||
limit: limit.value
|
||
}
|
||
getmsgList(data);
|
||
}
|
||
});
|
||
const scrollToBottom = () => {
|
||
nextTick(() => {
|
||
if (scrollContainer.value) {
|
||
scrollContainer.value.scrollTop = scrollContainer.value.scrollHeight;
|
||
}
|
||
})
|
||
}
|
||
const debounce = (fn, delay) => {
|
||
let timer
|
||
return (...args) => {
|
||
clearTimeout(timer)
|
||
timer = setTimeout(() => fn(...args), delay)
|
||
}
|
||
}
|
||
const onChatScrollTop = () => {
|
||
if (scrollLock.value) return;
|
||
const { scrollTop, scrollHeight } = scrollContainer.value;
|
||
isFirstEnter.value = false
|
||
if (scrollTop == 0) {
|
||
let data = {
|
||
session_id: session_id.value,
|
||
created_at: created_at.value,
|
||
limit: limit.value
|
||
}
|
||
getmsgList(data, true, scrollHeight);
|
||
}
|
||
}
|
||
const handleScroll = debounce(onChatScrollTop, 500);
|
||
|
||
const getmsgList = (data, isScrollType = false, scrollHeight) => {
|
||
getMessageList(data).then(res => {
|
||
if (res && res.data?.length) {
|
||
created_at.value = res.data[0].created_at;
|
||
handleMsgList(res.data, isScrollType, scrollHeight);
|
||
}
|
||
})
|
||
}
|
||
|
||
// Reconstruct agentEventStream from agent_steps stored in database
|
||
// This allows the frontend to restore the exact conversation state including all agent reasoning steps
|
||
const reconstructEventStreamFromSteps = (agentSteps, messageContent, isCompleted = false) => {
|
||
const events = [];
|
||
|
||
// Process agent steps if they exist
|
||
if (agentSteps && Array.isArray(agentSteps) && agentSteps.length > 0) {
|
||
agentSteps.forEach((step) => {
|
||
// Add thinking event if thought content exists
|
||
if (step.thought && step.thought.trim()) {
|
||
events.push({
|
||
type: 'thinking',
|
||
event_id: `step-${step.iteration}-thought`,
|
||
content: step.thought,
|
||
done: true,
|
||
thinking: false,
|
||
// Extract duration from step if available
|
||
duration_ms: step.duration || undefined,
|
||
});
|
||
}
|
||
|
||
// Add tool call and result events
|
||
if (step.tool_calls && Array.isArray(step.tool_calls)) {
|
||
step.tool_calls.forEach((toolCall) => {
|
||
events.push({
|
||
type: 'tool_call',
|
||
tool_call_id: toolCall.id,
|
||
tool_name: toolCall.name,
|
||
arguments: toolCall.args,
|
||
pending: false,
|
||
success: toolCall.result?.success !== false,
|
||
output: toolCall.result?.output || '',
|
||
error: toolCall.result?.error || undefined,
|
||
// Use both duration and duration_ms for compatibility
|
||
duration: toolCall.duration,
|
||
duration_ms: toolCall.duration,
|
||
display_type: toolCall.result?.data?.display_type,
|
||
tool_data: toolCall.result?.data,
|
||
});
|
||
});
|
||
}
|
||
});
|
||
}
|
||
|
||
// 总是添加 answer 事件如果有内容(无论是否有 agent_steps)
|
||
// 这样可以确保最终答案始终被渲染
|
||
if (messageContent && messageContent.trim()) {
|
||
events.push({
|
||
type: 'answer',
|
||
content: messageContent,
|
||
done: true
|
||
});
|
||
} else if (isCompleted) {
|
||
// 如果消息已完成但 content 为空(Agent 模式常见情况),添加一个空的 answer 事件标记完成
|
||
// 这样可以确保 isConversationDone 返回 true,不显示 loading-indicator
|
||
events.push({
|
||
type: 'answer',
|
||
content: '',
|
||
done: true
|
||
});
|
||
}
|
||
|
||
return events;
|
||
};
|
||
const handleMsgList = async (data, isScrollType = false, newScrollHeight) => {
|
||
let chatlist = data.reverse()
|
||
for (let i = 0, len = chatlist.length; i < len; i++) {
|
||
let item = chatlist[i];
|
||
item.isAgentMode = false; // Agent 模式标记
|
||
item.agentEventStream = item.agentEventStream || [];
|
||
item._eventMap = new Map();
|
||
item._pendingToolCalls = new Map();
|
||
|
||
// Check if this message has agent_steps from database (historical agent conversation)
|
||
// If so, reconstruct the agentEventStream to restore the exact conversation state
|
||
if (item.agent_steps && Array.isArray(item.agent_steps) && item.agent_steps.length > 0) {
|
||
console.log('[Message Load] Reconstructing agent steps for message:', item.id, 'steps:', item.agent_steps.length);
|
||
item.isAgentMode = true;
|
||
item.agentEventStream = reconstructEventStreamFromSteps(item.agent_steps, item.content, item.is_completed);
|
||
// 隐藏最终答案内容,因为它已经包含在 agentEventStream 的 answer 事件中
|
||
item.hideContent = true;
|
||
console.log('[Message Load] Reconstructed', item.agentEventStream.length, 'events from agent steps');
|
||
}
|
||
|
||
if (item.content) {
|
||
if (!item.content.includes('<think>') && !item.content.includes('<\/think>')) {
|
||
item.thinkContent = "";
|
||
item.content = item.content;
|
||
item.showThink = false;
|
||
} else if (item.content.includes('<\/think>')) {
|
||
const arr = item.content.trim().split('<\/think>');
|
||
item.showThink = true;
|
||
item.thinkContent = arr[0].trim().replace('<think>', '');
|
||
let index = item.content.trim().lastIndexOf('<\/think>')
|
||
item.content = item.content.substring(index + 8);
|
||
}
|
||
}
|
||
|
||
// 只给非Agent模式的空内容已完成消息设置默认错误消息
|
||
// Agent模式的消息内容在agent_steps中,content为空是正常的
|
||
if (item.is_completed && !item.content && !item.isAgentMode) {
|
||
item.content = t('chat.cannotAnswer');
|
||
}
|
||
messagesList.unshift(item);
|
||
if (isFirstEnter.value) {
|
||
scrollToBottom();
|
||
} else if (isScrollType) {
|
||
nextTick(() => {
|
||
const { scrollHeight } = scrollContainer.value;
|
||
scrollContainer.value.scrollTop = scrollHeight - newScrollHeight
|
||
})
|
||
}
|
||
}
|
||
if (messagesList[messagesList.length - 1] && !messagesList[messagesList.length - 1].is_completed) {
|
||
isReplying.value = true;
|
||
// 保存正在 stream 的消息 ID,以便停止时使用
|
||
const lastMessage = messagesList[messagesList.length - 1];
|
||
if (lastMessage.role === 'assistant') {
|
||
currentAssistantMessageId.value = lastMessage.id;
|
||
console.log('[Continue Stream] Set assistant message ID:', lastMessage.id);
|
||
}
|
||
await startStream({ session_id: session_id.value, query: lastMessage.id, method: 'GET', url: '/api/v1/sessions/continue-stream' });
|
||
}
|
||
|
||
}
|
||
const checkmenuTitle = (session_id) => {
|
||
menuArr.value[1].children?.forEach(item => {
|
||
if (item.id == session_id) {
|
||
isNeedTitle.value = item.isNoTitle;
|
||
}
|
||
});
|
||
}
|
||
// 发送消息
|
||
// 处理停止生成事件 - 立即清除 loading 状态
|
||
const handleStopGeneration = () => {
|
||
console.log('[Stop Generation] Immediately clearing loading state');
|
||
loading.value = false;
|
||
isReplying.value = false;
|
||
// 注意:不在这里清空 currentAssistantMessageId,因为需要它来调用 API
|
||
// API 调用成功后,后端的 stop 事件会清空它
|
||
};
|
||
|
||
const sendMsg = async (value, modelId = '') => {
|
||
userquery.value = value;
|
||
isReplying.value = true;
|
||
loading.value = true;
|
||
messagesList.push({ content: value, role: 'user' });
|
||
scrollToBottom();
|
||
|
||
// Get agent mode status from settings store
|
||
const agentEnabled = useSettingsStoreInstance.isAgentEnabled;
|
||
|
||
// Get web search status from settings store
|
||
const webSearchEnabled = useSettingsStoreInstance.isWebSearchEnabled;
|
||
|
||
// Get knowledge_base_ids from settings store (selected by user via KnowledgeBaseSelector)
|
||
const kbIds = useSettingsStoreInstance.settings.selectedKnowledgeBases || [];
|
||
const knowledgeIds = useSettingsStoreInstance.settings.selectedFiles || [];
|
||
|
||
|
||
|
||
// Use agent-chat endpoint when agent is enabled, otherwise use knowledge-chat
|
||
const endpoint = agentEnabled ? '/api/v1/agent-chat' : '/api/v1/knowledge-chat';
|
||
|
||
// Get selected MCP services from settings store (if available)
|
||
const mcpServiceIds = useSettingsStoreInstance.settings.selectedMCPServices || [];
|
||
|
||
await startStream({
|
||
session_id: session_id.value,
|
||
knowledge_base_ids: kbIds,
|
||
knowledge_ids: knowledgeIds,
|
||
agent_enabled: agentEnabled,
|
||
web_search_enabled: webSearchEnabled,
|
||
summary_model_id: modelId,
|
||
mcp_service_ids: mcpServiceIds,
|
||
query: value,
|
||
method: 'POST',
|
||
url: endpoint
|
||
});
|
||
}
|
||
|
||
// Watch for stream errors and show message
|
||
watch(error, (newError) => {
|
||
if (newError) {
|
||
MessagePlugin.error(newError);
|
||
isReplying.value = false;
|
||
loading.value = false;
|
||
// 清空当前 assistant message ID
|
||
currentAssistantMessageId.value = '';
|
||
}
|
||
});
|
||
|
||
// 处理流式数据
|
||
onChunk((data) => {
|
||
// 日志:打印接收到的事件
|
||
console.log('[Agent Event Received]', {
|
||
response_type: data.response_type,
|
||
id: data.id,
|
||
done: data.done,
|
||
content_length: data.content?.length || 0,
|
||
content_preview: data.content ? data.content.substring(0, 50) : '',
|
||
data: data.data,
|
||
session_id: data.session_id,
|
||
assistant_message_id: data.assistant_message_id
|
||
});
|
||
|
||
// 处理 agent query 事件 - 保存 assistant message ID 并保持 loading 状态
|
||
if (data.response_type === 'agent_query') {
|
||
if (data.assistant_message_id) {
|
||
currentAssistantMessageId.value = data.assistant_message_id;
|
||
console.log('[Agent Query] Saved assistant message ID:', data.assistant_message_id);
|
||
}
|
||
console.log('[Agent Query Event]', {
|
||
session_id: data.session_id || data.data?.session_id,
|
||
assistant_message_id: data.assistant_message_id,
|
||
query: data.data?.query,
|
||
request_id: data.data?.request_id
|
||
});
|
||
|
||
// 检查是否是继续流式传输(消息已存在)
|
||
const existingMessage = messagesList.findLast((item) => item.id === data.id || item.request_id === data.id);
|
||
if (!existingMessage) {
|
||
// 新消息,设置 loading 状态
|
||
loading.value = true;
|
||
console.log('[Agent Query] New message, setting loading=true');
|
||
} else {
|
||
// 继续流式传输(刷新页面场景),不设置 loading,因为消息已经在列表中
|
||
console.log('[Agent Query] Continuing stream for existing message, keeping current loading state');
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 处理会话标题更新事件 - 不关闭 loading
|
||
if (data.response_type === 'session_title') {
|
||
const title = data.content || data.data?.title;
|
||
if (title && data.data?.session_id) {
|
||
console.log('[Session Title Update]', {
|
||
session_id: data.data.session_id,
|
||
title: title
|
||
});
|
||
usemenuStore.updatasessionTitle(data.data.session_id, title);
|
||
usemenuStore.changeIsFirstSession(false);
|
||
isNeedTitle.value = false;
|
||
}
|
||
// 不关闭 loading,等待实际内容
|
||
return;
|
||
}
|
||
|
||
// 判断是否是 Agent 模式的响应
|
||
const isAgentResponse = data.response_type === 'thinking' ||
|
||
data.response_type === 'tool_call' ||
|
||
data.response_type === 'tool_result' ||
|
||
data.response_type === 'references' ||
|
||
data.response_type === 'answer' ||
|
||
data.response_type === 'reflection' ||
|
||
data.response_type === 'stop';
|
||
|
||
// Agent 模式处理(包括 stop 事件)
|
||
if (isAgentResponse || messagesList[messagesList.length - 1]?.isAgentMode) {
|
||
// 在 handleAgentChunk 中处理 loading 状态
|
||
handleAgentChunk(data);
|
||
|
||
// 对于 stop 事件,额外处理全局状态
|
||
if (data.response_type === 'stop') {
|
||
console.log('[Stop Event] Generation stopped');
|
||
loading.value = false;
|
||
isReplying.value = false;
|
||
// 清空当前 assistant message ID
|
||
currentAssistantMessageId.value = '';
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 原有的知识库 QA 处理逻辑
|
||
fullContent.value += data.content;
|
||
let obj = { ...data, content: '', role: 'assistant', showThink: false, is_completed: false };
|
||
|
||
if (fullContent.value.includes('<think>') && !fullContent.value.includes('<\/think>')) {
|
||
obj.thinking = true;
|
||
obj.showThink = true;
|
||
obj.content = '';
|
||
obj.thinkContent = fullContent.value.replace('<think>', '').trim();
|
||
} else if (fullContent.value.includes('<think>') && fullContent.value.includes('<\/think>')) {
|
||
obj.thinking = false;
|
||
obj.showThink = true;
|
||
const index = fullContent.value.indexOf('<\/think>');
|
||
obj.thinkContent = fullContent.value.substring(0, index).replace('<think>', '').trim();
|
||
obj.content = fullContent.value.substring(index + 8).trim();
|
||
} else {
|
||
obj.content = fullContent.value;
|
||
}
|
||
|
||
// 检查是否已有消息,如果没有则说明这是第一次,关闭 loading
|
||
const existingMessage = messagesList.findLast((item) => {
|
||
if (item.request_id === obj.id) {
|
||
return true
|
||
}
|
||
return item.id === obj.id;
|
||
});
|
||
if (!existingMessage) {
|
||
loading.value = false; // 消息即将创建,关闭 loading
|
||
}
|
||
|
||
if (data.done) {
|
||
// 标记消息已完成
|
||
obj.is_completed = true;
|
||
// 标题生成已改为异步事件推送,不再需要在这里手动调用
|
||
// 如果标题还未生成,前端会通过 SSE 事件接收
|
||
isReplying.value = false;
|
||
fullContent.value = "";
|
||
// 清空当前 assistant message ID
|
||
currentAssistantMessageId.value = '';
|
||
}
|
||
updateAssistantSession(obj);
|
||
})
|
||
// 处理 Agent 流式数据 (Cursor-style UI)
|
||
const handleAgentChunk = (data) => {
|
||
let message = messagesList.findLast((item) => item.request_id === data.id || item.id === data.id);
|
||
|
||
if (!message) {
|
||
// 创建新的 Assistant 消息 - 此时开始显示内容,关闭 loading
|
||
const newMsg = {
|
||
id: data.id,
|
||
request_id: data.id,
|
||
role: 'assistant',
|
||
content: '',
|
||
isAgentMode: true,
|
||
// Event stream: ordered list of all agent events (thinking, tool calls, etc)
|
||
agentEventStream: [],
|
||
// Map to track event by event_id for quick lookup
|
||
_eventMap: new Map(),
|
||
knowledge_references: []
|
||
};
|
||
messagesList.push(newMsg);
|
||
loading.value = false; // 消息已创建,关闭 loading
|
||
scrollToBottom();
|
||
// Don't return - continue to process the current event data
|
||
message = newMsg;
|
||
}
|
||
|
||
message.isAgentMode = true;
|
||
|
||
// 确保在继续流式传输时(刷新页面场景),一旦接收到实际内容就关闭 loading
|
||
// 这是一个保护措施,防止任何边缘情况导致 loading 残留
|
||
if (loading.value && (data.response_type === 'thinking' || data.response_type === 'answer' || data.response_type === 'tool_call')) {
|
||
console.log('[Agent Chunk] Closing loading for continued stream');
|
||
loading.value = false;
|
||
}
|
||
|
||
switch(data.response_type) {
|
||
case 'thinking':
|
||
{
|
||
const eventId = data.data?.event_id;
|
||
console.log('[Thinking Event]', {
|
||
event_id: eventId,
|
||
done: data.done,
|
||
content_length: data.content?.length || 0
|
||
});
|
||
|
||
// Initialize structures
|
||
if (!message.agentEventStream) message.agentEventStream = [];
|
||
if (!message._eventMap) message._eventMap = new Map();
|
||
|
||
if (!data.done) {
|
||
// Check if this thinking event already exists
|
||
let thinkingEvent = message._eventMap.get(eventId);
|
||
|
||
if (!thinkingEvent) {
|
||
// Create new thinking event
|
||
console.log('[Thinking] Creating new thinking event, event_id:', eventId);
|
||
thinkingEvent = {
|
||
type: 'thinking',
|
||
event_id: eventId,
|
||
content: '',
|
||
done: false,
|
||
startTime: Date.now(),
|
||
thinking: true
|
||
};
|
||
|
||
// Add to event stream
|
||
message.agentEventStream.push(thinkingEvent);
|
||
message._eventMap.set(eventId, thinkingEvent);
|
||
}
|
||
|
||
// Accumulate content
|
||
if (data.content) {
|
||
thinkingEvent.content += data.content;
|
||
console.log('[Thinking] Event', eventId, 'accumulated:', thinkingEvent.content.length, 'chars');
|
||
}
|
||
|
||
} else {
|
||
// Thinking completed
|
||
const thinkingEvent = message._eventMap.get(eventId);
|
||
if (thinkingEvent) {
|
||
console.log('[Thinking] Completing event, event_id:', eventId, 'content length:', thinkingEvent.content.length);
|
||
|
||
// Mark as done
|
||
thinkingEvent.done = true;
|
||
thinkingEvent.thinking = false;
|
||
thinkingEvent.duration_ms = data.data?.duration_ms || (Date.now() - thinkingEvent.startTime);
|
||
thinkingEvent.completed_at = data.data?.completed_at || Date.now();
|
||
|
||
console.log('[Thinking] Event completed, duration:', thinkingEvent.duration_ms, 'ms');
|
||
} else {
|
||
console.warn('[Thinking] Received done for unknown event_id:', eventId);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case 'tool_call':
|
||
// Store or update pending tool call to pair with result later
|
||
if (data.data && (data.data.tool_name || data.data.tool_call_id)) {
|
||
const incomingToolName = data.data.tool_name;
|
||
const incomingArguments = data.data.arguments;
|
||
|
||
if (!message.agentEventStream) message.agentEventStream = [];
|
||
if (!message._pendingToolCalls) message._pendingToolCalls = new Map();
|
||
|
||
const toolCallId = data.data.tool_call_id || (incomingToolName ? (incomingToolName + '_' + Date.now()) : null);
|
||
if (!toolCallId) {
|
||
console.warn('[Tool Call] Received event without identifiable tool_call_id:', data.data);
|
||
break;
|
||
}
|
||
|
||
console.log('[Tool Call]', {
|
||
tool_call_id: toolCallId,
|
||
tool_name: incomingToolName,
|
||
has_arguments: Boolean(incomingArguments)
|
||
});
|
||
|
||
let toolCallEvent = message._pendingToolCalls.get(toolCallId);
|
||
if (!toolCallEvent) {
|
||
toolCallEvent = message.agentEventStream.find(
|
||
(event) => event.type === 'tool_call' && event.tool_call_id === toolCallId
|
||
);
|
||
}
|
||
|
||
if (toolCallEvent) {
|
||
if (incomingToolName) toolCallEvent.tool_name = incomingToolName;
|
||
if (incomingArguments) toolCallEvent.arguments = incomingArguments;
|
||
toolCallEvent.pending = true;
|
||
if (!toolCallEvent.timestamp) {
|
||
toolCallEvent.timestamp = Date.now();
|
||
}
|
||
message._pendingToolCalls.set(toolCallId, toolCallEvent);
|
||
} else {
|
||
const newToolCallEvent = {
|
||
type: 'tool_call',
|
||
tool_call_id: toolCallId,
|
||
tool_name: incomingToolName,
|
||
arguments: incomingArguments,
|
||
timestamp: Date.now(),
|
||
pending: true
|
||
};
|
||
message.agentEventStream.push(newToolCallEvent);
|
||
message._pendingToolCalls.set(toolCallId, newToolCallEvent);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case 'tool_result':
|
||
case 'error':
|
||
// Tool result - update the corresponding tool call event
|
||
if (data.data) {
|
||
const toolCallId = data.data.tool_call_id;
|
||
const toolName = data.data.tool_name;
|
||
const success = data.response_type !== 'error' && data.data.success !== false;
|
||
|
||
console.log('[Tool Result]', {
|
||
tool_call_id: toolCallId,
|
||
tool_name: toolName,
|
||
success: success
|
||
});
|
||
|
||
// Find and update the pending tool call event
|
||
let toolCallEvent = null;
|
||
if (message._pendingToolCalls) {
|
||
if (toolCallId && message._pendingToolCalls.has(toolCallId)) {
|
||
toolCallEvent = message._pendingToolCalls.get(toolCallId);
|
||
message._pendingToolCalls.delete(toolCallId);
|
||
} else {
|
||
// Try to find by tool_name if no tool_call_id match
|
||
for (const [key, value] of message._pendingToolCalls.entries()) {
|
||
if (value.tool_name === toolName) {
|
||
toolCallEvent = value;
|
||
message._pendingToolCalls.delete(key);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (toolCallEvent) {
|
||
// Update the existing event with result
|
||
toolCallEvent.pending = false;
|
||
toolCallEvent.success = success;
|
||
toolCallEvent.output = success ? (data.data.output || data.content) : (data.data.error || data.content);
|
||
toolCallEvent.error = !success ? (data.data.error || data.content) : undefined;
|
||
// Set both duration and duration_ms for compatibility
|
||
const duration = data.data.duration_ms !== undefined ? data.data.duration_ms : data.data.duration;
|
||
toolCallEvent.duration = duration;
|
||
toolCallEvent.duration_ms = duration;
|
||
toolCallEvent.display_type = data.data.display_type;
|
||
toolCallEvent.tool_data = data.data;
|
||
|
||
console.log('[Tool Result] Updated event in stream');
|
||
} else {
|
||
console.warn('[Tool Result] No pending tool call found for', toolCallId || toolName);
|
||
}
|
||
|
||
// If this is an error response without tool data, handle it
|
||
if (data.response_type === 'error' && !toolName) {
|
||
message.content = data.content || t('chat.processError');
|
||
isReplying.value = false;
|
||
}
|
||
} else if (data.response_type === 'error') {
|
||
// Generic error without tool context
|
||
message.content = data.content || t('chat.processError');
|
||
isReplying.value = false;
|
||
}
|
||
break;
|
||
|
||
|
||
case 'references':
|
||
// 知识引用
|
||
if (data.data?.references) {
|
||
message.knowledge_references = data.data.references;
|
||
} else if (data.knowledge_references) {
|
||
// 兼容旧格式
|
||
message.knowledge_references = data.knowledge_references;
|
||
}
|
||
break;
|
||
|
||
case 'answer':
|
||
// 最终答案
|
||
message.thinking = false;
|
||
message.content = (message.content || '') + (data.content || '');
|
||
fullContent.value += data.content || '';
|
||
|
||
// Add or update answer event in agentEventStream
|
||
if (!message.agentEventStream) message.agentEventStream = [];
|
||
|
||
let answerEvent = message.agentEventStream.find((e) => e.type === 'answer');
|
||
if (!answerEvent) {
|
||
answerEvent = {
|
||
type: 'answer',
|
||
content: '',
|
||
done: false
|
||
};
|
||
message.agentEventStream.push(answerEvent);
|
||
}
|
||
|
||
answerEvent.content = message.content;
|
||
answerEvent.done = data.done;
|
||
|
||
if (data.done) {
|
||
console.log('[Agent] Answer done, content length:', message.content?.length || 0);
|
||
|
||
// 完成 - 关闭所有状态
|
||
loading.value = false;
|
||
isReplying.value = false;
|
||
fullContent.value = '';
|
||
// 清空当前 assistant message ID
|
||
currentAssistantMessageId.value = '';
|
||
|
||
// 标题生成已改为异步事件推送,不再需要在这里手动调用
|
||
// 如果标题还未生成,前端会通过 SSE 事件接收
|
||
}
|
||
break;
|
||
|
||
case 'stop':
|
||
// 停止事件 - 添加到事件流并标记对话完成
|
||
console.log('[Agent] Stop event received');
|
||
if (!message.agentEventStream) message.agentEventStream = [];
|
||
|
||
// Add stop event to stream
|
||
message.agentEventStream.push({
|
||
type: 'stop',
|
||
timestamp: Date.now(),
|
||
reason: data.data?.reason || 'user_requested'
|
||
});
|
||
|
||
// Mark conversation as stopped
|
||
isReplying.value = false;
|
||
fullContent.value = '';
|
||
break;
|
||
}
|
||
|
||
scrollToBottom();
|
||
};
|
||
|
||
const updateAssistantSession = (payload) => {
|
||
const message = messagesList.findLast((item) => {
|
||
if (item.request_id === payload.id) {
|
||
return true
|
||
}
|
||
return item.id === payload.id;
|
||
});
|
||
if (message) {
|
||
message.content = payload.content;
|
||
message.thinking = payload.thinking;
|
||
message.thinkContent = payload.thinkContent;
|
||
message.showThink = payload.showThink;
|
||
message.knowledge_references = message.knowledge_references ? message.knowledge_references : payload.knowledge_references;
|
||
// 更新完成状态
|
||
if (payload.is_completed) {
|
||
message.is_completed = true;
|
||
}
|
||
} else {
|
||
messagesList.push(payload);
|
||
}
|
||
scrollToBottom();
|
||
}
|
||
onMounted(async () => {
|
||
messagesList.splice(0);
|
||
|
||
// 初始化状态:加载历史消息时不应显示loading
|
||
loading.value = false;
|
||
isReplying.value = false;
|
||
|
||
// Load session data to get agent_config
|
||
try {
|
||
const sessionRes = await getSession(session_id.value);
|
||
if (sessionRes?.data) {
|
||
sessionData.value = sessionRes.data;
|
||
}
|
||
} catch (error) {
|
||
console.error('Failed to load session data:', error);
|
||
}
|
||
|
||
checkmenuTitle(session_id.value)
|
||
if (firstQuery.value) {
|
||
scrollLock.value = true;
|
||
sendMsg(firstQuery.value);
|
||
usemenuStore.changeFirstQuery('');
|
||
} else {
|
||
scrollLock.value = false;
|
||
let data = {
|
||
session_id: session_id.value,
|
||
created_at: '',
|
||
limit: limit.value
|
||
}
|
||
getmsgList(data)
|
||
}
|
||
})
|
||
const clearData = () => {
|
||
stopStream();
|
||
isReplying.value = false;
|
||
fullContent.value = '';
|
||
userquery.value = '';
|
||
|
||
}
|
||
onBeforeRouteLeave((to, from, next) => {
|
||
clearData()
|
||
next()
|
||
})
|
||
onBeforeRouteUpdate((to, from, next) => {
|
||
clearData()
|
||
next()
|
||
})
|
||
</script>
|
||
<style lang="less" scoped>
|
||
.chat {
|
||
font-size: 20px;
|
||
padding: 20px;
|
||
box-sizing: border-box;
|
||
flex: 1;
|
||
position: relative;
|
||
display: flex;
|
||
flex-direction: column;
|
||
align-items: center;
|
||
max-width: calc(100vw - 260px);
|
||
min-width: 400px;
|
||
|
||
:deep(.answers-input) {
|
||
position: static;
|
||
transform: translateX(0);
|
||
|
||
.t-textarea__inner {
|
||
width: 100% !important;
|
||
}
|
||
}
|
||
}
|
||
|
||
.chat_scroll_box {
|
||
flex: 1;
|
||
width: 100%;
|
||
overflow-y: auto;
|
||
|
||
&::-webkit-scrollbar {
|
||
width: 0;
|
||
height: 0;
|
||
color: transparent;
|
||
}
|
||
}
|
||
|
||
|
||
.agent-mode-indicator {
|
||
display: flex;
|
||
align-items: center;
|
||
gap: 8px;
|
||
padding: 8px 16px;
|
||
background: linear-gradient(135deg, #e6f7ff 0%, #bae7ff 100%);
|
||
border: 1px solid #91d5ff;
|
||
border-radius: 6px;
|
||
margin-bottom: 12px;
|
||
max-width: 800px;
|
||
width: 100%;
|
||
|
||
.agent-icon {
|
||
font-size: 20px;
|
||
}
|
||
|
||
.agent-text {
|
||
font-size: 14px;
|
||
font-weight: 500;
|
||
color: #0050b3;
|
||
flex: 1;
|
||
}
|
||
}
|
||
|
||
.msg_list {
|
||
display: flex;
|
||
flex-direction: column;
|
||
gap: 16px;
|
||
max-width: 800px;
|
||
flex: 1;
|
||
margin: 0 auto;
|
||
width: 100%;
|
||
|
||
.botanswer_laoding_gif {
|
||
width: 24px;
|
||
height: 18px;
|
||
margin-left: 16px;
|
||
}
|
||
|
||
.loading-typing {
|
||
display: flex;
|
||
align-items: center;
|
||
gap: 4px;
|
||
|
||
span {
|
||
width: 6px;
|
||
height: 6px;
|
||
border-radius: 50%;
|
||
background: #07c05f;
|
||
animation: typingBounce 1.4s ease-in-out infinite;
|
||
|
||
&:nth-child(1) {
|
||
animation-delay: 0s;
|
||
}
|
||
|
||
&:nth-child(2) {
|
||
animation-delay: 0.2s;
|
||
}
|
||
|
||
&:nth-child(3) {
|
||
animation-delay: 0.4s;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
@keyframes typingBounce {
|
||
0%, 60%, 100% {
|
||
transform: translateY(0);
|
||
}
|
||
30% {
|
||
transform: translateY(-8px);
|
||
}
|
||
}
|
||
</style> |