Files
Enterprise-Knowledge-Base/frontend/src/views/chat/index.vue
T
wizardchen 4aedf5fd62 fix(chat): simplify enableMemoryOverride assignment in sendMsg function
Refactored the assignment of enableMemoryOverride in the sendMsg function to remove explicit type declaration, enhancing code clarity. This change maintains the existing functionality while streamlining the code structure.
2026-05-18 17:28:58 +08:00

1591 lines
61 KiB
Vue
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<template>
<div class="chat" :class="{ 'is-embedded': embeddedMode, 'is-sidebar-collapsed': uiStore.sidebarCollapsed }">
<div ref="scrollContainer" class="chat_scroll_box" @scroll="handleScroll">
<div class="msg_list" :class="{ 'is-embedded': embeddedMode }">
<!-- 消息列表骨架屏 -->
<div v-if="historyLoading && messagesList.length === 0" class="msg-skeleton-list">
<div class="msg-skeleton msg-skeleton-user">
<t-skeleton animation="gradient" :row-col="[{ width: '45%', height: '36px', type: 'rect' }]" />
</div>
<div class="msg-skeleton msg-skeleton-bot">
<t-skeleton animation="gradient" :row-col="[{ width: '80%', height: '16px' }, { width: '100%', height: '16px' }, { width: '60%', height: '16px' }]" />
</div>
<div class="msg-skeleton msg-skeleton-user">
<t-skeleton animation="gradient" :row-col="[{ width: '35%', height: '36px', type: 'rect' }]" />
</div>
<div class="msg-skeleton msg-skeleton-bot">
<t-skeleton animation="gradient" :row-col="[{ width: '70%', height: '16px' }, { width: '90%', height: '16px' }]" />
</div>
</div>
<!-- 推荐问题卡片 - 仅在新会话(无消息)时展示 -->
<div v-if="messagesList.length === 0 && !loading" class="suggested-questions-container" :class="{ 'has-questions': suggestedQuestions.length > 0 || suggestedQuestionsLoading }">
<!-- 骨架屏占位 -->
<div v-if="suggestedQuestionsLoading && suggestedQuestions.length === 0" class="suggested-questions-inner">
<div class="suggested-questions-title"><t-skeleton animation="gradient" :row-col="[{ width: '120px', height: '18px' }]" /></div>
<div class="suggested-questions-grid">
<div v-for="n in 6" :key="'sq-skel-'+n" class="suggested-question-card sq-card-skeleton">
<t-skeleton animation="gradient" :row-col="[{ width: '90%', height: '14px' }, { width: '60%', height: '14px' }]" />
</div>
</div>
</div>
<transition v-else appear name="sq-fade">
<div v-if="suggestedQuestions.length > 0" class="suggested-questions-inner">
<div class="suggested-questions-title">{{ t('chat.suggestedQuestions') }}</div>
<div class="suggested-questions-grid">
<div
v-for="(item, index) in suggestedQuestions"
:key="item.question"
class="suggested-question-card"
@click="handleSuggestedQuestionClick(item.question)"
>
<span class="suggested-question-text">{{ item.question }}</span>
<span v-if="item.source === 'faq'" class="suggested-question-badge faq">FAQ</span>
</div>
</div>
</div>
</transition>
</div>
<div v-for="(session, id) in messagesList" :key='id'>
<div v-if="session.role == 'user'">
<usermsg :content="session.content" :mentioned_items="session.mentioned_items" :images="session.images" :attachments="session.attachments" :embeddedMode="embeddedMode"></usermsg>
</div>
<div v-if="session.role == 'assistant'">
<botmsg :content="session.content" :session="session" :user-query="getUserQuery(id)" @scroll-bottom="scrollToBottom"
:isFirstEnter="isFirstEnter" :embeddedMode="embeddedMode"></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>
<transition name="scroll-btn-fade">
<div v-show="userHasScrolledUp" class="scroll-to-bottom-btn" @click="onClickScrollToBottom">
<t-icon name="chevron-down" size="20px" />
</div>
</transition>
<div class="input-container" :class="{ 'is-embedded': embeddedMode }">
<InputField
ref="inputFieldRef"
@send-msg="(query, modelId, mentionedItems, imageFiles, attachmentFiles) => sendMsg(query, modelId, mentionedItems, imageFiles, attachmentFiles)"
@stop-generation="handleStopGeneration"
:isReplying="isReplying"
:sessionId="session_id"
:assistantMessageId="currentAssistantMessageId"
:embeddedMode="embeddedMode"
></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, defineProps } 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 { getSuggestedQuestions } from "@/api/agent/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 props = defineProps({
session_id: { type: String, default: '' },
agentId: { type: String, default: '' },
kbIds: { type: Array, default: () => [] },
embeddedMode: { type: Boolean, default: false }
});
const usemenuStore = useMenuStore();
const useSettingsStoreInstance = useSettingsStore();
const uiStore = useUIStore();
const { navigateToKnowledgeBaseList } = useKnowledgeBaseCreationNavigation();
const { t } = useI18n();
const { menuArr, isFirstSession, firstQuery, firstMentionedItems, firstModelId, firstImageFiles, firstAttachmentFiles } = storeToRefs(usemenuStore);
const { output, onChunk, isStreaming, isLoading, error, startStream, stopStream } = useStream();
const route = useRoute();
const router = useRouter();
const session_id = ref(props.session_id || route.params.chatid);
const sessionData = ref(null);
const inputFieldRef = ref();
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);
const historyLoading = ref(true);
let fullContent = ref('')
let userquery = ref('')
const scrollContainer = ref(null)
const userHasScrolledUp = ref(false)
const SCROLL_BOTTOM_THRESHOLD = 80
const isNearBottom = () => {
if (!scrollContainer.value) return true;
const { scrollTop, scrollHeight, clientHeight } = scrollContainer.value;
return scrollHeight - scrollTop - clientHeight < SCROLL_BOTTOM_THRESHOLD;
}
const handleKBEditorSuccess = (kbId) => {
navigateToKnowledgeBaseList(kbId)
}
// ===== 推荐问题 =====
const suggestedQuestions = ref([]);
const suggestedQuestionsLoading = ref(false);
let suggestedQuestionsFetchId = 0; // 用于取消过时的请求
let suggestedDebounceTimer = null;
const fetchSuggestedQuestions = async () => {
const fetchId = ++suggestedQuestionsFetchId;
suggestedQuestionsLoading.value = true;
// 加载期间保留旧数据,不清空,避免布局抖动
try {
const agentId = props.embeddedMode ? props.agentId : useSettingsStoreInstance.selectedAgentId;
if (!agentId) return;
const selectedKBs = props.embeddedMode ? props.kbIds : useSettingsStoreInstance.getSelectedKnowledgeBases();
const selectedFiles = props.embeddedMode ? [] : useSettingsStoreInstance.getSelectedFiles();
const res = await getSuggestedQuestions(agentId, {
knowledge_base_ids: selectedKBs.length > 0 ? selectedKBs : undefined,
knowledge_ids: selectedFiles.length > 0 ? selectedFiles : undefined,
limit: 6,
});
if (fetchId === suggestedQuestionsFetchId) {
suggestedQuestions.value = res?.data?.questions || [];
}
} catch (err) {
console.warn('[SuggestedQuestions] Failed to fetch:', err);
if (fetchId === suggestedQuestionsFetchId) {
suggestedQuestions.value = [];
}
} finally {
if (fetchId === suggestedQuestionsFetchId) {
suggestedQuestionsLoading.value = false;
}
}
};
const handleSuggestedQuestionClick = (question) => {
if (inputFieldRef.value?.triggerSend) {
inputFieldRef.value.triggerSend(question);
} else {
sendMsg(question);
}
};
// 防抖包装,切换知识库/文件时300ms内不重复请求
const debouncedFetchSuggestions = () => {
if (suggestedDebounceTimer) clearTimeout(suggestedDebounceTimer);
suggestedDebounceTimer = setTimeout(() => { fetchSuggestedQuestions(); }, 300);
};
// 监听 Agent / 知识库 / 文件切换,重新获取推荐问题
watch(
() => useSettingsStoreInstance.selectedAgentId,
debouncedFetchSuggestions,
);
watch(
() => useSettingsStoreInstance.settings.selectedKnowledgeBases,
debouncedFetchSuggestions,
{ deep: true },
);
watch(
() => useSettingsStoreInstance.settings.selectedFiles,
debouncedFetchSuggestions,
{ deep: true },
);
function fileToBase64(file) {
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onload = () => resolve(reader.result);
reader.onerror = reject;
reader.readAsDataURL(file);
});
}
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;
// 切换会话时,重置状态
historyLoading.value = true;
loading.value = false;
isReplying.value = false;
currentAssistantMessageId.value = '';
userHasScrolledUp.value = false;
checkmenuTitle(session_id.value)
let data = {
session_id: session_id.value,
created_at: '',
limit: limit.value
}
getmsgList(data);
}
});
const scrollToBottom = (force = false) => {
if (!force && userHasScrolledUp.value) return;
nextTick(() => {
if (scrollContainer.value) {
scrollContainer.value.scrollTop = scrollContainer.value.scrollHeight;
}
})
}
const onClickScrollToBottom = () => {
userHasScrolledUp.value = false;
scrollToBottom(true);
}
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 debouncedScrollTop = debounce(onChatScrollTop, 500);
const handleScroll = () => {
userHasScrolledUp.value = !isNearBottom();
debouncedScrollTop();
};
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);
}
}).finally(() => {
historyLoading.value = false;
})
}
// 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, isFallback = false, agentDurationMs = 0) => {
const events = [];
// Process agent steps if they exist
if (agentSteps && Array.isArray(agentSteps) && agentSteps.length > 0) {
agentSteps.forEach((step) => {
// Compute step timestamp (milliseconds) from step.timestamp if available
const stepTimestamp = step.timestamp ? new Date(step.timestamp).getTime() : 0;
// Add thinking event if thought content exists.
// For tool-calling rounds, providers like MiMo / DeepSeek thinking-mode
// emit reasoning into the OpenAI-protocol `reasoning_content` field
// rather than visible `content`, so step.thought is often empty even
// though the model did reason. Fall back to step.reasoning_content so
// the historical step card mirrors what the user saw live.
const thoughtText = (step.thought && step.thought.trim())
? step.thought
: (step.reasoning_content && step.reasoning_content.trim())
? step.reasoning_content
: '';
if (thoughtText) {
events.push({
type: 'thinking',
event_id: `step-${step.iteration}-thought`,
content: thoughtText,
done: true,
thinking: false,
timestamp: stepTimestamp || undefined,
// Extract duration from step if available
duration_ms: step.duration || undefined,
});
}
// Add tool call and result events (skip final_answer as its content is in the answer event)
if (step.tool_calls && Array.isArray(step.tool_calls)) {
step.tool_calls.forEach((toolCall) => {
if (toolCall.name === 'final_answer') return; // Skip - shown as answer event
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,
timestamp: stepTimestamp || 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,
});
});
}
});
}
// Add agent_complete event with duration info (before answer event)
if (agentDurationMs > 0) {
events.push({
type: 'agent_complete',
total_duration_ms: agentDurationMs,
});
}
// 总是添加 answer 事件如果有内容(无论是否有 agent_steps)
// 这样可以确保最终答案始终被渲染
if (messageContent && messageContent.trim()) {
const answerEvent = {
type: 'answer',
content: messageContent,
done: true
};
if (isFallback) answerEvent.is_fallback = true;
events.push(answerEvent);
} else if (isCompleted) {
// 消息已完成但 content 为空:说明是"停止时尚未产出最终答案"的场景。
// Push 一个 stop 事件,让 AgentStreamDisplay 的 isConversationDone 返回 true,
// 但不产生 answer 内容,也就不会渲染最终答案的 toolbar。与实时 stop 分支保持一致。
events.push({
type: 'stop',
timestamp: Date.now(),
reason: 'user_requested'
});
}
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, item.is_fallback, item.agent_duration_ms || 0);
// 隐藏最终答案内容,因为它已经包含在 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;
item.thinking = false;
} else if (item.content.includes('<\/think>')) {
// 历史消息中包含完整的 <think>...</think> 标签,说明 thinking 已完成
item.showThink = true;
item.thinking = false; // 关键:标记 thinking 已完成,使 deepThink 默认折叠
const index = item.content.trim().lastIndexOf('<\/think>');
item.thinkContent = item.content.trim().substring(0, index).replace('<think>', '').trim();
item.content = item.content.trim().substring(index + 8);
} else if (item.content.includes('<think>')) {
// 内容包含 <think> 但没有 </think>,说明 thinking 还在进行中(不太可能出现在历史消息中)
item.showThink = true;
item.thinking = true;
item.thinkContent = item.content.replace('<think>', '').trim();
item.content = '';
}
}
// 非 Agent 模式下若 content 为空(例如用户停止时尚未产出任何文字),
// 保持为空;botmsg.vue 会因 hasActualContent=false 不渲染内容区和 toolbar。
// 此前这里会兜底为 "chat.cannotAnswer",会让停止场景显示误导性文案并出现复制按钮。
messagesList.unshift(item);
if (isFirstEnter.value) {
scrollToBottom(true);
} 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 = '', mentionedItems = [], imageFiles = [], attachmentFiles = []) => {
userquery.value = value;
isReplying.value = true;
loading.value = true;
// Convert images to base64 data URIs for backend processing and local display
let imageAttachments = [];
let userImages = [];
if (imageFiles && imageFiles.length > 0) {
try {
for (const file of imageFiles) {
const dataURI = await fileToBase64(file);
imageAttachments.push({ data: dataURI });
userImages.push({ url: dataURI });
}
} catch (e) {
console.error('[Image] Failed to read images:', e);
loading.value = false;
isReplying.value = false;
return;
}
}
// Convert attachment files to base64 for backend processing
let attachmentUploads = [];
if (attachmentFiles && attachmentFiles.length > 0) {
try {
for (const attachment of attachmentFiles) {
const reader = new FileReader();
const base64Promise = new Promise((resolve, reject) => {
reader.onload = () => {
const result = reader.result;
// Extract base64 content (remove data:...;base64, prefix)
const base64 = result.split(',')[1];
resolve(base64);
};
reader.onerror = reject;
reader.readAsDataURL(attachment.file);
});
const base64Data = await base64Promise;
attachmentUploads.push({
data: base64Data,
file_name: attachment.name,
file_size: attachment.size
});
}
} catch (e) {
console.error('[Attachment] Failed to read attachments:', e);
loading.value = false;
isReplying.value = false;
return;
}
}
// 将@提及的知识库和文件信息存入用户消息
messagesList.push({ content: value, role: 'user', mentioned_items: mentionedItems, images: userImages, attachments: attachmentFiles.map(a => ({ file_name: a.name, file_size: a.size, file_type: '.' + a.name.split('.').pop()?.toLowerCase() })), channel: 'web' });
userHasScrolledUp.value = false;
scrollToBottom(true);
// Get agent mode status from settings store
const agentEnabled = props.embeddedMode ? (props.agentId && props.agentId !== 'builtin-quick-answer') : useSettingsStoreInstance.isAgentEnabled;
// Get web search status from settings store
const webSearchEnabled = props.embeddedMode ? false : useSettingsStoreInstance.isWebSearchEnabled;
// Memory toggle is now a server-side per-user preference (see PUT
// /auth/me/preferences). For the normal logged-in chat we leave the
// field unset so the backend reads `user.preferences.enable_memory`;
// for embedded widgets we still send an explicit `false` so a user's
// personal "memory on" setting doesn't leak into a KB-embed context.
const enableMemoryOverride = props.embeddedMode ? false : undefined;
// Get knowledge_base_ids from settings store (selected by user via KnowledgeBaseSelector)
// Merge @mentioned KB/file IDs so retrieval uses the same targets user @mentioned (including shared KBs)
const sidebarKbIds = props.embeddedMode ? props.kbIds : (useSettingsStoreInstance.settings.selectedKnowledgeBases || []);
const sidebarFileIds = props.embeddedMode ? [] : (useSettingsStoreInstance.settings.selectedFiles || []);
const kbIdSet = new Set(sidebarKbIds);
const fileIdSet = new Set(sidebarFileIds);
for (const item of mentionedItems || []) {
if (!item?.id) continue;
if (item.type === 'kb' && !kbIdSet.has(item.id)) {
kbIdSet.add(item.id);
} else if (item.type === 'file' && !fileIdSet.has(item.id)) {
fileIdSet.add(item.id);
}
}
const kbIds = [...kbIdSet];
const knowledgeIds = [...fileIdSet];
// Get selected agent ID (backend resolves shared agent and its tenant from share relation)
const selectedAgentId = props.embeddedMode ? props.agentId : (useSettingsStoreInstance.selectedAgentId || '');
// 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 = props.embeddedMode ? [] : (useSettingsStoreInstance.settings.selectedMCPServices || []);
await startStream({
session_id: session_id.value,
knowledge_base_ids: kbIds,
knowledge_ids: knowledgeIds,
agent_enabled: agentEnabled,
agent_id: selectedAgentId,
web_search_enabled: webSearchEnabled,
enable_memory: enableMemoryOverride,
summary_model_id: modelId,
mcp_service_ids: mcpServiceIds,
mentioned_items: mentionedItems,
images: imageAttachments.length > 0 ? imageAttachments : undefined,
attachment_uploads: attachmentUploads.length > 0 ? attachmentUploads : undefined,
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 模式的响应
// 注意:'answer', 'complete', 'references' 类型可能在两种模式下都存在
// 只有 'thinking', 'tool_call', 'tool_result', 'reflection' 是 Agent 专有的
const isAgentOnlyResponse = data.response_type === 'thinking' ||
data.response_type === 'tool_call' ||
data.response_type === 'tool_result' ||
data.response_type === 'reflection';
// 检查当前消息是否已经是 Agent 模式
const lastMessage = messagesList[messagesList.length - 1];
const isCurrentlyAgentMode = lastMessage?.isAgentMode === true;
// 如果是 Agent 专有的响应类型,或者当前消息已经是 Agent 模式,则走 Agent 处理
const shouldHandleAsAgent = isAgentOnlyResponse || isCurrentlyAgentMode;
// 处理 references 事件 - 在两种模式下都需要处理,但不改变模式
if (data.response_type === 'references') {
// 如果当前是 Agent 模式,走 Agent 处理
if (isCurrentlyAgentMode) {
handleAgentChunk(data);
return;
}
// 非 Agent 模式:将 references 保存到消息中供 botmsg 使用
let existingMessage = messagesList.findLast((item) => item.request_id === data.id || item.id === data.id);
// 如果消息还不存在,先创建一个空的 assistant 消息
if (!existingMessage) {
existingMessage = {
id: data.id,
request_id: data.id,
role: 'assistant',
content: '',
showThink: false,
thinkContent: '',
thinking: false,
is_completed: false,
knowledge_references: []
};
messagesList.push(existingMessage);
loading.value = false; // 消息已创建,关闭 loading
scrollToBottom(true);
}
existingMessage.knowledge_references = data.knowledge_references || data.data?.references || [];
console.log('[References] Saved to message, count:', existingMessage.knowledge_references.length);
return;
}
// Agent 模式处理(包括 stop 事件)
if (shouldHandleAsAgent) {
// 在 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 处理逻辑(非 Agent 模式)
// answer 内容中可能包含 <think>...</think> 标签
// 非 Agent 模式下的 stop 事件:只更新状态,不把后端附带的 "Generation stopped by user"
// 文案拼进 content,保留用户点停止时已经流式输出的内容不变。
if (data.response_type === 'stop') {
console.log('[Stop Event] Non-agent generation stopped');
const stoppedMessage = messagesList.findLast((item) => {
if (item.request_id === data.id) return true;
return item.id === data.id;
});
if (stoppedMessage) {
stoppedMessage.is_completed = true;
}
loading.value = false;
isReplying.value = false;
fullContent.value = '';
currentAssistantMessageId.value = '';
return;
}
// 检查消息是否已经完成,如果已完成则忽略后续的完成事件(防止空内容覆盖)
const existingMessage = messagesList.findLast((item) => {
if (item.request_id === data.id) {
return true
}
return item.id === data.id;
});
// 如果消息已完成且当前事件是完成事件(done=true 且无内容),直接忽略
if (existingMessage?.is_completed && data.done && !data.content) {
console.log('[Non-Agent] Ignoring duplicate completion event for completed message');
return;
}
fullContent.value += data.content;
let obj = { ...data, content: '', role: 'assistant', showThink: false, is_completed: false };
// 检查是否为 fallback 回答(未从知识库检索到内容)
if (data.data?.is_fallback) {
obj.is_fallback = true;
}
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;
// Use lastIndexOf to handle edge cases with multiple </think> occurrences,
// consistent with history loading logic (line 280)
const index = fullContent.value.lastIndexOf('<\/think>');
obj.thinkContent = fullContent.value.substring(0, index).replace('<think>', '').trim();
obj.content = fullContent.value.substring(index + 8).trim();
} else {
obj.content = fullContent.value;
}
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(true);
// 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' || data.response_type === 'tool_approval_required')) {
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_approval_required': {
if (!message.agentEventStream) message.agentEventStream = [];
const d = data.data || {};
message.agentEventStream.push({
type: 'tool_approval_required',
pending_id: d.pending_id,
service_name: d.service_name,
mcp_tool_name: d.mcp_tool_name,
description: d.description,
args_json: d.args_json,
timeout_seconds: d.timeout_seconds,
requested_at: d.requested_at,
tool_call_id: d.tool_call_id,
resolved: false,
});
break;
}
case 'tool_approval_resolved': {
const d = data.data || {};
const pid = d.pending_id;
const ev = message.agentEventStream?.find(
(e) => e.type === 'tool_approval_required' && e.pending_id === pid
);
if (ev) {
ev.resolved = true;
ev.approved = d.approved;
ev.resolve_reason = d.reason;
ev.timed_out = d.timed_out;
ev.canceled = d.canceled;
}
break;
}
case 'tool_call':
// Skip final_answer tool call from event stream - its content appears as answer events
if (data.data && data.data.tool_name === 'final_answer') {
break;
}
// 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) {
const errorMsg = data.content || t('chat.processError');
message.content = errorMsg;
isReplying.value = false;
loading.value = false;
MessagePlugin.error(errorMsg);
console.error('[Chat Error]', errorMsg);
}
} else if (data.response_type === 'error') {
// Generic error without tool context
const errorMsg = data.content || t('chat.processError');
message.content = errorMsg;
isReplying.value = false;
loading.value = false;
MessagePlugin.error(errorMsg);
console.error('[Chat Error]', errorMsg);
}
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;
console.log('[Answer Event] Received:', {
has_content: !!data.content,
content_length: data.content?.length || 0,
done: data.done,
current_message_content_length: message.content?.length || 0
});
// 只有当有实际内容时才追加,避免空内容覆盖
if (data.content) {
message.content = (message.content || '') + data.content;
fullContent.value += data.content;
console.log('[Answer] Content appended, new length:', message.content.length);
}
// 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);
console.log('[Answer] Created new answer event in stream');
}
// 只有当有实际内容时才更新 answerEvent.content
if (data.content) {
answerEvent.content = message.content;
console.log('[Answer] answerEvent.content updated, length:', answerEvent.content.length);
}
// 检查是否为 fallback 回答
if (data.data?.is_fallback) {
answerEvent.is_fallback = true;
message.is_fallback = true;
}
// 只在第一次收到 done:true 时标记完成,忽略后续重复的完成事件
if (data.done && !answerEvent.done) {
answerEvent.done = true;
console.log('[Agent] Answer done, content length:', message.content?.length || 0, 'answerEvent.content length:', answerEvent.content?.length || 0);
// 完成 - 关闭所有状态
loading.value = false;
isReplying.value = false;
fullContent.value = '';
// 清空当前 assistant message ID
currentAssistantMessageId.value = '';
// 标题生成已改为异步事件推送,不再需要在这里手动调用
// 如果标题还未生成,前端会通过 SSE 事件接收
} else if (data.done && answerEvent.done) {
console.log('[Answer] Ignoring duplicate done event, current content preserved:', answerEvent.content?.length || 0);
}
break;
case 'complete':
// 整个流式响应完成事件 - 确保状态正确关闭
console.log('[Agent] Complete event received');
loading.value = false;
isReplying.value = false;
message.is_completed = true;
fullContent.value = '';
currentAssistantMessageId.value = '';
// 将 total_duration_ms 存入事件流供 AgentStreamDisplay 使用
if (message.agentEventStream) {
message.agentEventStream.push({
type: 'agent_complete',
total_duration_ms: data.data?.total_duration_ms || 0,
total_steps: data.data?.total_steps || 0,
});
}
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;
// 更新 fallback 状态
if (payload.is_fallback) {
message.is_fallback = true;
}
// 更新完成状态
if (payload.is_completed) {
message.is_completed = true;
}
} else {
messagesList.push(payload);
}
scrollToBottom();
}
const handleSessionCleared = (e) => {
if (e.detail?.sessionId === session_id.value) {
messagesList.splice(0);
created_at.value = '';
}
};
onMounted(async () => {
window.addEventListener('session-messages-cleared', handleSessionCleared);
messagesList.splice(0);
// 若从智能体列表点击共享智能体进入,URL 带 agent_id 与 source_tenant_id,同步到 store
const agentIdFromQuery = props.embeddedAgentId || (route.query.agent_id && String(route.query.agent_id));
const sourceTenantIdFromQuery = route.query.source_tenant_id && String(route.query.source_tenant_id);
if (agentIdFromQuery && sourceTenantIdFromQuery) {
useSettingsStoreInstance.selectAgent(agentIdFromQuery, sourceTenantIdFromQuery);
} else if (agentIdFromQuery) {
useSettingsStoreInstance.selectAgent(agentIdFromQuery, null);
}
if (props.embeddedKbIds && props.embeddedKbIds.length > 0) {
useSettingsStoreInstance.selectKnowledgeBases(props.embeddedKbIds);
}
// 初始化状态:加载历史消息时不应显示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;
historyLoading.value = false;
sendMsg(firstQuery.value, firstModelId.value || '', firstMentionedItems.value || [], firstImageFiles.value || [], firstAttachmentFiles.value || []);
usemenuStore.changeFirstQuery('', [], '', [], []);
} else {
scrollLock.value = false;
let data = {
session_id: session_id.value,
created_at: '',
limit: limit.value
}
getmsgList(data)
}
// 初始加载推荐问题
fetchSuggestedQuestions();
})
const clearData = () => {
stopStream();
isReplying.value = false;
fullContent.value = '';
userquery.value = '';
}
onUnmounted(() => {
window.removeEventListener('session-messages-cleared', handleSessionCleared);
});
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;
// The parent .platform-route-outlet is a flex column with min-height:0
// and overflow:hidden — we also need min-height:0 here so that our
// own flex:1 child (.chat_scroll_box) can shrink below its content
// height and scroll instead of pushing .input-container out of view.
min-height: 0;
position: relative;
display: flex;
flex-direction: column;
align-items: center;
max-width: calc(100vw - 260px);
min-width: 400px;
&.is-sidebar-collapsed {
max-width: calc(100vw - 60px);
}
&.is-embedded {
max-width: 100%;
min-width: 100%;
padding: 0;
overflow-x: hidden;
}
&.is-embedded :deep(.answers-input) {
transform: translateX(0);
width: 100%;
left: 0;
display: flex;
justify-content: center;
}
:deep(.answers-input) {
position: static;
transform: translateX(0);
.t-textarea__inner {
width: 100% !important;
}
}
}
.chat_scroll_box {
flex: 1;
// Without min-height: 0, a flex-column child defaults to min-height: auto
// and expands to fit all inner content. When there are many messages,
// that pushes .input-container out of the viewport. Clamping min-height
// to 0 lets overflow-y: auto take effect so the messages scroll inside
// this box instead of stretching it.
min-height: 0;
width: 100%;
overflow-y: auto;
&::-webkit-scrollbar {
width: 0;
height: 0;
color: transparent;
}
}
.scroll-to-bottom-btn {
position: absolute;
left: 50%;
transform: translateX(-50%);
bottom: 140px;
z-index: 10;
width: 36px;
height: 36px;
border-radius: 50%;
background: var(--td-bg-color-container);
border: 1px solid var(--td-component-stroke);
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
display: flex;
align-items: center;
justify-content: center;
cursor: pointer;
color: var(--td-text-color-secondary);
transition: all 0.2s ease;
&:hover {
background: var(--td-bg-color-container-hover);
color: var(--td-text-color-primary);
box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
}
&:active {
transform: translateX(-50%) scale(0.92);
}
}
.scroll-btn-fade-enter-active,
.scroll-btn-fade-leave-active {
transition: opacity 0.2s ease, transform 0.2s ease;
}
.scroll-btn-fade-enter-from,
.scroll-btn-fade-leave-to {
opacity: 0;
transform: translateX(-50%) translateY(8px);
}
.agent-mode-indicator {
display: flex;
align-items: center;
gap: 8px;
padding: 8px 16px;
background: var(--td-brand-color-light);
border: 1px solid var(--td-brand-color-focus);
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: var(--td-brand-color);
flex: 1;
}
}
@keyframes contentFadeIn {
from { opacity: 0; transform: translateY(6px); }
to { opacity: 1; transform: translateY(0); }
}
.msg-skeleton-list {
display: flex;
flex-direction: column;
gap: 20px;
max-width: 800px;
padding: 16px 0;
animation: contentFadeIn 0.3s ease-out;
}
.msg-skeleton-user {
display: flex;
justify-content: flex-end;
}
.msg-skeleton-bot {
display: flex;
flex-direction: column;
gap: 8px;
padding-left: 4px;
}
.input-container {
min-height: 115px;
// Keep the input visible when messages overflow: without flex-shrink: 0
// a tall .chat_scroll_box can squeeze this container down to 0 height.
flex-shrink: 0;
margin: 16px auto 4px;
width: 100%;
max-width: 800px;
box-sizing: border-box;
&.is-embedded {
max-width: 100%;
width: 100%;
margin: 0;
overflow-x: hidden;
}
}
.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: var(--td-brand-color);
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);
}
}
.suggested-questions-container {
display: flex;
flex-direction: column;
align-items: center;
padding: 32px 16px 16px;
max-width: 800px;
margin: 0 auto;
width: 100%;
min-height: 0;
transition: min-height 0.3s ease;
&.has-questions {
min-height: 80px;
}
}
.suggested-questions-inner {
display: flex;
flex-direction: column;
align-items: center;
width: 100%;
animation: contentFadeIn 0.3s ease-out;
}
.sq-fade-enter-active,
.sq-fade-leave-active {
transition: opacity 0.25s ease;
}
.sq-fade-enter-from,
.sq-fade-leave-to {
opacity: 0;
}
.suggested-questions-title {
font-size: 14px;
color: var(--td-text-color-secondary);
margin-bottom: 16px;
font-weight: 500;
}
.suggested-questions-grid {
display: flex;
flex-wrap: wrap;
gap: 10px;
justify-content: center;
width: 100%;
}
.suggested-question-card {
display: flex;
align-items: center;
gap: 6px;
padding: 10px 16px;
border-radius: 20px;
border: 1px solid var(--td-component-stroke);
background: var(--td-bg-color-container);
cursor: pointer;
transition: all 0.2s ease;
max-width: 100%;
&:hover {
border-color: var(--td-brand-color);
background: var(--td-brand-color-light);
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.06);
}
}
.suggested-question-text {
font-size: 13px;
color: var(--td-text-color-primary);
line-height: 1.4;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.suggested-question-badge {
font-size: 10px;
padding: 1px 5px;
border-radius: 4px;
flex-shrink: 0;
font-weight: 500;
&.faq {
background: var(--td-success-color-1);
color: var(--td-success-color);
}
}
</style>