tanxing
/
deep-searcher
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

fix: 修复deep_search.py中新建collection无法获取的问题 

fix: 修改错误的脚注样式
main
tanxing 3 days ago
parent
e0256a3fe0
commit
8bab5b066e
2 changed files with 407 additions and 404 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 29
      deepsearcher/agent/deep_search.py
  2. 782
      deepsearcher/templates/static/js/app.js

29
deepsearcher/agent/deep_search.py
View File

@ -92,14 +92,13 @@ SUMMARY_PROMPT = """
如果检索到的信息不足以回答问题，你应该使用你的知识来进行扩展补充。 如果检索到的信息不足以回答问题，你应该使用你的知识来进行扩展补充。
注意，不要逐个回答问题，而是应该综合所有问题和信息，生成一个完整的回答。 注意，不要逐个回答问题，而是应该综合所有问题和信息，生成一个完整的回答。
同时，你应该根据提供的信息生成文内引用"[^index]"(markdown文内引用)。 同时，你应该根据提供的信息生成文内引用"[^index]"(markdown文内引用)。
如果你自己提供的信息需要使用"[^0]"引用，即你提供的信息使用固定index=0。 来自<chunk><reference>的引用序号从[^index]从index=1开始，来源需要与前文<reference>中的"id"一致。
来自<chunk><reference>的引用序号从[^index]从index=1开始，来源需要与前文<reference>中的"href"一致 不需要对每个<chunk>分配一个引用，而是相同<reference>的<chunk>共用引用，并确保每一个<reference>都被引用。
不需要对每个<chunk>分配一个引用，而是相同<reference>的<chunk>共用一个引用。
另外，如果回答的内容文内引用需要引用多个<reference>，请添加多个[^index]到句尾。 另外，如果回答的内容文内引用需要引用多个<reference>，请添加多个[^index]到句尾。
<EXAMPLE> <EXAMPLE>
"XGBoost是非常强大的集成学习模型。[^1]但是XGBoost的缺点是计算复杂度高，需要大量的计算资源。[^0]" "XGBoost是非常强大的集成学习模型。[^1]但是XGBoost的缺点是计算复杂度高，需要大量的计算资源。[^2]"
</EXAMPLE> </EXAMPLE>
@ -152,10 +151,6 @@ class DeepSearch(BaseAgent):
self.vector_db = vector_db self.vector_db = vector_db
self.max_iter = max_iter self.max_iter = max_iter
self.route_collection = route_collection self.route_collection = route_collection
self.all_collections = [
collection_info.collection_name
for collection_info in self.vector_db.list_collections(dim=embedding_model.dimension)
]
self.text_window_splitter = text_window_splitter self.text_window_splitter = text_window_splitter
def invoke(self, query: str, dim: int, **kwargs) -> list[str]: def invoke(self, query: str, dim: int, **kwargs) -> list[str]:
@ -227,7 +222,10 @@ class DeepSearch(BaseAgent):
query=query, dim=self.embedding_model.dimension query=query, dim=self.embedding_model.dimension
) )
else: else:
selected_collections = self.all_collections selected_collections = [
collection_info.collection_name
for collection_info in self.vector_db.list_collections(dim=self.embedding_model.dimension)
]
all_retrieved_results = [] all_retrieved_results = []
query_vector = self.embedding_model.embed_query(query) query_vector = self.embedding_model.embed_query(query)
@ -394,7 +392,7 @@ class DeepSearch(BaseAgent):
if not all_retrieved_results or len(all_retrieved_results) == 0: if not all_retrieved_results or len(all_retrieved_results) == 0:
send_info(f"'{original_query}'没能找到更多信息！") send_info(f"'{original_query}'没能找到更多信息！")
return "", [] return "", []
chunks, refs = self._format_chunks(all_retrieved_results) chunks, refs = self._format_chunks(all_retrieved_results, with_chunk_id=False)
send_info(f"正在总结 {len(all_retrieved_results)} 个查找到的文档片段") send_info(f"正在总结 {len(all_retrieved_results)} 个查找到的文档片段")
summary_prompt = SUMMARY_PROMPT.format( summary_prompt = SUMMARY_PROMPT.format(
original_query=original_query, original_query=original_query,
@ -406,13 +404,13 @@ class DeepSearch(BaseAgent):
send_answer(response) send_answer(response)
return response, all_retrieved_results return response, all_retrieved_results
def _format_chunks(self, retrieved_results: list[RetrievalResult]) -> tuple[str, str]: def _format_chunks(self, retrieved_results: list[RetrievalResult], with_chunk_id: bool = True) -> tuple[str, str]:
# 以referecen为key，把chunk放到字典中 # 以referecen为key，把chunk放到字典中
ref_dict = defaultdict(list) ref_dict = defaultdict(list)
for result in retrieved_results: for result in retrieved_results:
ref_dict[result.reference].append(result.text) ref_dict[result.reference].append(result.text)
formated_chunks = [] formated_chunks = []
formated_refs = ["\n\n[^0]: AI 生成\n"] formated_refs = ["\n\n"]
chunk_count = 0 chunk_count = 0
for i, reference in enumerate(ref_dict): for i, reference in enumerate(ref_dict):
formated_chunk = "".join( formated_chunk = "".join(
@ -421,6 +419,11 @@ class DeepSearch(BaseAgent):
f"<reference id='{i + 1}' href='{reference}'>" + f"<reference id='{i + 1}' href='{reference}'>" +
f"<chunk id='{j + 1 + chunk_count}'>\n{chunk}\n</chunk id='{j + 1 + chunk_count}'>" + f"<chunk id='{j + 1 + chunk_count}'>\n{chunk}\n</chunk id='{j + 1 + chunk_count}'>" +
f"</reference id='{i + 1}'>\n" f"</reference id='{i + 1}'>\n"
)
if with_chunk_id else (
f"<reference id='{i + 1}' href='{reference}'>" +
f"<chunk>\n{chunk}\n</chunk>" +
f"</reference id='{i + 1}'>\n"
) )
for j, chunk in enumerate(ref_dict[reference]) for j, chunk in enumerate(ref_dict[reference])
] ]
@ -428,7 +431,7 @@ class DeepSearch(BaseAgent):
print(formated_chunk) print(formated_chunk)
formated_chunks.append(formated_chunk) formated_chunks.append(formated_chunk)
chunk_count += len(ref_dict[reference]) chunk_count += len(ref_dict[reference])
formated_refs.append(f"[^{i + 1}]: " + str(reference) + "\n") formated_refs.append(f"[{i + 1}]: " + str(reference) + "\n")
formated_chunks = "".join(formated_chunks) formated_chunks = "".join(formated_chunks)
formated_refs = "".join(formated_refs) formated_refs = "".join(formated_refs)
return formated_chunks, formated_refs return formated_chunks, formated_refs

782
deepsearcher/templates/static/js/app.js
View File

@ -4,481 +4,481 @@ let isStreaming = false;
// 工具函数：显示状态信息 // 工具函数：显示状态信息
function showStatus(elementId, message, type) { function showStatus(elementId, message, type) {
const statusElement = document.getElementById(elementId); const statusElement = document.getElementById(elementId);
// 清除之前的类型类 // 清除之前的类型类
statusElement.classList.remove( statusElement.classList.remove(
'status-success', 'status-success',
'status-error', 'status-error',
'status-loading' 'status-loading'
); );
// 添加新的类型类 // 添加新的类型类
if (type === 'success') { if (type === 'success') {
statusElement.classList.add('status-success'); statusElement.classList.add('status-success');
statusElement.innerHTML = message; statusElement.innerHTML = message;
} else if (type === 'error') { } else if (type === 'error') {
statusElement.classList.add('status-error'); statusElement.classList.add('status-error');
statusElement.innerHTML = message; statusElement.innerHTML = message;
} else if (type === 'loading') { } else if (type === 'loading') {
statusElement.classList.add('status-loading'); statusElement.classList.add('status-loading');
statusElement.innerHTML = `<div class="loading-spinner"></div>${message}`; statusElement.innerHTML = `<div class="loading-spinner"></div>${message}`;
} }
statusElement.classList.add('visible'); statusElement.classList.add('visible');
} }
// 工具函数：显示消息流 // 工具函数：显示消息流
function displayMessages(messages) { function displayMessages(messages) {
const container = document.getElementById('messageContainer'); const container = document.getElementById('messageContainer');
container.innerHTML = ''; container.innerHTML = '';
messages.forEach((message) => { messages.forEach((message) => {
addMessageToContainer(message); addMessageToContainer(message);
}); });
// 滚动到底部 // 滚动到底部
container.scrollTop = container.scrollHeight; container.scrollTop = container.scrollHeight;
} }
// 工具函数：添加单个消息到容器 // 工具函数：添加单个消息到容器
function addMessageToContainer(message) { function addMessageToContainer(message) {
console.log('Adding message to container:', message); console.log('Adding message to container:', message);
const container = document.getElementById('messageContainer'); const container = document.getElementById('messageContainer');
if (!container) { if (!container) {
console.error('Message container not found!'); console.error('Message container not found!');
return; return;
} }
const messageElement = document.createElement('div'); const messageElement = document.createElement('div');
messageElement.className = `message message-${message.type}`; messageElement.className = `message message-${message.type}`;
const contentElement = document.createElement('div'); const contentElement = document.createElement('div');
contentElement.textContent = message.content; contentElement.textContent = message.content;
messageElement.appendChild(contentElement); messageElement.appendChild(contentElement);
// 只有在有有效时间戳时才显示时间 // 只有在有有效时间戳时才显示时间
if (message.timestamp && !isNaN(message.timestamp)) { if (message.timestamp && !isNaN(message.timestamp)) {
const date = new Date(message.timestamp * 1000); const date = new Date(message.timestamp * 1000);
if (!isNaN(date.getTime())) { if (!isNaN(date.getTime())) {
const timestampElement = document.createElement('div'); const timestampElement = document.createElement('div');
timestampElement.className = 'message-timestamp'; timestampElement.className = 'message-timestamp';
timestampElement.textContent = date.toLocaleTimeString(); timestampElement.textContent = date.toLocaleTimeString();
messageElement.appendChild(timestampElement); messageElement.appendChild(timestampElement);
}
}
container.appendChild(messageElement);
// 确保处理过程容器是可见的
const processContainer = document.getElementById('processResult');
if (processContainer && !processContainer.classList.contains('visible')) {
processContainer.classList.add('visible');
} }
}
container.appendChild(messageElement); // 滚动到底部
container.scrollTop = container.scrollHeight;
// 确保处理过程容器是可见的
const processContainer = document.getElementById('processResult'); console.log(
if (processContainer && !processContainer.classList.contains('visible')) { 'Message added successfully, container now has',
processContainer.classList.add('visible'); container.children.length,
} 'messages'
);
// 滚动到底部
container.scrollTop = container.scrollHeight;
console.log(
'Message added successfully, container now has',
container.children.length,
'messages'
);
} }
// 工具函数：隐藏状态信息 // 工具函数：隐藏状态信息
function hideStatus(elementId) { function hideStatus(elementId) {
const statusElement = document.getElementById(elementId); const statusElement = document.getElementById(elementId);
statusElement.classList.remove('visible'); statusElement.classList.remove('visible');
} }
// 工具函数：显示结果 // 工具函数：显示结果
function showResult() { function showResult() {
const resultElement = document.getElementById('queryResult'); const resultElement = document.getElementById('queryResult');
resultElement.classList.add('visible'); resultElement.classList.add('visible');
} }
// 工具函数：隐藏结果 // 工具函数：隐藏结果
function hideResult() { function hideResult() {
const resultElement = document.getElementById('queryResult'); const resultElement = document.getElementById('queryResult');
resultElement.classList.remove('visible'); resultElement.classList.remove('visible');
} }
// 工具函数：显示处理过程 // 工具函数：显示处理过程
function showProcessResult() { function showProcessResult() {
const processElement = document.getElementById('processResult'); const processElement = document.getElementById('processResult');
processElement.classList.add('visible'); processElement.classList.add('visible');
} }
// 工具函数：隐藏处理过程 // 工具函数：隐藏处理过程
function hideProcessResult() { function hideProcessResult() {
const processElement = document.getElementById('processResult'); const processElement = document.getElementById('processResult');
processElement.classList.remove('visible'); processElement.classList.remove('visible');
} }
// 工具函数：转义HTML特殊字符 // 工具函数：转义HTML特殊字符
function escapeHtml(text) { function escapeHtml(text) {
const map = { const map = {
'&': '&amp;', '&': '&amp;',
'<': '&lt;', '<': '&lt;',
'>': '&gt;', '>': '&gt;',
'"': '&quot;', '"': '&quot;',
"'": '&#039;' "'": '&#039;'
}; };
return text.replace(/[&<>"']/g, function (m) { return text.replace(/[&<>"']/g, function (m) {
return map[m]; return map[m];
}); });
} }
// 工具函数：设置按钮加载状态 // 工具函数：设置按钮加载状态
function setButtonLoading(button, loading) { function setButtonLoading(button, loading) {
if (loading) { if (loading) {
button.classList.add('loading'); button.classList.add('loading');
button.disabled = true; button.disabled = true;
} else { } else {
button.classList.remove('loading'); button.classList.remove('loading');
button.disabled = false; button.disabled = false;
} }
} }
// 工具函数：关闭EventSource连接 // 工具函数：关闭EventSource连接
function closeEventSource() { function closeEventSource() {
if (eventSource) { if (eventSource) {
console.log('Closing eventSource in closeEventSource function'); console.log('Closing eventSource in closeEventSource function');
eventSource.close(); eventSource.close();
eventSource = null; eventSource = null;
} }
if (window.currentEventSource) { if (window.currentEventSource) {
console.log('Closing currentEventSource in closeEventSource function'); console.log('Closing currentEventSource in closeEventSource function');
window.currentEventSource.close(); window.currentEventSource.close();
window.currentEventSource = null; window.currentEventSource = null;
} }
isStreaming = false; isStreaming = false;
} }
// 工具函数：处理实时消息流 // 工具函数：处理实时消息流
function handleStreamMessage(data) { function handleStreamMessage(data) {
try { try {
const message = JSON.parse(data); const message = JSON.parse(data);
switch (message.type) { switch (message.type) {
case 'connection': case 'connection':
console.log('Connected to message stream:', message.message); console.log('Connected to message stream:', message.message);
break; break;
case 'heartbeat': case 'heartbeat':
// 心跳消息，不需要处理 // 心跳消息，不需要处理
break; break;
case 'start': case 'start':
console.log('Query started:', message.content); console.log('Query started:', message.content);
showStatus('queryStatus', ' 正在处理...', 'loading'); showStatus('queryStatus', ' 正在处理...', 'loading');
addMessageToContainer(message); addMessageToContainer(message);
break; break;
case 'complete': case 'complete':
console.log('Query completed - closing connection'); console.log('Query completed - closing connection');
showStatus('queryStatus', '查询完成', 'success'); showStatus('queryStatus', '查询完成', 'success');
addMessageToContainer(message); addMessageToContainer(message);
// 关闭EventSource连接 // 关闭EventSource连接
if (window.currentEventSource) { if (window.currentEventSource) {
console.log('Closing currentEventSource'); console.log('Closing currentEventSource');
window.currentEventSource.close(); window.currentEventSource.close();
window.currentEventSource = null; window.currentEventSource = null;
} }
isStreaming = false; isStreaming = false;
setButtonLoading(document.getElementById('queryBtn'), false); setButtonLoading(document.getElementById('queryBtn'), false);
console.log( console.log(
'Query completed - connection closed, isStreaming set to false' 'Query completed - connection closed, isStreaming set to false'
); );
break; break;
case 'error': case 'error':
console.error('Error:', message.content); console.error('Error:', message.content);
showStatus('queryStatus', message.content, 'error'); showStatus('queryStatus', message.content, 'error');
addMessageToContainer(message); addMessageToContainer(message);
// 关闭EventSource连接 // 关闭EventSource连接
if (window.currentEventSource) { if (window.currentEventSource) {
window.currentEventSource.close(); window.currentEventSource.close();
window.currentEventSource = null; window.currentEventSource = null;
} }
isStreaming = false; isStreaming = false;
setButtonLoading(document.getElementById('queryBtn'), false); setButtonLoading(document.getElementById('queryBtn'), false);
break; break;
case 'info': case 'info':
// 处理信息消息 // 处理信息消息
console.log( console.log(
'Processing info message:', 'Processing info message:',
message.content.substring(0, 100) + '...' message.content.substring(0, 100) + '...'
); );
addMessageToContainer(message); addMessageToContainer(message);
break; break;
case 'answer': case 'answer':
// 处理answer类型，显示查询结果 // 处理answer类型，显示查询结果
console.log( console.log(
'Processing answer message:', 'Processing answer message:',
message.content.substring(0, 100) + '...' message.content.substring(0, 100) + '...'
); );
// 将结果内容显示在结果区域 // 将结果内容显示在结果区域
if (message.content && message.content !== '==== FINAL ANSWER====') { if (message.content && message.content !== '==== FINAL ANSWER====') {
// document.getElementById('resultText').textContent = message.content; // document.getElementById('resultText').textContent = message.content;
document.getElementById('resultText').innerHTML = marked.parse( document.getElementById('resultText').innerHTML = marked.parse(
message.content message.content
); );
showResult(); showResult();
}
// 不将answer消息添加到处理过程容器中，只显示在查询结果框中
break;
default:
console.log('Unknown message type:', message.type);
} }
// 不将answer消息添加到处理过程容器中，只显示在查询结果框中 } catch (error) {
break; console.error('Error parsing message:', error);
default:
console.log('Unknown message type:', message.type);
} }
} catch (error) {
console.error('Error parsing message:', error);
}
} }
// 工具函数：开始实时消息流 // 工具函数：开始实时消息流
function startMessageStream() { function startMessageStream() {
closeEventSource(); // 关闭之前的连接 closeEventSource(); // 关闭之前的连接
eventSource = new EventSource('/stream-messages/'); eventSource = new EventSource('/stream-messages/');
eventSource.onopen = function (event) { eventSource.onopen = function (event) {
console.log('EventSource connection opened'); console.log('EventSource connection opened');
}; };
eventSource.onmessage = function (event) { eventSource.onmessage = function (event) {
handleStreamMessage(event.data); handleStreamMessage(event.data);
}; };
eventSource.onerror = function (event) { eventSource.onerror = function (event) {
console.error('EventSource error:', event); console.error('EventSource error:', event);
if (eventSource.readyState === EventSource.CLOSED) { if (eventSource.readyState === EventSource.CLOSED) {
console.log('EventSource connection closed'); console.log('EventSource connection closed');
} }
}; };
} }
// 加载文件功能 // 加载文件功能
document document
.getElementById('loadFilesBtn') .getElementById('loadFilesBtn')
.addEventListener('click', async function () { .addEventListener('click', async function () {
const button = this; const button = this;
const filePathsInput = document.getElementById('filePaths').value; const filePathsInput = document.getElementById('filePaths').value;
const collectionName = document.getElementById('collectionName').value; const collectionName = document.getElementById('collectionName').value;
const collectionDesc = document.getElementById('collectionDesc').value; const collectionDesc = document.getElementById('collectionDesc').value;
if (!filePathsInput) { if (!filePathsInput) {
showStatus('loadStatus', '请提供至少一个文件路径', 'error'); showStatus('loadStatus', '请提供至少一个文件路径', 'error');
return; return;
} }
const filePaths = filePathsInput const filePaths = filePathsInput
.split(',') .split(',')
.map((path) => path.trim()) .map((path) => path.trim())
.filter((path) => path); .filter((path) => path);
setButtonLoading(button, true); setButtonLoading(button, true);
showStatus('loadStatus', ' 正在加载文件...', 'loading'); showStatus('loadStatus', ' 正在加载文件...', 'loading');
hideResult(); hideResult();
hideProcessResult(); hideProcessResult();
try { try {
const response = await fetch('/load-files/', { const response = await fetch('/load-files/', {
method: 'POST', method: 'POST',
headers: { headers: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}, },
body: JSON.stringify({ body: JSON.stringify({
paths: filePaths, paths: filePaths,
collection_name: collectionName || undefined, collection_name: collectionName || undefined,
collection_description: collectionDesc || undefined collection_description: collectionDesc || undefined
}) })
}); });
const data = await response.json(); const data = await response.json();
if (response.ok) { if (response.ok) {
showStatus('loadStatus', data.message, 'success'); showStatus('loadStatus', data.message, 'success');
} else { } else {
showStatus('loadStatus', `加载失败: ${data.detail}`, 'error'); showStatus('loadStatus', `加载失败: ${data.detail}`, 'error');
} }
} catch (error) { } catch (error) {
showStatus('loadStatus', `请求失败: ${error.message}`, 'error'); showStatus('loadStatus', `请求失败: ${error.message}`, 'error');
} finally { } finally {
setButtonLoading(button, false); setButtonLoading(button, false);
} }
}); });
// 清空消息功能 // 清空消息功能
document document
.getElementById('clearMessagesBtn') .getElementById('clearMessagesBtn')
.addEventListener('click', async function () { .addEventListener('click', async function () {
try { try {
const response = await fetch('/clear-messages/', { const response = await fetch('/clear-messages/', {
method: 'POST', method: 'POST',
headers: { headers: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}
});
if (response.ok) {
// 清空消息容器
const container = document.getElementById('messageContainer');
container.innerHTML = '';
// 清空查询结果
const resultText = document.getElementById('resultText');
resultText.textContent = '';
// 隐藏处理过程容器
hideProcessResult();
// 隐藏查询结果容器
hideResult();
showStatus('queryStatus', '消息已清空', 'success');
} else {
showStatus('queryStatus', '清空消息失败', 'error');
}
} catch (error) {
showStatus('queryStatus', `请求失败: ${error.message}`, 'error');
} }
}); });
if (response.ok) {
// 清空消息容器
const container = document.getElementById('messageContainer');
container.innerHTML = '';
// 清空查询结果
const resultText = document.getElementById('resultText');
resultText.textContent = '';
// 隐藏处理过程容器
hideProcessResult();
// 隐藏查询结果容器
hideResult();
showStatus('queryStatus', '消息已清空', 'success');
} else {
showStatus('queryStatus', '清空消息失败', 'error');
}
} catch (error) {
showStatus('queryStatus', `请求失败: ${error.message}`, 'error');
}
});
// 加载网站内容功能 // 加载网站内容功能
document document
.getElementById('loadWebsiteBtn') .getElementById('loadWebsiteBtn')
.addEventListener('click', async function () { .addEventListener('click', async function () {
const button = this; const button = this;
const urlsInput = document.getElementById('websiteUrls').value; const urlsInput = document.getElementById('websiteUrls').value;
const collectionName = document.getElementById('webCollectionName').value; const collectionName = document.getElementById('webCollectionName').value;
const collectionDesc = document.getElementById('webCollectionDesc').value; const collectionDesc = document.getElementById('webCollectionDesc').value;
if (!urlsInput) { if (!urlsInput) {
showStatus('webLoadStatus', '请提供至少一个网站URL', 'error'); showStatus('webLoadStatus', '请提供至少一个网站URL', 'error');
return; return;
} }
const urls = urlsInput const urls = urlsInput
.split(',') .split(',')
.map((url) => url.trim()) .map((url) => url.trim())
.filter((url) => url); .filter((url) => url);
setButtonLoading(button, true); setButtonLoading(button, true);
showStatus('webLoadStatus', ' 正在加载网站...', 'loading'); showStatus('webLoadStatus', ' 正在加载网站...', 'loading');
hideResult(); hideResult();
hideProcessResult(); hideProcessResult();
try { try {
const response = await fetch('/load-website/', { const response = await fetch('/load-website/', {
method: 'POST', method: 'POST',
headers: { headers: {
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}, },
body: JSON.stringify({ body: JSON.stringify({
urls: urls, urls: urls,
collection_name: collectionName || undefined, collection_name: collectionName || undefined,
collection_description: collectionDesc || undefined collection_description: collectionDesc || undefined
}) })
}); });
const data = await response.json(); const data = await response.json();
if (response.ok) { if (response.ok) {
showStatus('webLoadStatus', data.message, 'success'); showStatus('webLoadStatus', data.message, 'success');
} else { } else {
showStatus('webLoadStatus', `加载失败: ${data.detail}`, 'error'); showStatus('webLoadStatus', `加载失败: ${data.detail}`, 'error');
} }
} catch (error) { } catch (error) {
showStatus('webLoadStatus', `请求失败: ${error.message}`, 'error'); showStatus('webLoadStatus', `请求失败: ${error.message}`, 'error');
} finally { } finally {
setButtonLoading(button, false); setButtonLoading(button, false);
} }
}); });
// 查询功能 - 使用实时流 // 查询功能 - 使用实时流
document document
.getElementById('queryBtn') .getElementById('queryBtn')
.addEventListener('click', async function () { .addEventListener('click', async function () {
const button = this; const button = this;
const queryText = document.getElementById('queryText').value; const queryText = document.getElementById('queryText').value;
const maxIter = parseInt(document.getElementById('maxIter').value); const maxIter = parseInt(document.getElementById('maxIter').value);
if (!queryText) { if (!queryText) {
showStatus('queryStatus', '请输入查询问题', 'error'); showStatus('queryStatus', '请输入查询问题', 'error');
return; return;
} }
if (isNaN(maxIter) || maxIter < 1 || maxIter > 10) {
showStatus('queryStatus', '迭代次数必须是1到10之间的整数', 'error');
return;
}
if (isStreaming) {
console.log('Query already in progress, isStreaming:', isStreaming);
showStatus('queryStatus', '查询正在进行中，请等待完成', 'error');
return;
}
setButtonLoading(button, true);
showStatus('queryStatus', '正在启动查询...', 'loading');
hideResult();
hideProcessResult();
// 清空消息容器
const container = document.getElementById('messageContainer');
container.innerHTML = '';
try {
console.log('Starting new query, setting isStreaming to true');
isStreaming = true;
// 确保没有其他连接存在
if (window.currentEventSource) {
console.log('Closing existing EventSource connection');
window.currentEventSource.close();
window.currentEventSource = null;
}
// 使用EventSource直接连接到查询流 if (isNaN(maxIter) || maxIter < 1 || maxIter > 10) {
const eventSource = new EventSource( showStatus('queryStatus', '迭代次数必须是1到10之间的整数', 'error');
`/query-stream/?original_query=${encodeURIComponent( return;
queryText }
)}&max_iter=${maxIter}`
);
// 保存EventSource引用以便后续关闭 if (isStreaming) {
window.currentEventSource = eventSource; console.log('Query already in progress, isStreaming:', isStreaming);
showStatus('queryStatus', '查询正在进行中，请等待完成', 'error');
return;
}
eventSource.onopen = function (event) { setButtonLoading(button, true);
console.log('EventSource connection opened for query'); showStatus('queryStatus', '正在启动查询...', 'loading');
showStatus('queryStatus', ' 正在处理...', 'loading'); hideResult();
}; hideProcessResult();
eventSource.onmessage = function (event) { // 清空消息容器
console.log('Received message:', event.data); const container = document.getElementById('messageContainer');
handleStreamMessage(event.data); container.innerHTML = '';
};
eventSource.onerror = function (event) { try {
console.error('EventSource error:', event); console.log('Starting new query, setting isStreaming to true');
if (eventSource.readyState === EventSource.CLOSED) { isStreaming = true;
console.log('EventSource connection closed due to error');
isStreaming = false; // 确保没有其他连接存在
setButtonLoading(button, false); if (window.currentEventSource) {
window.currentEventSource = null; console.log('Closing existing EventSource connection');
window.currentEventSource.close();
window.currentEventSource = null;
}
// 使用EventSource直接连接到查询流
const eventSource = new EventSource(
`/query-stream/?original_query=${encodeURIComponent(
queryText
)}&max_iter=${maxIter}`
);
// 保存EventSource引用以便后续关闭
window.currentEventSource = eventSource;
eventSource.onopen = function (event) {
console.log('EventSource connection opened for query');
showStatus('queryStatus', ' 正在处理...', 'loading');
};
eventSource.onmessage = function (event) {
console.log('Received message:', event.data);
handleStreamMessage(event.data);
};
eventSource.onerror = function (event) {
console.error('EventSource error:', event);
if (eventSource.readyState === EventSource.CLOSED) {
console.log('EventSource connection closed due to error');
isStreaming = false;
setButtonLoading(button, false);
window.currentEventSource = null;
}
};
} catch (error) {
console.error('Query error:', error);
showStatus('queryStatus', `请求失败: ${error.message}`, 'error');
isStreaming = false;
setButtonLoading(button, false);
} }
}; });
} catch (error) {
console.error('Query error:', error);
showStatus('queryStatus', `请求失败: ${error.message}`, 'error');
isStreaming = false;
setButtonLoading(button, false);
}
});
// 页面卸载时清理连接 // 页面卸载时清理连接
window.addEventListener('beforeunload', function () { window.addEventListener('beforeunload', function () {
if (window.currentEventSource) { if (window.currentEventSource) {
window.currentEventSource.close(); window.currentEventSource.close();
window.currentEventSource = null; window.currentEventSource = null;
} }
}); });

Write Preview
Loading…
Cancel
Save