1807 lines
60 KiB
Plaintext
1807 lines
60 KiB
Plaintext
import { nextTick } from "vue";
|
||
import {
|
||
MessageInfo,
|
||
ConversationChatParams,
|
||
ConversationChatResponse,
|
||
ConversationChatSuggestParams,
|
||
ProcessingInfo,
|
||
MessageQuestionExtInfo,
|
||
AttachmentFile,
|
||
ConversationCreateParams,
|
||
OpenAppParams,
|
||
ConversationInfo,
|
||
} from "@/types/interfaces/conversationInfo";
|
||
import type {
|
||
AgentSelectedComponentInfo,
|
||
AgentConversationUpdateParams,
|
||
AgentManualComponentInfo,
|
||
} from "@/types/interfaces/agent";
|
||
import { UploadFileInfo } from "@/types/interfaces/common";
|
||
import { RequestResponse } from "@/types/interfaces/request";
|
||
import {
|
||
MessageModeEnum,
|
||
ConversationEventTypeEnum,
|
||
MessageTypeEnum,
|
||
AssistantRoleEnum,
|
||
DefaultSelectedEnum,
|
||
ExpandPageAreaEnum,
|
||
HideChatAreaEnum,
|
||
AgentComponentTypeEnum,
|
||
TaskStatus,
|
||
} from "@/types/enums/agent";
|
||
import { MessageStatusEnum, ProcessingEnum } from "@/types/enums/common";
|
||
import { OpenCloseEnum } from "@/types/enums/space";
|
||
import { SUCCESS_CODE } from "@/constants/codes.constants";
|
||
import { chatService } from "@/utils/chatService";
|
||
import { generateUniqueId } from "@/utils/common";
|
||
import {
|
||
apiAgentConversationCreate,
|
||
apiAgentConversation,
|
||
apiAgentConversationChatSuggest,
|
||
apiAgentConversationUpdate,
|
||
apiAgentConversationChatStop,
|
||
apiTempChatConversationStop,
|
||
apiTempChatConversationQuery,
|
||
apiTempChatConversationCreate,
|
||
apiAgentConversationMessageList,
|
||
} from "@/servers/conversation";
|
||
import {
|
||
apiPublishedAgentInfo,
|
||
apiCollectAgent,
|
||
apiUnCollectAgent,
|
||
apiGetStaticFileList,
|
||
} from "@/servers/agentDev";
|
||
import {
|
||
apiGetSandboxList,
|
||
apiUpdateSelectedSandbox,
|
||
apiRestartAgent,
|
||
apiRestartSandbox,
|
||
} from "@/subpackages/servers/sandbox";
|
||
import { v4 as uuidv4 } from "uuid";
|
||
import AgentDetailData from "./AgentDetailData.uts";
|
||
import { getCustomBlock } from "@/subpackages/utils/containerHelper.uts";
|
||
import { replaceMathBracket } from "@/utils/markdown.uts";
|
||
import { adaptHistoryMessage } from "@/subpackages/utils/historyMessageAdapter";
|
||
import AgentDetailUtils from "./AgentDetailUtils.uts";
|
||
import { TEMP_CONVERSATION_UID } from "@/constants/common.constants";
|
||
import { API_BASE_URL } from "@/constants/config";
|
||
import { CustomActionService } from "@/subpackages/utils/customActionService";
|
||
import { transformFlatListToTree } from "@/subpackages/utils/fileTree";
|
||
import {
|
||
extractTaskResult,
|
||
getFileProxyUrlByConversationIdAndFilePath,
|
||
jumpToFilePreviewPage,
|
||
} from "@/utils/system.uts";
|
||
import { t } from "@/utils/i18n";
|
||
|
||
/** 每页加载消息数量 */
|
||
const MESSAGE_LIST_SIZE = 10;
|
||
|
||
const handleMessageProcess = (text: string): string => {
|
||
return text; // 目前由于方案 已经整体切换到 mp-html内处理 所这里都关闭了
|
||
};
|
||
/**
|
||
* 服务层：负责业务逻辑和API调用
|
||
*/
|
||
export default class AgentDetailService {
|
||
private data: AgentDetailData;
|
||
private isAllowSuggest: boolean;
|
||
constructor(private data: AgentDetailData) {
|
||
this.data = data;
|
||
this.isAllowSuggest = true;
|
||
}
|
||
|
||
/**
|
||
* 处理查询会话
|
||
*/
|
||
async handleQueryConversation(
|
||
result: RequestResponse<ConversationInfo>,
|
||
): Promise<void> {
|
||
this.data.isLoadingConversation.value = true;
|
||
const { data: responseData } = result;
|
||
|
||
this.data.conversationInfo.value =
|
||
responseData as unknown as ConversationInfo;
|
||
this.data.agentInfo.value = responseData?.agent;
|
||
// 确保 agentId 被设置
|
||
if (responseData?.agentId) {
|
||
this.data.agentId.value = responseData.agentId;
|
||
}
|
||
// 确保会话ID被设置，临时会话加载历史记录同样需要该 ID
|
||
if (responseData?.id) {
|
||
this.data.conversationId.value = responseData.id;
|
||
}
|
||
// 是否开启问题建议,可用值:Open,Close
|
||
this.data.isSuggest.value =
|
||
responseData?.agent?.openSuggest === OpenCloseEnum.Open;
|
||
// 可用组件列表
|
||
this.data.manualComponents.value =
|
||
responseData?.agent?.manualComponents || [];
|
||
// 初始化默认选中组件
|
||
this.data.selectedComponents.value = (
|
||
responseData?.agent?.manualComponents || []
|
||
)
|
||
.filter(
|
||
(item: AgentManualComponentInfo): boolean =>
|
||
item.defaultSelected === DefaultSelectedEnum.Yes,
|
||
)
|
||
.map(
|
||
(item: AgentManualComponentInfo): AgentSelectedComponentInfo =>
|
||
({
|
||
id: item.id,
|
||
type: item.type,
|
||
}) as AgentSelectedComponentInfo,
|
||
);
|
||
// 如果变量参数存在,则禁用变量参数
|
||
if (responseData?.variables) {
|
||
this.data.isSendMessageRef.value = true;
|
||
}
|
||
// 变量参数
|
||
const _variables = responseData?.agent?.variables || [];
|
||
this.data.variables.value = _variables;
|
||
// 用户填充变量
|
||
this.data.userFillVariables.value = responseData?.variables || {};
|
||
// 消息列表
|
||
const _messageList = responseData?.messageList || [];
|
||
// 排除预置问题
|
||
const len = _messageList?.filter((item) => !!item.id).length || 0;
|
||
if (len) {
|
||
// 处理消息文本，先适配历史消息格式（PC端HTML标签转移动端Markdown语法）
|
||
const processedMessageList = _messageList.map((message: MessageInfo) => {
|
||
// 适配历史消息：将PC端自定义HTML标签转换为移动端Markdown容器语法
|
||
// 同时将componentExecutedList转换为processingList
|
||
const adaptedMessage = adaptHistoryMessage(message);
|
||
|
||
// 确保 text 字段始终有值，避免 undefined 导致渲染错误
|
||
const rawText = adaptedMessage.text ?? "";
|
||
const text = handleMessageProcess(rawText);
|
||
// 使用同步方法生成ID，兼容所有平台
|
||
const id = adaptedMessage.id || generateUniqueId();
|
||
|
||
return { ...adaptedMessage, text, id };
|
||
});
|
||
|
||
this.data.autoToLastMsg.value = true;
|
||
// 一次性设置消息列表，避免逐条渲染产生动态效果
|
||
this.data.messageList.value = processedMessageList;
|
||
|
||
// 无论初始返回多少条，只要有消息就认为可能有历史消息，保证向上滑动时至少调用一次分页接口
|
||
this.data.hasMoreMessages.value = len > 0;
|
||
|
||
// 处理问题建议
|
||
const lastMessage = processedMessageList[len - 1];
|
||
// 最后一条消息为"问答"时，获取问题建议
|
||
if (
|
||
lastMessage.type === MessageModeEnum.QUESTION &&
|
||
lastMessage.ext?.length
|
||
) {
|
||
const suggestList = lastMessage.ext.map((item) => item.content) || [];
|
||
this.data.chatSuggestList.value = suggestList;
|
||
} else if (len === 1) {
|
||
// 如果消息列表大于1时，说明已开始会话，就不显示预置问题，反之显示
|
||
// 如果存在预置问题，显示预置问题
|
||
this.data.chatSuggestList.value =
|
||
responseData?.agent?.openingGuidQuestions || [];
|
||
}
|
||
}
|
||
// 不存在会话消息时，才显示开场白预置问题
|
||
else {
|
||
this.data.chatSuggestList.value =
|
||
responseData?.agent?.guidQuestionDtos?.slice(0, 5) || [];
|
||
}
|
||
this.data.isLoadingConversation.value = false;
|
||
|
||
// 获取沙盒列表
|
||
this.handleGetSandboxList();
|
||
|
||
// 初始化当前模型ID
|
||
if (responseData?.agent) {
|
||
this.data.currentModelId.value = responseData.modelId || 0;
|
||
}
|
||
|
||
// 检查订阅限制
|
||
if (responseData?.agent != null) {
|
||
const agent = responseData.agent!;
|
||
const paymentRequired = agent.paymentRequired === true;
|
||
const subscribed = agent.subscribed === true;
|
||
const overCallLimit = agent.overCallLimit === true;
|
||
|
||
// 是否弹出模态框：要求订阅且未订阅，或超出调用限制（已订阅时不主动弹窗）
|
||
const shouldShowModal =
|
||
paymentRequired && (!subscribed || overCallLimit) && !subscribed;
|
||
if (shouldShowModal && this.data.enableSubscription.value === 1) {
|
||
this.data.subscriptionModalVisible.value = true;
|
||
}
|
||
|
||
// 是否禁用输入框：要求订阅、且未订阅、且已超出调用限制
|
||
const shouldBlockInput = paymentRequired && !subscribed && overCallLimit;
|
||
if (shouldBlockInput && this.data.enableSubscription.value === 1) {
|
||
this.data.subscriptionRequired.value = true;
|
||
} else {
|
||
this.data.subscriptionRequired.value = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 加载更多历史消息
|
||
* 用户上滑到顶部时触发，向消息列表头部追加更多历史消息
|
||
*/
|
||
async handleLoadMoreMessages(): Promise<void> {
|
||
const conversationId = this.data.conversationId.value;
|
||
|
||
// 前置校验
|
||
if (
|
||
!conversationId ||
|
||
this.data.isLoadingMoreMessages.value ||
|
||
!this.data.hasMoreMessages.value ||
|
||
this.data.messageList.value.length === 0
|
||
) {
|
||
return;
|
||
}
|
||
|
||
// 取消息列表第一条的 index 作为查询游标
|
||
const firstMessage = this.data.messageList.value[0];
|
||
const currentIndex = firstMessage?.index || 0;
|
||
|
||
// 如果 index 为 0，说明已经是最早的消息
|
||
if (currentIndex <= 0) {
|
||
this.data.hasMoreMessages.value = false;
|
||
return;
|
||
}
|
||
|
||
this.data.isLoadingMoreMessages.value = true;
|
||
|
||
try {
|
||
const res = await apiAgentConversationMessageList({
|
||
conversationId,
|
||
index: currentIndex,
|
||
size: MESSAGE_LIST_SIZE,
|
||
});
|
||
|
||
if (res.code === SUCCESS_CODE && res.data) {
|
||
const olderMessages = res.data;
|
||
|
||
if (olderMessages.length > 0) {
|
||
// 处理消息格式（与 handleQueryConversation 保持一致）
|
||
const processedMessages = olderMessages.map(
|
||
(message: MessageInfo) => {
|
||
const adaptedMessage = adaptHistoryMessage(message);
|
||
const rawText = adaptedMessage.text ?? "";
|
||
const text = handleMessageProcess(rawText);
|
||
const id = adaptedMessage.id || generateUniqueId();
|
||
return { ...adaptedMessage, text, id };
|
||
},
|
||
);
|
||
|
||
// 前插到消息列表头部
|
||
this.data.messageList.value = [
|
||
...processedMessages,
|
||
...this.data.messageList.value,
|
||
];
|
||
|
||
// 判断是否还有更多消息
|
||
this.data.hasMoreMessages.value =
|
||
olderMessages.length >= MESSAGE_LIST_SIZE;
|
||
} else {
|
||
// 返回空数组，没有更多消息
|
||
this.data.hasMoreMessages.value = false;
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error("[AgentDetailService] 加载更多消息失败:", error);
|
||
} finally {
|
||
this.data.isLoadingMoreMessages.value = false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 修改消息列表
|
||
*/
|
||
async handleChangeMessageList(
|
||
res: ConversationChatResponse,
|
||
currentMessageId: string,
|
||
): Promise<void> {
|
||
// 添加空值检查
|
||
if (!res) {
|
||
console.warn("[AgentDetailService] handleChangeMessageList 收到空响应");
|
||
return;
|
||
}
|
||
|
||
// 忽略心跳包 (HEART_BEAT 不包含 data)
|
||
if (res.eventType === "HEART_BEAT") {
|
||
return;
|
||
}
|
||
|
||
// 检查 res.data 是否存在
|
||
if (!res.data) {
|
||
console.warn(
|
||
"[AgentDetailService] handleChangeMessageList 响应中缺少 data 字段:",
|
||
res,
|
||
);
|
||
return;
|
||
}
|
||
|
||
const { data: responseData, eventType } = res;
|
||
this.data.currentConversationRequestId.value = res.requestId;
|
||
|
||
// 调试日志：追踪流式过程
|
||
// console.log(`[Stream] Event: ${eventType}, MessageId: ${currentMessageId}, Text: ${responseData?.text?.substring(0, 50)}...`)
|
||
|
||
if (!this.data.messageList.value?.length) return;
|
||
|
||
const list = [...this.data.messageList.value];
|
||
const index = list.findIndex((item) => item.id === currentMessageId);
|
||
let arraySpliceAction = 1;
|
||
|
||
const currentMessage = list.find(
|
||
(item) => item.id === currentMessageId,
|
||
) as MessageInfo;
|
||
if (!currentMessage) return;
|
||
|
||
// 检查是否是新的对话开始（第一个消息块）
|
||
const isNewConversation =
|
||
!currentMessage.text || currentMessage.text.length === 0;
|
||
|
||
// 确保流式过程中消息始终可见
|
||
if (currentMessage.status === MessageStatusEnum.Loading) {
|
||
currentMessage.status = MessageStatusEnum.Incomplete;
|
||
// console.log(`[Stream] Message ${currentMessageId} status changed from Loading to Incomplete`)
|
||
}
|
||
|
||
let newMessage: MessageInfo | null = null;
|
||
|
||
// 处理不同的事件类型
|
||
if (eventType === ConversationEventTypeEnum.PROCESSING) {
|
||
const processingResult = responseData.result || {};
|
||
responseData.executeId = processingResult.executeId;
|
||
|
||
const accumulatedText = getCustomBlock(
|
||
currentMessage.text || "",
|
||
responseData,
|
||
);
|
||
|
||
newMessage = {
|
||
...currentMessage,
|
||
text: accumulatedText,
|
||
status: MessageStatusEnum.Loading,
|
||
processingList: [
|
||
...(currentMessage?.processingList || []),
|
||
responseData,
|
||
] as ProcessingInfo[],
|
||
};
|
||
|
||
// 长任务型任务处理
|
||
const conversationId = this.data.conversationId.value;
|
||
|
||
// 长任务型任务处理(打开远程桌面)
|
||
// if (
|
||
// responseData.type === AgentComponentTypeEnum.Event &&
|
||
// (responseData as any).subEventType === 'OPEN_DESKTOP' &&
|
||
// conversationId
|
||
// ) {
|
||
// console.log('[AgentDetailService] Action: RECEIVE_EVENT, Params:', { type: 'OPEN_DESKTOP', conversationId, payload: responseData });
|
||
// // 详情见 docs/agent_integration_guide.md
|
||
// CustomActionService.openDesktopView(conversationId);
|
||
// }
|
||
|
||
// 长任务型任务处理(刷新文件树)
|
||
if (
|
||
responseData.type === AgentComponentTypeEnum.ToolCall &&
|
||
conversationId
|
||
) {
|
||
// console.log("[AgentDetailService] Action: RECEIVE_TOOL_CALL, Params:", {
|
||
// type: "REFRESH_FILE_LIST",
|
||
// conversationId,
|
||
// payload: responseData,
|
||
// });
|
||
CustomActionService.refreshFileList(conversationId);
|
||
}
|
||
}
|
||
|
||
if (eventType === ConversationEventTypeEnum.MESSAGE) {
|
||
const { text, type, ext, id, finished } = responseData;
|
||
// 如果会话结束，则设置会话状态为不活跃
|
||
if (finished) {
|
||
this.data.isConversationActive.value = false;
|
||
}
|
||
|
||
if (type === MessageModeEnum.THINK) {
|
||
newMessage = {
|
||
...currentMessage,
|
||
think: `${currentMessage.think}${text}`,
|
||
status: MessageStatusEnum.Incomplete,
|
||
};
|
||
} else if (type === MessageModeEnum.QUESTION) {
|
||
// 问题内容累积 - 新对话时从头开始，否则累积
|
||
const accumulatedText = handleMessageProcess(
|
||
isNewConversation ? text : `${currentMessage.text}${text}`,
|
||
);
|
||
newMessage = {
|
||
...currentMessage,
|
||
text: accumulatedText,
|
||
status: finished
|
||
? MessageStatusEnum.Complete
|
||
: MessageStatusEnum.Incomplete,
|
||
};
|
||
|
||
if (ext?.length) {
|
||
this.data.chatSuggestList.value =
|
||
ext.map((extItem: MessageQuestionExtInfo) => extItem.content) || [];
|
||
}
|
||
} else {
|
||
// 工作流过程输出
|
||
if (
|
||
this.data.messageIdRef.value &&
|
||
this.data.messageIdRef.value !== id &&
|
||
finished
|
||
) {
|
||
// 新对话时从头开始，否则累积
|
||
const accumulatedText = handleMessageProcess(
|
||
isNewConversation ? text : `${currentMessage.text}${text}`,
|
||
);
|
||
newMessage = {
|
||
...currentMessage,
|
||
id,
|
||
text: accumulatedText,
|
||
status: MessageStatusEnum.Complete,
|
||
};
|
||
arraySpliceAction = 0;
|
||
} else {
|
||
this.data.messageIdRef.value = id;
|
||
// 新对话时从头开始，否则累积
|
||
const accumulatedText = handleMessageProcess(
|
||
isNewConversation ? text : `${currentMessage.text}${text}`,
|
||
);
|
||
|
||
newMessage = {
|
||
...currentMessage,
|
||
text: accumulatedText,
|
||
status: MessageStatusEnum.Incomplete,
|
||
};
|
||
}
|
||
}
|
||
}
|
||
|
||
if (eventType === ConversationEventTypeEnum.FINAL_RESULT) {
|
||
newMessage = {
|
||
...currentMessage,
|
||
status: MessageStatusEnum.Complete,
|
||
finalResult: responseData,
|
||
requestId: res.requestId,
|
||
};
|
||
this.data.requestId.value = res.requestId;
|
||
}
|
||
|
||
if (eventType === ConversationEventTypeEnum.ERROR) {
|
||
newMessage = {
|
||
...currentMessage,
|
||
status: MessageStatusEnum.Error,
|
||
};
|
||
this.data.isConversationActive.value = false;
|
||
}
|
||
|
||
// 更新消息列表
|
||
if (newMessage) {
|
||
list.splice(index, arraySpliceAction, newMessage as MessageInfo);
|
||
}
|
||
|
||
// 确保消息列表更新是同步的
|
||
this.data.messageList.value = [...list];
|
||
|
||
// 流式渲染过程中触发自动滚动到底部
|
||
// 确保 autoToLastMsg 为 true，这样 watch 触发后会执行滚动
|
||
if (this.data.autoToLastMsg.value) {
|
||
// 通过事件总线通知主组件执行滚动，兼容微信小程序和 H5
|
||
uni.$emit("streamMessageUpdate");
|
||
}
|
||
|
||
// 调试日志：状态更新
|
||
// if (newMessage) {
|
||
// console.log(`[Stream] Message ${currentMessageId} updated: status=${newMessage.status}, textLength=${newMessage.text?.length || 0}`)
|
||
// }
|
||
|
||
// 使用优化更新方法，只更新需要更新的组件
|
||
if (newMessage && newMessage.messageType === MessageTypeEnum.ASSISTANT) {
|
||
await nextTick();
|
||
// 通过uni事件总线更新 - 现在直接传递文本内容给 mp-html 组件
|
||
uni.$emit("updateMessageComponent", {
|
||
messageId: `${currentMessageId}_${newMessage.index}`,
|
||
data: {
|
||
body: handleMessageProcess(newMessage.text || ""),
|
||
...newMessage,
|
||
},
|
||
});
|
||
|
||
// 打开页面首页
|
||
if (
|
||
responseData.status === ProcessingEnum.EXECUTING &&
|
||
responseData.type === "Page"
|
||
) {
|
||
uni.$emit("page_preview_executing", responseData);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 获取文件树列表
|
||
async fetchFileList(cId: number): Promise<void> {
|
||
try {
|
||
this.data.isLoadingFiles.value = true;
|
||
const result = await apiGetStaticFileList(cId);
|
||
this.data.isLoadingFiles.value = false;
|
||
if (result.code === SUCCESS_CODE) {
|
||
const { files } = result.data || {};
|
||
|
||
let treeData: FileNode[] = [];
|
||
|
||
// 检查是否是新的扁平格式
|
||
if (Array.isArray(files) && files.length > 0 && files[0].name) {
|
||
treeData = transformFlatListToTree(files);
|
||
} else if (Array.isArray(files)) {
|
||
// 如果是原有的树形格式，直接使用
|
||
treeData = files as FileNode[];
|
||
}
|
||
|
||
this.data.fileList.value = treeData;
|
||
}
|
||
} catch (error) {
|
||
console.error("[AgentDetailService] 获取文件树列表失败:", error);
|
||
} finally {
|
||
this.data.isLoadingFiles.value = false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 会话处理
|
||
*/
|
||
async handleConversation(
|
||
params: ConversationChatParams | TempConversationChatParams,
|
||
currentMessageId: string,
|
||
// 是否是临时会话
|
||
isTempChat?: boolean = false,
|
||
// 超时回调
|
||
onTimeout?: () => void,
|
||
): Promise<void> {
|
||
try {
|
||
// 清空问题建议列表
|
||
this.data.chatSuggestList.value = [];
|
||
// 开始会话后，允许获取问题建议
|
||
this.isAllowSuggest = true;
|
||
|
||
// 标记是否已经更新过主题，确保只更新一次
|
||
let hasUpdatedTopic = false;
|
||
|
||
await chatService.sendMessage(
|
||
params,
|
||
// 处理流式数据
|
||
(chunk: string) => {
|
||
try {
|
||
const result = JSON.parse(chunk);
|
||
// 验证解析结果
|
||
if (!result || typeof result !== "object") {
|
||
console.warn(
|
||
"[AgentDetailService] 解析结果无效, type:",
|
||
typeof result,
|
||
"value:",
|
||
result,
|
||
);
|
||
return;
|
||
}
|
||
// 验证是否包含必要字段
|
||
if (!result.hasOwnProperty("data")) {
|
||
console.warn(
|
||
"[AgentDetailService] 解析结果缺少 data 字段, keys:",
|
||
Object.keys(result),
|
||
);
|
||
return;
|
||
}
|
||
|
||
// 流式数据开始时，第一次收到数据时更新主题（只执行一次）
|
||
if (
|
||
!hasUpdatedTopic &&
|
||
!isTempChat &&
|
||
this.data.needUpdateTopicRef.value &&
|
||
this.data.conversationInfo?.value?.topicUpdated !== 1 // 只有未更新过才会执行，避免重复修改标题
|
||
) {
|
||
hasUpdatedTopic = true;
|
||
this.handleUpdateTopic(params.conversationId, params.message);
|
||
}
|
||
|
||
this.handleChangeMessageList(result, currentMessageId);
|
||
} catch (error) {
|
||
console.error(
|
||
"[AgentDetailService] 解析SSE数据失败:",
|
||
error,
|
||
"原始数据长度:",
|
||
chunk?.length,
|
||
"前100字符:",
|
||
chunk?.substring(0, 100),
|
||
);
|
||
}
|
||
},
|
||
// 完成回调
|
||
async () => {
|
||
// 流式消息完成，设置会话状态为不活跃
|
||
this.data.isConversationActive.value = false;
|
||
|
||
// 如果不是临时会话,则处理问题建议，临时会话，不需要处理问题建议
|
||
if (!isTempChat) {
|
||
if (this.data.isSuggest.value && this.isAllowSuggest) {
|
||
const responseData = await apiAgentConversationChatSuggest(
|
||
params as ConversationChatSuggestParams,
|
||
);
|
||
// 更新问题建议列表
|
||
this.data.chatSuggestList.value = responseData?.data ?? [];
|
||
}
|
||
}
|
||
// 会话完成后根据消息列表中的最后一条消息 判断是否存在 <task-result> 标签
|
||
const lastMessage =
|
||
this.data.messageList.value[this.data.messageList.value.length - 1];
|
||
|
||
const taskResult = extractTaskResult(lastMessage.text);
|
||
if (taskResult.hasTaskResult && taskResult.file) {
|
||
try {
|
||
const conversationId = this.data.conversationId.value;
|
||
const fileProxyUrl =
|
||
await getFileProxyUrlByConversationIdAndFilePath(
|
||
conversationId,
|
||
taskResult.file,
|
||
);
|
||
jumpToFilePreviewPage(conversationId, fileProxyUrl);
|
||
} catch (error) {
|
||
console.error(
|
||
"[AgentDetailService] Failed to parse <task-result> from last message:",
|
||
error,
|
||
);
|
||
}
|
||
}
|
||
},
|
||
// 错误回调
|
||
(error: any) => {
|
||
console.error(
|
||
"[AgentDetailService] Chat stream error callback:",
|
||
error,
|
||
);
|
||
onTimeout?.();
|
||
},
|
||
isTempChat,
|
||
// 超时回调
|
||
() => {
|
||
onTimeout?.();
|
||
},
|
||
);
|
||
} catch (error) {
|
||
console.error("[AgentDetailService] Chat handling failed:", error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 停止会话
|
||
* @param isTempChat 是否是临时会话
|
||
*/
|
||
async handleStopConversation(isTempChat: boolean = false): Promise<void> {
|
||
// 停止会话后，不再允许获取问题建议
|
||
this.isAllowSuggest = false;
|
||
|
||
// 如果会话已经不活跃，说明会话已经结束，无需调用 stop 接口
|
||
if (!this.data.isConversationActive.value) {
|
||
this.data.isStoppingConversation.value = false;
|
||
return;
|
||
}
|
||
|
||
// 如果普通会话，并且任务正在执行，则更新任务状态为 CANCEL
|
||
if (this.data.conversationInfo.value?.taskStatus === TaskStatus.EXECUTING) {
|
||
this.data.conversationInfo.value = {
|
||
...this.data.conversationInfo.value,
|
||
taskStatus: TaskStatus.CANCEL,
|
||
};
|
||
}
|
||
|
||
// 会话消息请求ID
|
||
const requestId = this.data.currentConversationRequestId.value;
|
||
|
||
// 对于临时会话，必须要有 requestId 才能停止
|
||
if (isTempChat && !requestId) {
|
||
this.data.isStoppingConversation.value = false;
|
||
this.data.isConversationActive.value = false;
|
||
return;
|
||
}
|
||
|
||
// 对于普通会话，即使没有 requestId 也可以通过 conversationId 停止
|
||
// 显示停止会话loading
|
||
this.data.isStoppingConversation.value = true;
|
||
let res = null;
|
||
try {
|
||
if (isTempChat) {
|
||
res = await apiTempChatConversationStop(requestId);
|
||
} else {
|
||
res = await apiAgentConversationChatStop(
|
||
String(this.data.conversationId.value),
|
||
);
|
||
}
|
||
const { code, data: responseData, message } = res;
|
||
this.data.isStoppingConversation.value = false;
|
||
// 停止会话成功
|
||
if (code === SUCCESS_CODE) {
|
||
this.data.isConversationActive.value = false;
|
||
console.log("[AgentDetailService] stop 接口调用成功");
|
||
} else {
|
||
uni.showToast({
|
||
title: message,
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
}
|
||
} catch (error) {
|
||
console.error("[AgentDetailService] stop 接口调用失败:", error);
|
||
this.data.isStoppingConversation.value = false;
|
||
this.data.isConversationActive.value = false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 将正在执行的工具调用状态更新为失败
|
||
* 用于超时或异常中断时的状态更新
|
||
*/
|
||
updateProcessingListToFailed(): void {
|
||
console.log("[AgentDetailService] 开始更新工具调用状态为 FAILED");
|
||
|
||
const messageList = this.data.messageList.value;
|
||
if (!messageList || messageList.length === 0) {
|
||
console.log("[AgentDetailService] 消息列表为空，无需更新");
|
||
return;
|
||
}
|
||
|
||
// 查找正在处理中的消息（状态为 Loading 或 Incomplete）
|
||
const updatedMessages = messageList.map((message) => {
|
||
// 只处理正在进行中的助手消息
|
||
if (
|
||
(message.status === MessageStatusEnum.Loading ||
|
||
message.status === MessageStatusEnum.Incomplete) &&
|
||
message.processingList &&
|
||
message.processingList.length > 0
|
||
) {
|
||
console.log(
|
||
`[AgentDetailService] 更新消息 ${message.id} 的工具调用状态`,
|
||
);
|
||
|
||
// 更新 processingList 中的状态
|
||
const updatedProcessingList = message.processingList.map(
|
||
(processing) => {
|
||
// 将所有 EXECUTING 状态的工具调用改为 FAILED
|
||
if (processing.status === ProcessingEnum.EXECUTING) {
|
||
console.log(
|
||
`[AgentDetailService] 工具 ${processing.name} 状态从 EXECUTING 改为 FAILED`,
|
||
);
|
||
return {
|
||
...processing,
|
||
status: ProcessingEnum.FAILED,
|
||
};
|
||
}
|
||
return processing;
|
||
},
|
||
);
|
||
|
||
// 返回更新后的消息
|
||
return {
|
||
...message,
|
||
processingList: updatedProcessingList,
|
||
};
|
||
}
|
||
|
||
return message;
|
||
});
|
||
|
||
// 更新消息列表
|
||
this.data.messageList.value = updatedMessages;
|
||
console.log("[AgentDetailService] 工具调用状态更新完成");
|
||
}
|
||
|
||
/**
|
||
* 获取沙盒列表 (严格模式 - 移动端重构 Phase 9)
|
||
*/
|
||
async handleGetSandboxList(useAgentSelected: boolean = true): Promise<void> {
|
||
if (this.data.isTempChat.value) return;
|
||
try {
|
||
const res = await apiGetSandboxList();
|
||
if (res.code === SUCCESS_CODE && res.data) {
|
||
this.data.sandboxList.value = res.data.sandboxes || [];
|
||
this.data.agentSelectedSandbox.value = useAgentSelected
|
||
? res.data.agentSelected || {}
|
||
: {};
|
||
|
||
const sandboxList = this.data.sandboxList.value;
|
||
const conversationInfo = this.data.conversationInfo.value;
|
||
const agentInfo = this.data.agentInfo.value;
|
||
// 优先使用 data.agentId，其次使用 agentInfo.agentId
|
||
const agentId = String(
|
||
this.data.agentId.value || this.data.agentInfo.value?.agentId || "",
|
||
);
|
||
|
||
// 2.1 权限判断 (UI层已处理置灰，这里主要处理状态)
|
||
if (agentInfo?.hasPermission === false) {
|
||
this.data.isSandboxSwitchDisabled.value = true;
|
||
// this.data.wholeDisabled.value = true;
|
||
// 提示语由UI层 maskText 控制，或者在这里设置 disabledText?
|
||
// 根据需求描述 "置灰对话框，提示：您无该智能体权限"
|
||
// 查看 chat-input-phone 组件，maskText 可能是 prop，但这里好像没有直接控制 maskText 的变量？
|
||
// 假设 UI 层 `chat-input-phone` 的 `has-permission` 属性已经控制了提示。
|
||
// 我们主要确保 switch disabled
|
||
return;
|
||
}
|
||
|
||
// 2.2.1 个人电脑 (Priority 1)
|
||
if (agentInfo && agentInfo.sandboxId) {
|
||
const personalSandboxId = String(agentInfo.sandboxId);
|
||
const exists = sandboxList.some(
|
||
(s) => s.sandboxId === personalSandboxId,
|
||
);
|
||
|
||
if (!exists) {
|
||
// 2.2.1.1 不在列表中 -> 展示“个人电脑不可用”
|
||
this.data.currentSandboxId.value = personalSandboxId; // 或者是空？通常显示名字需要ID匹配，或者UI显示"不可用"
|
||
this.data.isSandboxSwitchDisabled.value = true;
|
||
this.data.isSandboxUnavailable.value = true;
|
||
this.data.sandboxDisabledText.value = t(
|
||
"Mobile.Sandbox.unavailable",
|
||
);
|
||
// this.data.wholeDisabled.value = true;
|
||
} else {
|
||
// 2.2.1.2 在列表中 -> 展示对应的电脑名称且不可切换
|
||
this.data.currentSandboxId.value = personalSandboxId;
|
||
this.data.isSandboxSwitchDisabled.value = true;
|
||
this.data.isSandboxUnavailable.value = false;
|
||
this.data.sandboxDisabledText.value = "";
|
||
// this.data.wholeDisabled.value = false;
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 2.2.2 电脑列表为空 (Priority 2)
|
||
if (sandboxList.length === 0) {
|
||
this.data.currentSandboxId.value = "";
|
||
this.data.isSandboxSwitchDisabled.value = true;
|
||
this.data.isSandboxUnavailable.value = true;
|
||
this.data.sandboxDisabledText.value = t(
|
||
"Mobile.Sandbox.noneAvailable",
|
||
);
|
||
// this.data.wholeDisabled.value = true;
|
||
return;
|
||
}
|
||
|
||
// 2.2.3 共享电脑 (Priority 3)
|
||
if (conversationInfo && conversationInfo.sandboxServerId) {
|
||
const sharedSandboxId = String(conversationInfo.sandboxServerId);
|
||
const exists = sandboxList.some(
|
||
(s) => s.sandboxId === sharedSandboxId,
|
||
);
|
||
|
||
if (!exists) {
|
||
// 2.2.3.1 不在列表中 -> 展示“电脑不可用”
|
||
this.data.currentSandboxId.value = sharedSandboxId;
|
||
this.data.isSandboxSwitchDisabled.value = true;
|
||
this.data.isSandboxUnavailable.value = true;
|
||
this.data.sandboxDisabledText.value = t(
|
||
"Mobile.Sandbox.unavailable",
|
||
);
|
||
// this.data.wholeDisabled.value = true;
|
||
} else {
|
||
// 2.2.3.2 在列表中 -> 展示对应的电脑名称且不可切换
|
||
this.data.currentSandboxId.value = sharedSandboxId;
|
||
this.data.isSandboxSwitchDisabled.value = true;
|
||
this.data.isSandboxUnavailable.value = false;
|
||
this.data.sandboxDisabledText.value = "";
|
||
// this.data.wholeDisabled.value = false;
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 2.2.4 默认选择 (Priority 4)
|
||
// conversationInfo?.sandboxServerId 和 conversationInfo?.agent?.sandboxId 都为空
|
||
this.data.isSandboxSwitchDisabled.value = false;
|
||
this.data.isSandboxUnavailable.value = false;
|
||
this.data.sandboxDisabledText.value = "";
|
||
// this.data.wholeDisabled.value = false;
|
||
|
||
let initialId = "";
|
||
if (this.data.agentSelectedSandbox.value[agentId]) {
|
||
// agentSelected 优先
|
||
initialId = this.data.agentSelectedSandbox.value[agentId];
|
||
// 校验是否存在，不存在默认第一个
|
||
if (!sandboxList.some((s) => s.sandboxId === initialId)) {
|
||
initialId = sandboxList[0].sandboxId;
|
||
}
|
||
} else {
|
||
// 默认第一个
|
||
initialId = sandboxList[0].sandboxId;
|
||
}
|
||
this.data.currentSandboxId.value = initialId;
|
||
}
|
||
} catch (error) {
|
||
console.error("[AgentDetailService] 获取沙盒列表失败:", error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 切换沙盒
|
||
*/
|
||
async handleSelectSandbox(sandboxId: string): Promise<void> {
|
||
// 如果禁止切换，直接返回
|
||
if (this.data.isSandboxSwitchDisabled.value) {
|
||
console.warn("[AgentDetailService] 当前不允许切换沙盒");
|
||
return;
|
||
}
|
||
|
||
const agentId = String(
|
||
this.data.agentId.value || this.data.agentInfo.value?.agentId || "",
|
||
);
|
||
|
||
try {
|
||
// 调用 API 更新选中记录
|
||
await apiUpdateSelectedSandbox(agentId, sandboxId);
|
||
|
||
// 更新本地状态
|
||
this.data.currentSandboxId.value = sandboxId;
|
||
this.data.agentSelectedSandbox.value[agentId] = sandboxId;
|
||
|
||
// uni.showToast({
|
||
// title: "切换成功",
|
||
// icon: "none",
|
||
// });
|
||
} catch (error) {
|
||
console.error("[AgentDetailService] 切换沙盒失败:", error);
|
||
uni.showToast({
|
||
title: t("Mobile.Sandbox.switchFailed"),
|
||
icon: "none",
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 切换模型
|
||
*/
|
||
handleSelectModel(modelId: number, modelName: string = ""): void {
|
||
this.data.currentModelId.value = modelId;
|
||
if (modelName) {
|
||
this.data.currentModelName.value = modelName;
|
||
}
|
||
this.data.modelSelectVisible.value = false;
|
||
}
|
||
|
||
/**
|
||
* 恢复会话状态
|
||
* 用于页面从后台唤醒后检测并恢复会话
|
||
*
|
||
* 检测异常中断的条件：最后一条 ASSISTANT 消息状态为 Loading/Incomplete 且无 finalResult
|
||
*
|
||
* @returns 是否需要恢复（true 表示检测到异常中断并已恢复）
|
||
*/
|
||
async resumeConversationState(): Promise<boolean> {
|
||
// 1. 检查会话ID
|
||
const conversationId = this.data.conversationId.value;
|
||
if (!conversationId || this.data.isTempChat.value) {
|
||
return false;
|
||
}
|
||
|
||
// 2. 获取最后一条 ASSISTANT 消息
|
||
const messageList = this.data.messageList.value;
|
||
const lastAssistantMessage = [...messageList]
|
||
.reverse()
|
||
.find(
|
||
(msg) => msg.messageType === MessageTypeEnum.ASSISTANT && msg.status,
|
||
);
|
||
|
||
// 3. 获取前端状态
|
||
const isConversationActive = this.data.isConversationActive.value;
|
||
const isStreaming = chatService.isCurrentlyStreaming;
|
||
const isStoppingConversation = this.data.isStoppingConversation.value;
|
||
|
||
// 4. 异常中断检测
|
||
// 条件：最后一条助手消息状态为 Loading/Incomplete 且无 finalResult
|
||
const isAbnormalInterruption =
|
||
lastAssistantMessage &&
|
||
(lastAssistantMessage.status === MessageStatusEnum.Loading ||
|
||
lastAssistantMessage.status === MessageStatusEnum.Incomplete) &&
|
||
!lastAssistantMessage.finalResult;
|
||
|
||
// 5. 如果用户正在主动停止，不是异常中断
|
||
if (isStoppingConversation) {
|
||
return false;
|
||
}
|
||
|
||
// 6. 如果 SSE 仍在工作，无需恢复
|
||
if (isStreaming) {
|
||
return false;
|
||
}
|
||
|
||
// 7. 检测到异常中断
|
||
if (!isAbnormalInterruption) {
|
||
return false;
|
||
}
|
||
|
||
console.log("[SessionResume] 检测到异常中断，正在查询后端会话状态", {
|
||
lastMessageStatus: lastAssistantMessage?.status,
|
||
conversationId,
|
||
});
|
||
|
||
try {
|
||
// 8. 查询后端会话状态并刷新
|
||
const res = await apiAgentConversation(conversationId);
|
||
if (res.code === SUCCESS_CODE) {
|
||
const taskStatus = res.data?.taskStatus;
|
||
// 更新会话状态
|
||
if (taskStatus === "EXECUTING") {
|
||
// 任务仍在后端执行，保持活跃状态
|
||
this.data.isConversationActive.value = true;
|
||
} else {
|
||
// 任务已完成或取消，更新前端状态
|
||
this.data.isConversationActive.value = false;
|
||
}
|
||
|
||
// 更新消息列表（刷新页面数据）
|
||
this.handleQueryConversation(res);
|
||
console.log(
|
||
"[SessionResume] 会话状态已恢复，后端任务状态:",
|
||
taskStatus,
|
||
);
|
||
}
|
||
|
||
return true;
|
||
} catch (error) {
|
||
console.error("[SessionResume] 恢复会话状态失败:", error);
|
||
// 恢复失败时，重置前端状态
|
||
this.data.isConversationActive.value = false;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送消息
|
||
*
|
||
* @param data 消息数据
|
||
* @param isTempChat 是否是临时会话
|
||
*/
|
||
async handleSendMessage(
|
||
data: {
|
||
// 初始 chat 消息
|
||
messageInfo?: string;
|
||
// 用户上传的文件
|
||
files?: UploadFileInfo[];
|
||
// 用户选择的组件
|
||
selectedComponents?: AgentSelectedComponentInfo[];
|
||
// 用户填写的变量参数
|
||
variableParams?: { [key: string]: string | number };
|
||
// 用户选择的技能ID列表
|
||
skillIds?: number[];
|
||
// 用户选择的模型ID
|
||
modelId?: number;
|
||
// 用户选择的沙盒ID
|
||
sandboxId?: string;
|
||
},
|
||
isTempChat?: boolean = false,
|
||
// 超时回调
|
||
onTimeout?: () => void,
|
||
): Promise<void> {
|
||
const { messageInfo, files, selectedComponents, variableParams } = data;
|
||
// 安全检查：确保this.data存在
|
||
if (!this.data) {
|
||
return;
|
||
}
|
||
|
||
// 清空用户自带的url参数，只在第一次发送消息时使用，后续发送消息时不再使用
|
||
this.data.urlOtherParams.value = null;
|
||
|
||
const attachments: AttachmentFile[] =
|
||
files?.map((file) => ({
|
||
fileKey: file.key || "",
|
||
fileUrl: file.url || "",
|
||
fileName: file.name || "",
|
||
mimeType: file.type || "",
|
||
fileSize: file.size || 0,
|
||
})) || [];
|
||
|
||
// 参数验证
|
||
if ((!messageInfo || !messageInfo?.trim()) && attachments.length === 0) {
|
||
return;
|
||
}
|
||
|
||
// 是否是临时会话
|
||
if (isTempChat) {
|
||
// 链接Key 或 会话唯一标识为空
|
||
if (!this.data.chatKey.value) {
|
||
uni.showToast({
|
||
title: t("Mobile.Conversation.chatKeyRequired"),
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
return;
|
||
}
|
||
} else {
|
||
if (!this.data.conversationId.value) {
|
||
uni.showToast({
|
||
title: t("Mobile.Conversation.idRequired"),
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
return;
|
||
}
|
||
}
|
||
|
||
// #ifdef WEB || H5
|
||
// 如果不是临时会话页面，并且url中不包含conversationId，则修改url
|
||
if (!isTempChat && !location.href.includes("conversationId")) {
|
||
let newUrl = "";
|
||
|
||
// 如果是应用详情页，则跳转至应用详情页
|
||
if (location.href.includes("app-details")) {
|
||
newUrl = `/subpackages/pages/app-details/app-details?id=${this.data.agentId.value}&conversationId=${this.data.conversationId.value}`;
|
||
} else {
|
||
newUrl = `/subpackages/pages/agent-detail/agent-detail?id=${this.data.agentId.value}&conversationId=${this.data.conversationId.value}`;
|
||
}
|
||
|
||
// 修改url参数且不刷新页面
|
||
const url = new URL(location.href);
|
||
url.hash = newUrl; // 修改参数
|
||
history.replaceState(null, "", url.toString()); // 替换当前历史记录
|
||
}
|
||
// #endif
|
||
|
||
// 使用同步方法生成唯一ID（兼容所有平台）
|
||
const chatMessageId = generateUniqueId();
|
||
const currentMessageId = generateUniqueId();
|
||
|
||
// 构造消息
|
||
const chatMessage = {
|
||
role: AssistantRoleEnum.USER,
|
||
type: MessageModeEnum.CHAT,
|
||
text: messageInfo,
|
||
time: new Date().toISOString(),
|
||
attachments,
|
||
id: chatMessageId,
|
||
messageType: MessageTypeEnum.USER,
|
||
};
|
||
|
||
// 当前助手信息
|
||
const currentMessage = {
|
||
role: AssistantRoleEnum.ASSISTANT,
|
||
type: MessageModeEnum.CHAT,
|
||
text: "",
|
||
think: "",
|
||
time: new Date().toISOString(),
|
||
id: currentMessageId,
|
||
messageType: MessageTypeEnum.ASSISTANT,
|
||
status: MessageStatusEnum.Loading,
|
||
} as MessageInfo;
|
||
|
||
// 将Incomplete状态的消息改为Complete状态，并清理旧的消息状态
|
||
const completeMessageList =
|
||
this.data.messageList.value?.map((item: MessageInfo) => {
|
||
if (item.status === MessageStatusEnum.Incomplete) {
|
||
item.status = MessageStatusEnum.Complete;
|
||
}
|
||
return item;
|
||
}) || [];
|
||
|
||
// 清理旧的消息状态，确保新对话开始时状态是干净的
|
||
this.data.messageIdRef.value = "";
|
||
this.data.currentConversationRequestId.value = "";
|
||
|
||
// 更新消息列表
|
||
const newMessageList = [
|
||
...completeMessageList,
|
||
chatMessage,
|
||
currentMessage,
|
||
] as MessageInfo[];
|
||
// AgentDetailUtils.checkConversationActive(newMessageList, this.data)
|
||
this.data.isConversationActive.value = true;
|
||
this.data.messageList.value = newMessageList;
|
||
|
||
// 基础参数
|
||
const baseParams = {
|
||
variableParams,
|
||
message: messageInfo,
|
||
attachments,
|
||
selectedComponents,
|
||
skillIds: data.skillIds,
|
||
};
|
||
|
||
// 发送消息
|
||
const params: ConversationChatParams | TempConversationChatParams =
|
||
isTempChat
|
||
? {
|
||
chatKey: this.data.chatKey.value,
|
||
conversationUid: this.data.conversationUid.value,
|
||
...baseParams,
|
||
}
|
||
: {
|
||
conversationId: this.data.conversationId.value,
|
||
...baseParams,
|
||
debug: false,
|
||
sandboxId: this.data.currentSandboxId.value || data.sandboxId,
|
||
modelId:
|
||
this.data.currentModelId.value || data.modelId || undefined,
|
||
};
|
||
this.handleConversation(params, currentMessageId, isTempChat, onTimeout);
|
||
}
|
||
|
||
// 根据用户消息更新会话主题
|
||
async handleUpdateTopic(
|
||
conversationId: string,
|
||
messageInfo: string,
|
||
): Promise<void> {
|
||
const params: AgentConversationUpdateParams = {
|
||
id: conversationId,
|
||
firstMessage: messageInfo,
|
||
};
|
||
|
||
const {
|
||
code,
|
||
data: responseData,
|
||
message,
|
||
} = await apiAgentConversationUpdate(params);
|
||
if (code === SUCCESS_CODE) {
|
||
this.data.needUpdateTopicRef.value = responseData?.topicUpdated !== 1;
|
||
// 更新会话主题
|
||
this.data.conversationInfo.value = {
|
||
...this.data.conversationInfo.value,
|
||
topic: responseData?.topic,
|
||
topicUpdated: responseData?.topicUpdated,
|
||
};
|
||
} else {
|
||
uni.showToast({
|
||
title: message,
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清空会话数据
|
||
* @param isTempChat 是否是临时会话
|
||
*/
|
||
clearConversationData(isTempChat: boolean = false): void {
|
||
// 创建新会话后，问题建议列表改为空
|
||
this.data.chatSuggestList.value = [];
|
||
// 创建新会话后，是否正在加载会话改为false
|
||
this.data.isLoadingConversation.value = false;
|
||
// 创建新会话后，消息列表改为空
|
||
this.data.messageList.value = [];
|
||
// 创建新会话后，发送按钮禁用状态改为false
|
||
this.data.wholeDisabled.value = false;
|
||
// 创建新会话后，是否发送过消息改为false, 让对话设置框取消禁用状态
|
||
this.data.isSendMessageRef.value = false;
|
||
// 创建新会话后，用户填写变量参数改为空对象
|
||
this.data.userFillVariables.value = {};
|
||
|
||
// 重新根据 manualComponents 初始化默认选中的组件
|
||
this.data.selectedComponents.value = (
|
||
this.data.manualComponents.value || []
|
||
)
|
||
.filter(
|
||
(item: AgentManualComponentInfo): boolean =>
|
||
item.defaultSelected === DefaultSelectedEnum.Yes,
|
||
)
|
||
.map(
|
||
(item: AgentManualComponentInfo): AgentSelectedComponentInfo =>
|
||
({
|
||
id: item.id,
|
||
type: item.type,
|
||
}) as AgentSelectedComponentInfo,
|
||
);
|
||
|
||
if (!isTempChat) {
|
||
// 创建新会话后，需要更新会话主题
|
||
this.data.needUpdateTopicRef.value = true;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 创建新会话
|
||
*/
|
||
async createNewConversation(isAppDetails: boolean = false): Promise<void> {
|
||
if (!this.data.agentId.value) {
|
||
uni.showToast({
|
||
title: t("Mobile.Conversation.agentIdMissing"),
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 清空会话数据
|
||
this.clearConversationData();
|
||
|
||
// 如果普通会话，并且任务正在执行，则更新任务状态为 CANCEL
|
||
if (this.data.conversationInfo.value?.taskStatus === TaskStatus.EXECUTING) {
|
||
this.data.conversationInfo.value = {
|
||
...this.data.conversationInfo.value,
|
||
taskStatus: TaskStatus.CANCEL,
|
||
};
|
||
}
|
||
|
||
// 会话参数
|
||
const conversationParams: ConversationCreateParams = {
|
||
agentId: this.data.agentId.value,
|
||
devMode: false, // 开发模式, 只有智能体编排页才会设置为true
|
||
};
|
||
|
||
// 获取引导问题
|
||
this.getGuidQuestion(this.data.agentId.value);
|
||
|
||
const {
|
||
code,
|
||
data: responseData,
|
||
message,
|
||
} = await apiAgentConversationCreate(conversationParams);
|
||
if (code === SUCCESS_CODE && responseData && responseData.id) {
|
||
this.data.conversationId.value = responseData.id;
|
||
|
||
// 更新会话信息
|
||
this.data.conversationInfo.value = responseData;
|
||
if (responseData.agent) {
|
||
this.data.agentInfo.value = responseData.agent;
|
||
if (responseData.agent.manualComponents) {
|
||
this.data.manualComponents.value =
|
||
responseData.agent.manualComponents;
|
||
}
|
||
}
|
||
|
||
// 重新基于最新的 manualComponents 初始化默认选中的组件
|
||
this.data.selectedComponents.value = (
|
||
this.data.manualComponents.value || []
|
||
)
|
||
.filter(
|
||
(item: AgentManualComponentInfo): boolean =>
|
||
item.defaultSelected === DefaultSelectedEnum.Yes,
|
||
)
|
||
.map(
|
||
(item: AgentManualComponentInfo): AgentSelectedComponentInfo =>
|
||
({
|
||
id: item.id,
|
||
type: item.type,
|
||
}) as AgentSelectedComponentInfo,
|
||
);
|
||
|
||
// 重新获取沙盒列表以更新状态
|
||
this.handleGetSandboxList(responseData.agent?.allowPrivateSandbox === 1);
|
||
|
||
let newUrl = "";
|
||
|
||
// 如果是应用智能体页面，则跳转至应用智能体页面
|
||
if (isAppDetails) {
|
||
newUrl = `/subpackages/pages/app-details/app-details?id=${this.data.agentId.value}&conversationId=${responseData.id}`;
|
||
} else {
|
||
// 新会话页面URL
|
||
newUrl = `/subpackages/pages/agent-detail/agent-detail?id=${this.data.agentId.value}&conversationId=${responseData.id}`;
|
||
}
|
||
|
||
// #ifdef WEB || H5
|
||
// 修改rul参数且不刷新页面
|
||
const url = new URL(location.href);
|
||
url.hash = newUrl; // 修改参数
|
||
history.replaceState(null, "", url.toString()); // 替换当前历史记录
|
||
// #endif
|
||
|
||
// #ifdef MP-WEIXIN
|
||
uni.redirectTo({
|
||
url: newUrl,
|
||
});
|
||
// #endif
|
||
} else {
|
||
uni.showToast({
|
||
title: message,
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取引导问题
|
||
* @param agentId 智能体id
|
||
*/
|
||
async getGuidQuestion(agentId: number): Promise<void> {
|
||
const {
|
||
code,
|
||
data: responseData,
|
||
message,
|
||
} = await apiPublishedAgentInfo(agentId);
|
||
if (code === SUCCESS_CODE) {
|
||
this.data.chatSuggestList.value =
|
||
responseData?.guidQuestionDtos?.slice(0, 5) ?? [];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取基本信息
|
||
* @param appParams 开放应用参数，来自开放应用URL参数params, 包含消息信息、文件信息、组件列表、变量参数等信息
|
||
*/
|
||
async getPublishedAgentInfo(appParams?: OpenAppParams): Promise<void> {
|
||
// 查询已发布的智能体详情接口, 初始化会话id
|
||
const {
|
||
code,
|
||
data: responseData,
|
||
message,
|
||
} = await apiPublishedAgentInfo(
|
||
this.data.agentId.value,
|
||
true, // 开启获取初始化会话id
|
||
);
|
||
|
||
if (code === SUCCESS_CODE) {
|
||
this.data.agentInfo.value = responseData;
|
||
// 初始化可用组件列表和默认选中组件
|
||
this.data.manualComponents.value = responseData?.manualComponents || [];
|
||
this.data.selectedComponents.value = (
|
||
responseData?.manualComponents || []
|
||
)
|
||
.filter(
|
||
(item: AgentManualComponentInfo): boolean =>
|
||
item.defaultSelected === DefaultSelectedEnum.Yes,
|
||
)
|
||
.map(
|
||
(item: AgentManualComponentInfo): AgentSelectedComponentInfo =>
|
||
({
|
||
id: item.id,
|
||
type: item.type,
|
||
}) as AgentSelectedComponentInfo,
|
||
);
|
||
|
||
// 判断是否开启问题建议
|
||
this.data.isSuggest.value =
|
||
responseData?.openSuggest === OpenCloseEnum.Open;
|
||
// 引导问题建议（兼容旧版）
|
||
this.data.chatSuggestList.value =
|
||
responseData?.guidQuestionDtos?.length > 0
|
||
? responseData?.guidQuestionDtos
|
||
: responseData?.openingGuidQuestions?.slice(0, 5);
|
||
// 首页页面URL
|
||
const httpUrl = `${API_BASE_URL}${responseData?.pageHomeIndex ?? ""}`;
|
||
// #ifdef H5 || WEB
|
||
this.data.pageHomeUrl.value =
|
||
process.env.NODE_ENV === "production"
|
||
? `${window.location.origin}${httpUrl}`
|
||
: httpUrl;
|
||
// #endif
|
||
|
||
// #ifdef MP-WEIXIN
|
||
this.data.pageHomeUrl.value = httpUrl;
|
||
// #endif
|
||
|
||
// 变量参数
|
||
const _variables = responseData?.variables || [];
|
||
this.data.variables.value = _variables;
|
||
// 获取会话ID
|
||
this.data.conversationId.value = responseData.conversationId;
|
||
|
||
// 获取沙盒列表
|
||
this.handleGetSandboxList(responseData?.allowPrivateSandbox === 1);
|
||
|
||
// #ifdef H5 || WEB
|
||
try {
|
||
// 如果存在开放应用参数，则发送消息
|
||
if (
|
||
appParams &&
|
||
typeof appParams === "object" &&
|
||
Object.keys(appParams)?.length > 0
|
||
) {
|
||
// 保存开放应用参数
|
||
this.data.appParams.value = appParams;
|
||
const newParams: OpenAppParams = {
|
||
...appParams,
|
||
};
|
||
// 如果存在会话ID，则删除会话唯一标识
|
||
if (
|
||
Object.prototype.hasOwnProperty.call(newParams, "conversationId")
|
||
) {
|
||
delete newParams.conversationId;
|
||
}
|
||
const { message, variableParams, ...urlOtherParams } = newParams;
|
||
// 如果存在其他参数，则保存到urlOtherParams中
|
||
if (
|
||
urlOtherParams &&
|
||
typeof urlOtherParams === "object" &&
|
||
Object.keys(urlOtherParams)?.length > 0
|
||
) {
|
||
this.data.urlOtherParams.value = urlOtherParams;
|
||
}
|
||
// 如果存在变量参数，则保存变量参数
|
||
if (
|
||
variableParams &&
|
||
typeof variableParams === "object" &&
|
||
Object.keys(variableParams)?.length > 0
|
||
) {
|
||
this.data.userFillVariables.value = variableParams;
|
||
}
|
||
// 如果存在消息或文件，则发送消息
|
||
if (message && message.trim()) {
|
||
// 智能体必填变量参数 name 列表（排除系统变量）
|
||
const requiredNames = _variables
|
||
.filter((item: any) => !item.systemVariable && item.require)
|
||
.map((item: any) => item.name);
|
||
|
||
// 用户自带的url参数中的变量参数对象
|
||
const vp =
|
||
variableParams !== null &&
|
||
typeof variableParams === "object" &&
|
||
!Array.isArray(variableParams)
|
||
? (variableParams as Record<string, unknown>)
|
||
: null;
|
||
|
||
// 判断用户自带的url参数中的变量参数是否存在且不为空
|
||
const variableValuePresent = (val: unknown): boolean => {
|
||
if (val === null || val === undefined) return false;
|
||
if (typeof val === "string") return val.trim() !== "";
|
||
if (typeof val === "number") return !Number.isNaN(val);
|
||
if (typeof val === "boolean") return true;
|
||
return false;
|
||
};
|
||
|
||
// 判断用户自带的url参数中的变量参数是否满足智能体必填变量参数要求
|
||
const allRequiredInParams =
|
||
requiredNames.length === 0 ||
|
||
(vp !== null &&
|
||
requiredNames.every(
|
||
(name: string) =>
|
||
Object.prototype.hasOwnProperty.call(vp, name) &&
|
||
variableValuePresent(vp[name]),
|
||
));
|
||
|
||
/**
|
||
* 如果用户自带的url参数中的变量参数满足智能体必填变量参数要求，则发送消息，否则不发送消息
|
||
*/
|
||
if (allRequiredInParams) {
|
||
// 将消息信息转换为消息信息对象
|
||
newParams.messageInfo = message;
|
||
delete newParams.message; // 删除消息信息
|
||
// 初始化会话时，发送消息
|
||
this.handleSendMessage(newParams);
|
||
}
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error(
|
||
"[AgentDetailService] Failed to get open app params:",
|
||
error,
|
||
);
|
||
}
|
||
// #endif
|
||
|
||
// 检查订阅限制
|
||
if (responseData != null) {
|
||
const paymentRequired = responseData!.paymentRequired === true;
|
||
const subscribed = responseData!.subscribed === true;
|
||
const overCallLimit = responseData!.overCallLimit === true;
|
||
|
||
// 是否弹出模态框：要求订阅且未订阅，或超出调用限制（已订阅时不主动弹窗）
|
||
const shouldShowModal =
|
||
paymentRequired && (!subscribed || overCallLimit) && !subscribed;
|
||
if (shouldShowModal && this.data.enableSubscription.value === 1) {
|
||
this.data.subscriptionModalVisible.value = true;
|
||
} else {
|
||
this.data.subscriptionModalVisible.value = false;
|
||
}
|
||
|
||
// 是否禁用输入框：要求订阅、且未订阅、且已超出调用限制
|
||
const shouldBlockInput =
|
||
paymentRequired && !subscribed && overCallLimit;
|
||
if (shouldBlockInput && this.data.enableSubscription.value === 1) {
|
||
this.data.subscriptionRequired.value = true;
|
||
} else {
|
||
this.data.subscriptionRequired.value = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 收藏/取消收藏
|
||
*/
|
||
async handleCollect(): Promise<void> {
|
||
if (!this.data.agentInfo.value) return;
|
||
|
||
if (this.data.agentInfo.value.collect) {
|
||
const { code } = await apiUnCollectAgent(
|
||
this.data.agentInfo.value.agentId,
|
||
);
|
||
if (code === SUCCESS_CODE) {
|
||
uni.showToast({
|
||
title: t("Mobile.Conversation.unfavoriteSuccess"),
|
||
icon: "success",
|
||
duration: 2000,
|
||
});
|
||
this.data.agentInfo.value.collect = false;
|
||
}
|
||
} else {
|
||
const { code } = await apiCollectAgent(this.data.agentInfo.value.agentId);
|
||
if (code === SUCCESS_CODE) {
|
||
uni.showToast({
|
||
title: t("Mobile.Conversation.favoriteSuccess"),
|
||
icon: "success",
|
||
duration: 2000,
|
||
});
|
||
this.data.agentInfo.value.collect = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查询临时会话信息
|
||
* conversationUid: 会话唯一标识 (可选)
|
||
*/
|
||
async queryTempConversation(conversationUid: string) {
|
||
// 链接Key为空
|
||
if (!this.data.chatKey.value) {
|
||
uni.showToast({
|
||
title: t("Mobile.Conversation.chatKeyRequired"),
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
return;
|
||
}
|
||
const res = await apiTempChatConversationQuery({
|
||
chatKey: this.data.chatKey.value,
|
||
conversationUid,
|
||
});
|
||
if (res.code === SUCCESS_CODE) {
|
||
// 临时会话页, 设置导航栏标题
|
||
if (res.data?.agent) {
|
||
uni.setNavigationBarTitle({
|
||
title: t("Mobile.Conversation.startWithAgent", {
|
||
name: res.data?.agent?.name || "",
|
||
}),
|
||
});
|
||
}
|
||
|
||
// 处理消息列表
|
||
this.handleQueryConversation(res);
|
||
} else {
|
||
this.data.isLoadingConversation.value = false;
|
||
uni.showToast({
|
||
title: res.message,
|
||
icon: "none",
|
||
duration: 2000,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 创建临时会话
|
||
* chatKey 链接Key
|
||
* @param captchaVerifyParam 验证码参数 (可选)
|
||
*/
|
||
async createTempChatConversation(captchaVerifyParam: string) {
|
||
// 链接Key为空
|
||
if (!this.data.chatKey.value) {
|
||
uni.showToast({
|
||
title: t("Mobile.Conversation.chatKeyRequired"),
|
||
icon: "none",
|
||
type: "error",
|
||
});
|
||
return;
|
||
}
|
||
const params = {
|
||
chatKey: this.data.chatKey.value,
|
||
captchaVerifyParam,
|
||
};
|
||
const res = await apiTempChatConversationCreate(params);
|
||
const { data: resData, code, message } = res;
|
||
// 创建临时会话成功
|
||
if (code === SUCCESS_CODE) {
|
||
this.data.conversationUid.value = resData.uid;
|
||
uni.setStorageSync(TEMP_CONVERSATION_UID, resData.uid);
|
||
// 查询临时会话详细
|
||
this.queryTempConversation(resData.uid);
|
||
} else {
|
||
this.data.isLoadingConversation.value = false;
|
||
uni.showToast({
|
||
title: message,
|
||
icon: "none",
|
||
duration: 2000,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 重启智能体
|
||
*/
|
||
async handleRestartAgent(): Promise<void> {
|
||
const conversationId = this.data.conversationId.value;
|
||
if (!conversationId) return;
|
||
|
||
uni.showLoading({
|
||
title: t("Mobile.Common.restarting"),
|
||
mask: true,
|
||
});
|
||
try {
|
||
const res = await apiRestartAgent(conversationId);
|
||
uni.hideLoading();
|
||
if (res.code === SUCCESS_CODE) {
|
||
uni.showToast({
|
||
title: t("Mobile.Sandbox.restartAgentSuccess"),
|
||
icon: "success",
|
||
});
|
||
} else {
|
||
uni.showToast({
|
||
title: res.message || t("Mobile.Sandbox.restartAgentFailed"),
|
||
icon: "none",
|
||
});
|
||
}
|
||
} catch (error) {
|
||
uni.hideLoading();
|
||
console.error("[AgentDetailService] 重启智能体失败:", error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 重启容器/客户端
|
||
* @param isCloudComp 是否是云电脑 (currentSandboxId === '-1')
|
||
*/
|
||
async handleRestartSandbox(isCloudComp: boolean): Promise<void> {
|
||
const conversationId = this.data.conversationId.value;
|
||
if (!conversationId) return;
|
||
|
||
uni.showLoading({
|
||
title: t("Mobile.Common.restarting"),
|
||
mask: true,
|
||
});
|
||
try {
|
||
const res = await apiRestartSandbox(conversationId);
|
||
uni.hideLoading();
|
||
if (res.code === SUCCESS_CODE) {
|
||
uni.showToast({
|
||
title: isCloudComp
|
||
? t("Mobile.Sandbox.restartCloudCompSuccess")
|
||
: t("Mobile.Sandbox.restartClientSuccess"),
|
||
icon: "success",
|
||
});
|
||
} else {
|
||
uni.showToast({
|
||
title: res.message || t("Mobile.Common.operationFailed"),
|
||
icon: "none",
|
||
});
|
||
}
|
||
} catch (error) {
|
||
uni.hideLoading();
|
||
console.error("[AgentDetailService] 重启容器失败:", error);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 刷新或重新查询会话订阅与限制状态
|
||
*/
|
||
async handleCheckSubscriptionLimit(): Promise<void> {
|
||
const id = this.data.conversationId.value;
|
||
if (id) {
|
||
const res = await apiAgentConversation(id);
|
||
if (res.code === SUCCESS_CODE && res.data != null) {
|
||
const agent = res.data!.agent;
|
||
if (agent != null) {
|
||
this.data.agentInfo.value = agent;
|
||
const paymentRequired = agent.paymentRequired === true;
|
||
const subscribed = agent.subscribed === true;
|
||
const overCallLimit = agent.overCallLimit === true;
|
||
|
||
// 是否弹出模态框：要求订阅且未订阅，或超出调用限制（已订阅时不主动弹窗）
|
||
const shouldShowModal =
|
||
paymentRequired && (!subscribed || overCallLimit) && !subscribed;
|
||
if (shouldShowModal && this.data.enableSubscription.value === 1) {
|
||
this.data.subscriptionModalVisible.value = true;
|
||
} else {
|
||
this.data.subscriptionModalVisible.value = false;
|
||
}
|
||
|
||
// 是否禁用输入框：要求订阅、且未订阅、且已超出调用限制
|
||
const shouldBlockInput =
|
||
paymentRequired && !subscribed && overCallLimit;
|
||
if (shouldBlockInput && this.data.enableSubscription.value === 1) {
|
||
this.data.subscriptionRequired.value = true;
|
||
} else {
|
||
this.data.subscriptionRequired.value = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|