573 lines
17 KiB
JavaScript
573 lines
17 KiB
JavaScript
import { defineStore } from 'pinia';
|
||
import { agentApi, threadApi } from '@/apis/agent_api';
|
||
import { MessageProcessor } from '@/utils/messageProcessor';
|
||
import { handleChatError } from '@/utils/errorHandler';
|
||
|
||
export const useAgentStore = defineStore('agent', {
|
||
state: () => ({
|
||
// 智能体相关状态
|
||
agents: {}, // 以ID为键的智能体对象
|
||
selectedAgentId: null, // 当前选中的智能体ID
|
||
defaultAgentId: null, // 默认智能体ID
|
||
|
||
// 智能体配置相关状态
|
||
agentConfig: {}, // 当前智能体的配置
|
||
originalAgentConfig: {}, // 原始配置，用于重置
|
||
|
||
// 工具相关状态
|
||
availableTools: [], // 所有可用工具列表
|
||
|
||
// 线程相关状态
|
||
threads: {}, // 以智能体ID为键的线程列表
|
||
currentThreadId: null, // 当前选中的线程ID
|
||
threadMessages: {}, // 以线程ID为键的消息列表
|
||
|
||
// 对话状态
|
||
onGoingConv: { msgChunks: {} }, // 正在进行的对话（流式）
|
||
isStreaming: false, // 是否正在接收流式响应
|
||
streamAbortController: null, // 流式对话取消控制器
|
||
|
||
// 加载状态
|
||
isLoadingAgents: false,
|
||
isLoadingConfig: false,
|
||
isLoadingTools: false,
|
||
isLoadingThreads: false,
|
||
isLoadingMessages: false,
|
||
|
||
// 错误状态
|
||
error: null,
|
||
|
||
// 初始化状态
|
||
isInitialized: false
|
||
}),
|
||
|
||
getters: {
|
||
// --- 智能体相关 Getters ---
|
||
selectedAgent: (state) => state.selectedAgentId ? state.agents[state.selectedAgentId] : null,
|
||
defaultAgent: (state) => state.defaultAgentId ? state.agents[state.defaultAgentId] : state.agents[Object.keys(state.agents)[0]],
|
||
agentsList: (state) => Object.values(state.agents),
|
||
isDefaultAgent: (state) => state.selectedAgentId === state.defaultAgentId,
|
||
configurableItems: (state) => {
|
||
const agent = state.selectedAgentId ? state.agents[state.selectedAgentId] : null;
|
||
if (!agent || !agent.configurable_items) return {};
|
||
|
||
const agentConfigurableItems = agent.configurable_items;
|
||
const items = { ...agentConfigurableItems };
|
||
Object.keys(items).forEach(key => {
|
||
const item = items[key];
|
||
if (item && item.x_oap_ui_config) {
|
||
items[key] = { ...item, ...item.x_oap_ui_config };
|
||
delete items[key].x_oap_ui_config;
|
||
}
|
||
});
|
||
return items;
|
||
},
|
||
hasConfigChanges: (state) => JSON.stringify(state.agentConfig) !== JSON.stringify(state.originalAgentConfig),
|
||
|
||
// --- 线程与消息相关 Getters ---
|
||
currentAgentThreads: (state) => state.selectedAgentId ? (state.threads[state.selectedAgentId] || []) : [],
|
||
currentThread: (state) => {
|
||
if (!state.currentThreadId || !state.selectedAgentId) return null;
|
||
const agentThreads = state.threads[state.selectedAgentId] || [];
|
||
return agentThreads.find(thread => thread.id === state.currentThreadId);
|
||
},
|
||
currentThreadMessages: (state) => state.currentThreadId ? (state.threadMessages[state.currentThreadId] || []) : [],
|
||
|
||
// --- 对话UI Getters ---
|
||
onGoingConvMessages: (state) => {
|
||
const msgs = Object.values(state.onGoingConv.msgChunks).map(MessageProcessor.mergeMessageChunk);
|
||
return msgs.length > 0
|
||
? MessageProcessor.convertToolResultToMessages(msgs).filter(msg => msg.type !== 'tool')
|
||
: [];
|
||
},
|
||
conversations: (state) => {
|
||
const historyConvs = MessageProcessor.convertServerHistoryToMessages(state.currentThreadMessages);
|
||
// Compute ongoing messages directly from state to avoid circular reference
|
||
const msgs = Object.values(state.onGoingConv.msgChunks).map(MessageProcessor.mergeMessageChunk);
|
||
const onGoingMessages = msgs.length > 0
|
||
? MessageProcessor.convertToolResultToMessages(msgs).filter(msg => msg.type !== 'tool')
|
||
: [];
|
||
|
||
if (onGoingMessages.length > 0) {
|
||
// Create a new conversation object for the ongoing messages
|
||
const onGoingConv = {
|
||
messages: onGoingMessages,
|
||
status: 'streaming'
|
||
};
|
||
return [...historyConvs, onGoingConv];
|
||
}
|
||
return historyConvs;
|
||
},
|
||
},
|
||
|
||
actions: {
|
||
// 初始化store
|
||
async initialize() {
|
||
if (this.isInitialized) return;
|
||
|
||
try {
|
||
// 首先加载智能体列表
|
||
await this.fetchAgents();
|
||
|
||
// 然后设置默认智能体
|
||
await this.fetchDefaultAgent();
|
||
|
||
// 最后加载工具
|
||
await this.fetchTools();
|
||
|
||
this.isInitialized = true;
|
||
} catch (error) {
|
||
console.error('Failed to initialize agent store:', error);
|
||
handleChatError(error, 'initialize');
|
||
this.error = error.message;
|
||
}
|
||
},
|
||
|
||
// 获取智能体列表
|
||
async fetchAgents() {
|
||
this.isLoadingAgents = true;
|
||
this.error = null;
|
||
|
||
try {
|
||
const response = await agentApi.getAgents();
|
||
// 将数组转换为以ID为键的对象
|
||
this.agents = response.agents.reduce((acc, agent) => {
|
||
acc[agent.id] = agent;
|
||
return acc;
|
||
}, {});
|
||
} catch (error) {
|
||
console.error('Failed to fetch agents:', error);
|
||
handleChatError(error, 'fetch');
|
||
this.error = error.message;
|
||
throw error;
|
||
} finally {
|
||
this.isLoadingAgents = false;
|
||
}
|
||
},
|
||
|
||
// 获取默认智能体
|
||
async fetchDefaultAgent() {
|
||
try {
|
||
const response = await agentApi.getDefaultAgent();
|
||
this.defaultAgentId = response.default_agent_id;
|
||
|
||
// 如果没有选中的智能体且默认智能体存在于智能体列表中，则选择默认智能体
|
||
if (!this.selectedAgentId && this.defaultAgentId && this.agents[this.defaultAgentId]) {
|
||
this.selectedAgentId = this.defaultAgentId;
|
||
}
|
||
} catch (error) {
|
||
console.error('Failed to fetch default agent:', error);
|
||
handleChatError(error, 'fetch');
|
||
this.error = error.message;
|
||
}
|
||
},
|
||
|
||
// 设置默认智能体
|
||
async setDefaultAgent(agentId) {
|
||
try {
|
||
await agentApi.setDefaultAgent(agentId);
|
||
this.defaultAgentId = agentId;
|
||
} catch (error) {
|
||
console.error('Failed to set default agent:', error);
|
||
handleChatError(error, 'save');
|
||
this.error = error.message;
|
||
throw error;
|
||
}
|
||
},
|
||
|
||
// 选择智能体
|
||
selectAgent(agentId) {
|
||
if (this.agents[agentId]) {
|
||
this.selectedAgentId = agentId;
|
||
// 清空之前的配置
|
||
this.agentConfig = {};
|
||
this.originalAgentConfig = {};
|
||
}
|
||
},
|
||
|
||
// 加载智能体配置
|
||
async loadAgentConfig(agentId = null) {
|
||
const targetAgentId = agentId || this.selectedAgentId;
|
||
if (!targetAgentId) return;
|
||
|
||
this.isLoadingConfig = true;
|
||
this.error = null;
|
||
|
||
try {
|
||
const response = await agentApi.getAgentConfig(targetAgentId);
|
||
this.agentConfig = { ...response.config };
|
||
this.originalAgentConfig = { ...response.config };
|
||
} catch (error) {
|
||
console.error('Failed to load agent config:', error);
|
||
handleChatError(error, 'load');
|
||
this.error = error.message;
|
||
throw error;
|
||
} finally {
|
||
this.isLoadingConfig = false;
|
||
}
|
||
},
|
||
|
||
// 保存智能体配置
|
||
async saveAgentConfig(agentId = null) {
|
||
const targetAgentId = agentId || this.selectedAgentId;
|
||
if (!targetAgentId) return;
|
||
|
||
try {
|
||
await agentApi.saveAgentConfig(targetAgentId, this.agentConfig);
|
||
this.originalAgentConfig = { ...this.agentConfig };
|
||
} catch (error) {
|
||
console.error('Failed to save agent config:', error);
|
||
handleChatError(error, 'save');
|
||
this.error = error.message;
|
||
throw error;
|
||
}
|
||
},
|
||
|
||
// 重置智能体配置
|
||
resetAgentConfig() {
|
||
this.agentConfig = { ...this.originalAgentConfig };
|
||
},
|
||
|
||
// 更新配置项
|
||
updateConfigItem(key, value) {
|
||
this.agentConfig[key] = value;
|
||
},
|
||
|
||
// 更新智能体配置（支持批量更新）
|
||
updateAgentConfig(updates) {
|
||
Object.assign(this.agentConfig, updates);
|
||
},
|
||
|
||
// 获取工具列表
|
||
async fetchTools() {
|
||
this.isLoadingTools = true;
|
||
this.error = null;
|
||
|
||
try {
|
||
const response = await agentApi.getTools(this.selectedAgentId);
|
||
this.availableTools = response.tools;
|
||
} catch (error) {
|
||
console.error('Failed to fetch tools:', error);
|
||
handleChatError(error, 'fetch');
|
||
this.error = error.message;
|
||
throw error;
|
||
} finally {
|
||
this.isLoadingTools = false;
|
||
}
|
||
},
|
||
|
||
// 清除错误状态
|
||
clearError() {
|
||
this.error = null;
|
||
},
|
||
|
||
// ==================== 线程管理方法 ====================
|
||
|
||
// 获取智能体的线程列表
|
||
async fetchThreads(agentId = null) {
|
||
const targetAgentId = agentId || this.selectedAgentId;
|
||
if (!targetAgentId) return;
|
||
|
||
this.isLoadingThreads = true;
|
||
this.error = null;
|
||
|
||
try {
|
||
const threads = await threadApi.getThreads(targetAgentId);
|
||
this.threads[targetAgentId] = threads || [];
|
||
} catch (error) {
|
||
console.error('Failed to fetch threads:', error);
|
||
handleChatError(error, 'fetch');
|
||
this.error = error.message;
|
||
throw error;
|
||
} finally {
|
||
this.isLoadingThreads = false;
|
||
}
|
||
},
|
||
|
||
// 创建新线程
|
||
async createThread(agentId, title = '新的对话') {
|
||
if (!agentId) return null;
|
||
|
||
try {
|
||
const thread = await threadApi.createThread(agentId, title);
|
||
if (thread) {
|
||
// 更新线程列表
|
||
if (!this.threads[agentId]) {
|
||
this.threads[agentId] = [];
|
||
}
|
||
this.threads[agentId].unshift(thread);
|
||
|
||
// 设置为当前线程
|
||
this.currentThreadId = thread.id;
|
||
|
||
// 初始化消息列表
|
||
this.threadMessages[thread.id] = [];
|
||
}
|
||
return thread;
|
||
} catch (error) {
|
||
console.error('Failed to create thread:', error);
|
||
handleChatError(error, 'create');
|
||
this.error = error.message;
|
||
throw error;
|
||
}
|
||
},
|
||
|
||
// 删除线程
|
||
async deleteThread(threadId) {
|
||
if (!threadId) return;
|
||
|
||
try {
|
||
await threadApi.deleteThread(threadId);
|
||
|
||
// 从所有智能体的线程列表中移除
|
||
Object.keys(this.threads).forEach(agentId => {
|
||
this.threads[agentId] = this.threads[agentId].filter(thread => thread.id !== threadId);
|
||
});
|
||
|
||
// 清理消息
|
||
delete this.threadMessages[threadId];
|
||
|
||
// 如果删除的是当前线程，重置当前线程ID
|
||
if (this.currentThreadId === threadId) {
|
||
this.currentThreadId = null;
|
||
}
|
||
} catch (error) {
|
||
console.error('Failed to delete thread:', error);
|
||
handleChatError(error, 'delete');
|
||
this.error = error.message;
|
||
throw error;
|
||
}
|
||
},
|
||
|
||
// 更新线程标题
|
||
async updateThread(threadId, title) {
|
||
if (!threadId || !title) return;
|
||
|
||
try {
|
||
await threadApi.updateThread(threadId, title);
|
||
|
||
// 更新本地线程列表中的标题
|
||
Object.keys(this.threads).forEach(agentId => {
|
||
const thread = this.threads[agentId].find(t => t.id === threadId);
|
||
if (thread) {
|
||
thread.title = title;
|
||
}
|
||
});
|
||
} catch (error) {
|
||
console.error('Failed to update thread:', error);
|
||
handleChatError(error, 'update');
|
||
this.error = error.message;
|
||
throw error;
|
||
}
|
||
},
|
||
|
||
// 选择线程
|
||
selectThread(threadId) {
|
||
this.currentThreadId = threadId;
|
||
this.resetOnGoingConv();
|
||
|
||
// 如果没有该线程的消息，初始化空数组
|
||
if (threadId && !this.threadMessages[threadId]) {
|
||
this.threadMessages[threadId] = [];
|
||
}
|
||
},
|
||
|
||
// 获取线程消息
|
||
async fetchThreadMessages(threadId) {
|
||
if (!threadId) return;
|
||
|
||
this.isLoadingMessages = true;
|
||
this.error = null;
|
||
this.resetOnGoingConv();
|
||
|
||
try {
|
||
const response = await agentApi.getAgentHistory(this.selectedAgentId, threadId);
|
||
this.threadMessages[threadId] = response.history || [];
|
||
} catch (error) {
|
||
handleChatError(error, 'load');
|
||
throw error;
|
||
} finally {
|
||
this.isLoadingMessages = false;
|
||
}
|
||
},
|
||
|
||
// --- 流式对话 Actions ---
|
||
|
||
resetOnGoingConv() {
|
||
// 取消之前的请求（如果存在）
|
||
if (this.streamAbortController) {
|
||
this.streamAbortController.abort();
|
||
this.streamAbortController = null;
|
||
}
|
||
this.onGoingConv = { msgChunks: {} };
|
||
},
|
||
|
||
_processStreamChunk(chunk) {
|
||
const { status, msg, request_id, message } = chunk;
|
||
switch (status) {
|
||
case 'init':
|
||
this.onGoingConv.msgChunks[request_id] = [msg];
|
||
break;
|
||
case 'loading':
|
||
if (msg.id) {
|
||
if (!this.onGoingConv.msgChunks[msg.id]) {
|
||
this.onGoingConv.msgChunks[msg.id] = [];
|
||
}
|
||
this.onGoingConv.msgChunks[msg.id].push(msg);
|
||
}
|
||
break;
|
||
case 'error':
|
||
handleChatError({ message }, 'stream');
|
||
break;
|
||
case 'finished':
|
||
this.fetchThreadMessages(this.currentThreadId);
|
||
break;
|
||
}
|
||
},
|
||
|
||
// 取消流式对话
|
||
cancelStreaming() {
|
||
if (this.streamAbortController && this.isStreaming) {
|
||
this.streamAbortController.abort();
|
||
this.streamAbortController = null;
|
||
this.isStreaming = false;
|
||
this.resetOnGoingConv();
|
||
}
|
||
},
|
||
|
||
// 发送消息并处理流式响应
|
||
async sendMessage(text) {
|
||
if (!this.selectedAgentId || !this.currentThreadId || !text) {
|
||
handleChatError({ message: "Missing agent, thread, or message text" }, 'send');
|
||
return;
|
||
}
|
||
|
||
this.isStreaming = true;
|
||
this.resetOnGoingConv();
|
||
|
||
// 创建新的 AbortController
|
||
this.streamAbortController = new AbortController();
|
||
|
||
// 如果是新对话，用消息内容作为标题
|
||
if (this.currentThreadMessages.length === 0) {
|
||
this.updateThread(this.currentThreadId, text);
|
||
}
|
||
|
||
const requestData = {
|
||
query: text,
|
||
config: {
|
||
thread_id: this.currentThreadId,
|
||
},
|
||
};
|
||
|
||
try {
|
||
const response = await agentApi.sendAgentMessage(this.selectedAgentId, requestData);
|
||
|
||
const reader = response.body.getReader();
|
||
const decoder = new TextDecoder();
|
||
let buffer = '';
|
||
|
||
while (true) {
|
||
// 检查是否被取消
|
||
if (this.streamAbortController && this.streamAbortController.signal.aborted) {
|
||
break;
|
||
}
|
||
|
||
const { done, value } = await reader.read();
|
||
if (done) break;
|
||
|
||
buffer += decoder.decode(value, { stream: true });
|
||
const lines = buffer.split('\n');
|
||
buffer = lines.pop() || '';
|
||
|
||
for (const line of lines) {
|
||
if (line.trim() && (!this.streamAbortController || !this.streamAbortController.signal.aborted)) {
|
||
try {
|
||
const chunk = JSON.parse(line.trim());
|
||
this._processStreamChunk(chunk);
|
||
} catch (e) {
|
||
console.warn('Failed to parse stream chunk JSON:', e);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Process any remaining data in the buffer
|
||
if (buffer.trim() && (!this.streamAbortController || !this.streamAbortController.signal.aborted)) {
|
||
try {
|
||
const chunk = JSON.parse(buffer.trim());
|
||
this._processStreamChunk(chunk);
|
||
} catch (e) {
|
||
console.warn('Failed to parse final stream chunk JSON:', e);
|
||
}
|
||
}
|
||
|
||
} catch (error) {
|
||
// 如果是取消错误，不显示错误信息
|
||
if (error.name === 'AbortError') {
|
||
console.log('Stream was cancelled');
|
||
} else {
|
||
handleChatError(error, 'send');
|
||
}
|
||
} finally {
|
||
this.isStreaming = false;
|
||
this.streamAbortController = null;
|
||
}
|
||
},
|
||
|
||
// 添加消息到线程
|
||
addMessageToThread(threadId, message) {
|
||
if (!threadId || !message) return;
|
||
|
||
if (!this.threadMessages[threadId]) {
|
||
this.threadMessages[threadId] = [];
|
||
}
|
||
|
||
this.threadMessages[threadId].push(message);
|
||
},
|
||
|
||
// 更新线程中的消息
|
||
updateMessageInThread(threadId, messageIndex, updatedMessage) {
|
||
if (!threadId || messageIndex < 0 || !this.threadMessages[threadId]) return;
|
||
|
||
if (messageIndex < this.threadMessages[threadId].length) {
|
||
this.threadMessages[threadId][messageIndex] = updatedMessage;
|
||
}
|
||
},
|
||
|
||
// 重置store状态
|
||
reset() {
|
||
// 取消正在进行的流式对话
|
||
if (this.streamAbortController) {
|
||
this.streamAbortController.abort();
|
||
this.streamAbortController = null;
|
||
}
|
||
|
||
this.agents = {};
|
||
this.selectedAgentId = null;
|
||
this.defaultAgentId = null;
|
||
this.agentConfig = {};
|
||
this.originalAgentConfig = {};
|
||
this.availableTools = [];
|
||
this.threads = {};
|
||
this.currentThreadId = null;
|
||
this.threadMessages = {};
|
||
this.onGoingConv = { msgChunks: {} };
|
||
this.isStreaming = false;
|
||
this.isLoadingAgents = false;
|
||
this.isLoadingConfig = false;
|
||
this.isLoadingTools = false;
|
||
this.isLoadingThreads = false;
|
||
this.isLoadingMessages = false;
|
||
this.error = null;
|
||
this.isInitialized = false;
|
||
}
|
||
},
|
||
|
||
// 持久化配置
|
||
persist: {
|
||
key: 'agent-store',
|
||
storage: localStorage,
|
||
paths: ['selectedAgentId', 'defaultAgentId'] // 只持久化关键状态
|
||
}
|
||
}); |