init

src/api/knowledge/aiBill.ts

@@ -0,0 +1,50 @@
+import request from "/@/utils/request"
+
+export function fetchList(query?: Object) {
+  return request({
+    url: '/knowledge/aiBill/page',
+    method: 'get',
+    params: query
+  })
+}
+
+export function addObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiBill',
+    method: 'post',
+    data: obj
+  })
+}
+
+export function getObj(id?: string) {
+  return request({
+    url: '/knowledge/aiBill/' + id,
+    method: 'get'
+  })
+}
+
+export function delObjs(ids?: Object) {
+  return request({
+    url: '/knowledge/aiBill',
+    method: 'delete',
+    data: ids
+  })
+}
+
+export function putObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiBill',
+    method: 'put',
+    data: obj
+  })
+}
+
+export const getSum = (params?: Object) => {
+  return request({
+    url: '/knowledge/aiBill/sum',
+    method: 'get',
+    params,
+  });
+};
+
+

src/api/knowledge/aiChatRecord.ts

@@ -0,0 +1,41 @@
+import request from "/@/utils/request"
+
+export function fetchList(query?: Object) {
+  return request({
+    url: '/knowledge/aiChatRecord/page',
+    method: 'get',
+    params: query
+  })
+}
+
+export function addObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiChatRecord',
+    method: 'post',
+    data: obj
+  })
+}
+
+export function getObj(id?: string) {
+  return request({
+    url: '/knowledge/aiChatRecord/' + id,
+    method: 'get'
+  })
+}
+
+export function delObjs(ids?: Object) {
+  return request({
+    url: '/knowledge/aiChatRecord',
+    method: 'delete',
+    data: ids
+  })
+}
+
+export function putObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiChatRecord',
+    method: 'put',
+    data: obj
+  })
+}
+

src/api/knowledge/aiData.ts

@@ -0,0 +1,41 @@
+import request from "/@/utils/request"
+
+export function fetchList(query?: Object) {
+  return request({
+    url: '/knowledge/aiData/page',
+    method: 'get',
+    params: query
+  })
+}
+
+export function addObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiData',
+    method: 'post',
+    data: obj
+  })
+}
+
+export function getObj(id?: string) {
+  return request({
+    url: '/knowledge/aiData/' + id,
+    method: 'get'
+  })
+}
+
+export function delObjs(ids?: Object) {
+  return request({
+    url: '/knowledge/aiData',
+    method: 'delete',
+    data: ids
+  })
+}
+
+export function putObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiData',
+    method: 'put',
+    data: obj
+  })
+}
+

src/api/knowledge/aiDataField.ts

@@ -0,0 +1,30 @@
+import request from '/@/utils/request';
+
+export function fetchByTableId(id: string, tableName: string) {
+	return request({
+		url: `/knowledge/aiDataField/table/${id}/${tableName}`,
+		method: 'get',
+	});
+}
+
+export function syncByTableId(id: string, tableName: string) {
+	return request({
+		url: `/knowledge/aiDataField/sync/${id}/${tableName}`,
+		method: 'post',
+	});
+}
+
+export function batchUpdateObj(data: any[]) {
+	return request({
+		url: '/knowledge/aiDataField/batch',
+		method: 'put',
+		data,
+	});
+}
+
+export function assessByTableId(id: string, tableName: string) {
+	return request({
+		url: `/knowledge/aiDataField/assess/${id}/${tableName}`,
+		method: 'post',
+	});
+}

src/api/knowledge/aiDataTable.ts

@@ -0,0 +1,55 @@
+import request from '/@/utils/request';
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiDataTable/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDataTable',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiDataTable/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiDataTable',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDataTable',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function syncObj() {
+	return request({
+		url: '/knowledge/aiDataTable/sync',
+		method: 'post',
+	});
+}
+
+export function listTables(dsName: string) {
+	return request({
+		url: '/knowledge/aiDataTable/list',
+		method: 'get',
+		params: { dsName },
+	});
+}

src/api/knowledge/aiDataset.ts

@@ -0,0 +1,70 @@
+import request from '/@/utils/request';
+
+export function fetchDataList(query?: Object) {
+	return request({
+		url: '/knowledge/aiDataset/list',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiDataset/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj: AiDataset) {
+	return request({
+		url: '/knowledge/aiDataset',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getDetails(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDataset/details',
+		method: 'get',
+		params: obj,
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiDataset',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj: AiDataset) {
+	return request({
+		url: '/knowledge/aiDataset',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function validateName(rule: any, value: any, callback: any, isEdit: boolean) {
+	if (isEdit) {
+		return callback();
+	}
+
+	getDetails({ name: value }).then((response) => {
+		const result = response.data;
+		if (result !== null) {
+			callback(new Error('名称已经存在'));
+		} else {
+			callback();
+		}
+	});
+}
+
+interface AiDataset {
+	// ... existing fields ...
+	embeddingModel: string;
+	summaryModel: string;
+}

src/api/knowledge/aiDatasetUser.ts

@@ -0,0 +1,100 @@
+import request from "/@/utils/request"
+
+/**
+ * 根据分页查询参数获取列表数据。
+ * @param {Object} [query] - 查询参数。
+ * @returns {Promise} 请求的 Promise 分页对象。
+ */
+export function fetchList(query?: Object) {
+  return request({
+    url: '/knowledge/aiDatasetUser/page',
+    method: 'get',
+    params: query
+  })
+}
+
+/**
+ * 添加一个新对象。
+ * @param {Object} [obj] - 要添加的对象。
+ * @returns {Promise} 请求的 Promise 对象 （true/false）。
+ */
+export function addObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiDatasetUser',
+    method: 'post',
+    data: obj
+  })
+}
+
+/**
+ * 根据查询参数获取对象详情。
+ * @param {Object} [obj] - 查询参数。
+ * @returns {Promise} 请求的 Promise 对象数组。
+ */
+export function getObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiDatasetUser/details',
+    method: 'get',
+    params: obj
+  })
+}
+
+/**
+ * 根据 ID 删除对象。
+ * @param {Object} [ids] - 要删除的对象 ID。
+ * @returns {Promise} 请求的 Promise 对象。
+ */
+export function delObjs(ids?: Object) {
+  return request({
+    url: '/knowledge/aiDatasetUser',
+    method: 'delete',
+    data: ids
+  })
+}
+
+/**
+ * 更新一个已存在的对象。
+ * @param {Object} [obj] - 要更新的对象。
+ * @returns {Promise} 请求的 Promise 对象。
+ */
+export function putObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiDatasetUser',
+    method: 'put',
+    data: obj
+  })
+}
+
+/**
+ * 验证某个字段的值是否已经存在。
+ * @param {Object} rule - 验证规则对象。
+ * @param {*} value - 要验证的值。
+ * @param {Function} callback - 验证完成后的回调函数。
+ * @param {boolean} isEdit - 当前操作是否为编辑。
+ * 
+ * 示例用法：
+ * 字段名: [
+ *   {
+ *     validator: (rule, value, callback) => {
+ *       validateExist(rule, value, callback, form.datasetId !== '');
+ *     },
+ *     trigger: 'blur',
+ *   },
+ * ]
+ */
+export function validateExist(rule: any, value: any, callback: any, isEdit: boolean) {
+  if (isEdit) {
+    return callback();
+  }
+
+  getObj({ [rule.field]: value }).then((response) => {
+    const result = response.data;
+    if (result !== null && result.length > 0) {
+      callback(new Error('数据已经存在'));
+    } else {
+      callback();
+    }
+  });
+}
+
+

src/api/knowledge/aiDocument.ts

@@ -0,0 +1,72 @@
+import request from '/@/utils/request';
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiDocument/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDocument',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function crawleObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDocument/crawle',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiDocument/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiDocument',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDocument',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function retrySlice(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDocument/retry/slice',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function retryIssue(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDocument/retry/issue',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function embedDocument(obj?: Object) {
+	return request({
+		url: '/knowledge/aiDocument/embed',
+		method: 'post',
+		data: obj,
+	});
+}

src/api/knowledge/aiEmbedStore.ts

@@ -0,0 +1,62 @@
+import request from '/@/utils/request';
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiEmbedStore/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function list() {
+	return request({
+		url: '/knowledge/aiEmbedStore/list',
+		method: 'get',
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiEmbedStore',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(obj: object) {
+	return request({
+		url: '/knowledge/aiEmbedStore/details',
+		method: 'get',
+		params: obj,
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiEmbedStore',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiEmbedStore',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function validateExist(rule: any, value: any, callback: any, isEdit: boolean) {
+	if (isEdit) {
+		return callback();
+	}
+	getObj({ [rule.field]: value }).then((response) => {
+		const result = response.data;
+		if (result !== null) {
+			callback(new Error('数据已经存在'));
+		} else {
+			callback();
+		}
+	});
+}

src/api/knowledge/aiFlow.ts

@@ -0,0 +1,575 @@
+import other from '/@/utils/other';
+import request from '/@/utils/request';
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+import { Session } from '/@/utils/storage';
+
+export interface IOrchestrationScope {
+	id?: string;
+	username: string;
+}
+
+export enum EOrchestrationType {
+	WORK_FLOW = 'WORK_FLOW',
+	SIMPLE = 'SIMPLE',
+}
+
+export interface IOrchestrationItem {
+	id?: string;
+	name?: string;
+	type?: EOrchestrationType;
+	description?: string;
+	isPublic?: boolean;
+	publicAddress?: string;
+	apiAddress?: string;
+	apiBaseUrl?: string;
+
+	fullScreenUrl?: string;
+	fixedUrl?: string;
+
+	questionLimit?: number;
+	whiteListEnable?: boolean;
+	whiteList?: string;
+	showSource?: boolean;
+
+	modelId?: string;
+
+	createBy?: string;
+	createTime?: string;
+	updateTime?: string;
+
+	modelSetting?: {
+		prompt?: string;
+		system?: string;
+		noReferencesPrompt?: string;
+	};
+	dialogueNumber?: number;
+	datasetIdList?: any[];
+	datasetSetting?: {
+		searchMode?: string;
+		similarity?: number;
+		topN?: number;
+		maxParagraphCharNumber?: number;
+		noReferencesSetting?: {
+			status?: string;
+			designatedAnswer?: string;
+		};
+	};
+	problemOptimizationPrompt?: string;
+	problemOptimization?: boolean;
+	prologue?: string;
+	sttModelEnable?: boolean;
+	sttModelId?: string;
+	ttsModelEnable?: boolean;
+	ttsType?: string;
+	ttsModelId?: string;
+	ttsModelParamsSetting?: {};
+	fileUploadSetting?: {
+		audio?: boolean;
+		image?: boolean;
+		video?: boolean;
+		document?: boolean;
+		maxFiles?: number;
+		fileLimit?: number;
+	};
+	disclaimerValue?: string;
+}
+
+export interface IOrchestrationAPIKey {
+	id?: string;
+	allowCrossDomain?: boolean;
+	application?: string;
+	createTime?: string;
+	crossDomainList?: string;
+	isActive?: boolean;
+	secretKey?: string;
+	updateTime?: string;
+}
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiFlow/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiFlow',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiFlow/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiFlow',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiFlow',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function exportFlow(id: string, name: string) {
+	return other.downBlobFile(`/knowledge/aiFlow/export/${id}`, {}, `${name}.dsl`);
+}
+
+export function copyFlow(id: string) {
+	return request.post(`/knowledge/aiFlow/copy/${id}`);
+}
+
+export function importFlow(data: FormData) {
+	return request.post(`/knowledge/aiFlow/import`, data);
+}
+
+export interface IOrchestrationAPIKey {
+	id?: string;
+	allowCrossDomain?: boolean;
+	application?: string;
+	createTime?: string;
+	crossDomainList?: string;
+	isActive?: boolean;
+	secretKey?: string;
+	updateTime?: string;
+}
+
+/**
+ * @description  : 编排 发起导入
+ * @return        {any}
+ */
+export async function orchestrationImportContent(data: FormData) {
+	return request.post(`/knowledge/orchestration/import/content`, data);
+}
+
+/**
+ * @description  : 编排 发起导出
+ * @return        {any}
+ */
+export async function orchestrationExportContent(id: string, name: string) {
+	return other.downBlobFile(`/knowledge/orchestration/export/content/${id}`, {}, name);
+}
+
+/**
+ * @description  : 复制 编排
+ * @param         {string} originId
+ * @param         {IOrchestrationItem} data
+ * @return        {any}
+ */
+export async function orchestrationCopy(originId: string, data: IOrchestrationItem) {
+	return request.post(`/knowledge/orchestration/copy/${originId}`, data);
+}
+
+/**
+ * @description  : 获取 编排 详情
+ * @param         {string} id
+ * @return        {any}
+ */
+export async function fetchOrchestrationInfo(id: string) {
+	return request.get(`/knowledge/orchestration/info/${id}`);
+}
+
+export async function fetchChartRecord(id: string, data: { startTime: string; endTime: string }) {
+	return request.get(`/knowledge/orchestration/chart/record/${id}`, { params: data });
+}
+
+export async function fetchOrchestrationAPIKeyList(data: { id: string }) {
+	return request.get(`/knowledge/orchestration/apikey/${data.id}`);
+}
+
+export async function orchestrationAPIKeyUpdate(data: any) {
+	return request.put(`/knowledge/orchestration/apikey/update`, data);
+}
+
+export async function orchestrationAPIKeyAdd(id: string) {
+	return request.post(`/knowledge/orchestration/apikey/${id}/add`);
+}
+
+export async function orchestrationAPIKeyRemove(id: string) {
+	return request.delete(`/knowledge/orchestration/apikey/${id}/delete`);
+}
+
+/**
+ * @description  : 获取模型的参数设置
+ * @param         {string} orchestrationId
+ * @param         {string} modelId
+ * @return        {any}
+ */
+export async function fetchModelParamsForm(orchestrationId: string, modelId: string) {
+	return request.get(`/knowledge/orchestration/${orchestrationId}/modelParamsForm/${modelId}`);
+}
+
+/**
+ * @description  : 播放测试文本
+ * @param         {string} id
+ * @param         {any} data
+ * @return        {any}
+ */
+export function playDemoText(id: string, data: any) {
+	return request.post(`/knowledge/orchestration/playDemoText/${id}`, data, {
+		responseType: 'blob',
+	});
+}
+
+/**
+ * @description  : 文件上传
+ * @param         {String} application_id
+ * @param         {String} chat_id
+ * @param         {any} data
+ * @return        {any}
+ */
+export function chatUploadFile(application_id: string, chat_id: String, data: any) {
+	return request.post(`/knowledge/orchestration/uploadFile/${application_id}/${chat_id}`, data);
+}
+
+/**
+ * @description  : 上传录音文件
+ * @param         {string} application_id
+ * @param         {any} data
+ * @return        {any}
+ */
+export function chatPostSpeechToText(application_id: string, data: any) {
+	return request.post(`/knowledge/orchestration/chatPostSpeechToText/${application_id}`, data);
+}
+
+export interface FlowExecutionResult {
+	nodes: any[];
+	executed: boolean;
+	result: any;
+	duration: number;
+	error?: string;
+	totalTokens?: number;
+}
+
+export interface FlowExecutionEvent {
+	type: 'start' | 'progress' | 'complete' | 'error' | 'chat_message';
+	nodeId?: string;
+	nodeName?: string;
+	data?: any;
+	progress?: number;
+	error?: string;
+	result?: FlowExecutionResult;
+	content?: string;
+	tokens?: number; // 添加 tokens 字段
+	duration?: number; // 添加 duration 字段
+	nodes?: Array<any>; // 添加 nodes 字段
+	isStreaming?: boolean;
+}
+
+export interface FlowExecutionCallbacks {
+	onStart?: () => void;
+	onProgress?: (event: FlowExecutionEvent) => void;
+	onComplete?: (result: FlowExecutionResult) => void;
+	onError?: (error: string) => void;
+	onChatMessage?: (content: string, isComplete: boolean, tokens?: number, duration?: number, nodes?: Array<any>) => void;
+}
+
+export function executeFlow(data: { id: string; params: any; envs: any; stream?: boolean }) {
+	return request.post(`/knowledge/aiFlow/execute`, data, {
+		timeout: 300000 // 设置超时时间为300秒 (300000毫秒)
+	});
+}
+
+/**
+ * 使用SSE执行工作流，提供实时执行状态更新
+ * @param data 执行参数
+ * @param callbacks 回调函数
+ * @returns Promise<FlowExecutionResult>
+ */
+export async function executeFlowSSE(
+	data: { id: string; params: any; envs: any; stream?: boolean },
+	callbacks?: FlowExecutionCallbacks
+): Promise<FlowExecutionResult> {
+	const token = Session.getToken();
+	const tenant = Session.getTenant();
+	
+	return new Promise<FlowExecutionResult>((resolve, reject) => {
+		let controller: AbortController | null = new AbortController();
+		let result: FlowExecutionResult | null = null;
+
+		const cleanup = () => {
+			if (controller) {
+				controller.abort();
+				controller = null;
+			}
+		};
+
+		// 解析SSE返回的数据
+		const parseSSEResponse = (eventData: string) => {
+			try {
+				const parsed = JSON.parse(eventData);
+				
+				// 处理聊天格式的数据: {"data":{"content":"...", "tokens": 123, "duration": 22986, "nodes": [...]}}
+				if (parsed.data && parsed.data.content !== undefined) {
+					return {
+						type: 'chat_message',
+						content: parsed.data.content,
+						tokens: parsed.data.tokens, // 添加 tokens 字段
+						duration: parsed.data.duration, // 添加 duration 字段
+						nodes: parsed.data.nodes, // 添加 nodes 字段
+						isStreaming: true
+					} as FlowExecutionEvent;
+				}
+				
+				// 处理标准的FlowExecutionEvent格式
+				return parsed as FlowExecutionEvent;
+			} catch (e) {
+				return null;
+			}
+		};
+
+		const fetchOptions = {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${token}`,
+				'TENANT-ID': tenant,
+			},
+			body: JSON.stringify(data),
+			signal: controller.signal,
+			async onopen(response: Response) {
+				if (response.ok && response.headers.get('content-type')?.includes('text/event-stream')) {
+					callbacks?.onStart?.();
+					return;
+				}
+				throw new Error(`Failed to connect: ${response.status} ${response.statusText}`);
+			},
+			onmessage(event: { data: string }) {
+				const parsed = parseSSEResponse(event.data);
+				if (!parsed) return;
+
+				switch (parsed.type) {
+					case 'start':
+						callbacks?.onStart?.();
+						break;
+					case 'progress':
+						callbacks?.onProgress?.(parsed);
+						break;
+					case 'chat_message':
+						// 处理聊天消息流
+						if (parsed.content !== undefined) {
+												// 检查是否收到完成标记
+					if (parsed.content === '[DONE]') {
+						// 标记聊天消息完成并关闭连接，传递 tokens、duration 和 nodes 信息
+						callbacks?.onChatMessage?.('', true, parsed.tokens, parsed.duration, parsed.nodes);
+						cleanup();
+						// 如果没有正式的结果，创建一个默认结果
+						if (!result) {
+							result = {
+								nodes: parsed.nodes || [],
+								executed: true,
+								result: {},
+								duration: parsed.duration || 0,
+								totalTokens: parsed.tokens || 0
+							};
+							callbacks?.onComplete?.(result);
+							resolve(result);
+						}
+						return;
+					}
+					callbacks?.onChatMessage?.(parsed.content, false, parsed.tokens, parsed.duration, parsed.nodes);
+						}
+						break;
+					case 'complete':
+						if (parsed.result) {
+							result = parsed.result;
+							callbacks?.onComplete?.(parsed.result);
+							resolve(parsed.result);
+						}
+						break;
+					case 'error':
+						const errorMsg = parsed.error || 'Unknown error occurred';
+						callbacks?.onError?.(errorMsg);
+						reject(new Error(errorMsg));
+						break;
+				}
+			},
+			onclose() {
+				// 连接关闭时，如果有未完成的聊天消息，标记为完成
+				if (callbacks?.onChatMessage) {
+					callbacks.onChatMessage('', true);
+				}
+				cleanup();
+			},
+			onerror(error: Error) {
+				cleanup();
+				const errorMsg = error.message || 'Connection error';
+				callbacks?.onError?.(errorMsg);
+				// 抛出错误以停止自动重试
+				throw error;
+			},
+		};
+
+		// 启动SSE连接
+		fetchEventSource(`${request.defaults.baseURL}${other.adaptationUrl('/knowledge/aiFlow/execute')}`, fetchOptions)
+			.catch((error) => {
+				cleanup();
+				if (error.name === 'AbortError') {
+					reject(new Error('Request was cancelled'));
+				} else {
+					reject(error);
+				}
+			});
+
+		// 返回清理函数以便外部可以取消请求
+		return cleanup;
+	});
+}
+
+/**
+ * 取消SSE工作流执行
+ * @param executionId 执行ID
+ */
+export async function cancelFlowExecution(executionId: string) {
+	return request.post(`/knowledge/aiFlow/cancel/${executionId}`);
+}
+
+/**
+ * 专为聊天格式设计的SSE工作流执行函数
+ * 处理 {"data":{"content":"..."}} 格式的流式响应
+ * @param data 执行参数
+ * @param callbacks 回调函数
+ * @returns Promise<{chatMessage: string, result: any}>
+ */
+export async function executeFlowSSEWithChat(
+	data: { id: string; conversationId: string; params: any; envs: any; stream?: boolean },
+	callbacks?: FlowExecutionCallbacks
+): Promise<{chatMessage: string, result: any}> {
+	const token = Session.getToken();
+	const tenant = Session.getTenant();
+	
+	return new Promise<{chatMessage: string, result: any}>((resolve, reject) => {
+		let controller: AbortController | null = new AbortController();
+		let chatMessageContent = '';
+		let hasReceivedData = false;
+
+		const cleanup = () => {
+			if (controller) {
+				controller.abort();
+				controller = null;
+			}
+		};
+
+		const fetchOptions = {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${token}`,
+				'TENANT-ID': tenant,
+			},
+			body: JSON.stringify(data),
+			signal: controller.signal,
+			async onopen(response: Response) {
+				if (response.ok && response.headers.get('content-type')?.includes('text/event-stream')) {
+					callbacks?.onStart?.();
+					return;
+				}
+				throw new Error(`Failed to connect: ${response.status} ${response.statusText}`);
+			},
+			onmessage(event: { data: string }) {
+				try {
+					const parsed = JSON.parse(event.data);
+					
+					// 处理聊天格式的数据: {"data":{"content":"...", "tokens": 123, "duration": 22986}}
+					if (parsed.data && parsed.data.content !== undefined) {
+						hasReceivedData = true;
+						
+										// 检查是否收到完成标记
+				if (parsed.data.content === '[DONE]') {
+					const result = {
+						chatMessage: chatMessageContent,
+						result: {
+							nodes: parsed.data.nodes || [],
+							executed: true,
+							result: {},
+							duration: parsed.data.duration || 0,
+							totalTokens: parsed.data.tokens || 0
+						}
+					};
+					callbacks?.onChatMessage?.('', true, parsed.data.tokens, parsed.data.duration, parsed.data.nodes); // 标记聊天消息完成，传递 tokens、duration 和 nodes
+					callbacks?.onComplete?.(result.result);
+					cleanup();
+					resolve(result);
+					return;
+				}
+				
+				chatMessageContent += parsed.data.content;
+				callbacks?.onChatMessage?.(parsed.data.content, false, parsed.data.tokens, parsed.data.duration, parsed.data.nodes);
+						return;
+					}
+					
+					// 处理其他类型的事件
+					if (parsed.type) {
+						switch (parsed.type) {
+							case 'start':
+								callbacks?.onStart?.();
+								break;
+							case 'progress':
+								callbacks?.onProgress?.(parsed);
+								break;
+							case 'complete':
+								const result = {
+									chatMessage: chatMessageContent,
+									result: parsed.result || {}
+								};
+								callbacks?.onChatMessage?.('', true); // 标记聊天消息完成
+								callbacks?.onComplete?.(parsed.result);
+								resolve(result);
+								break;
+							case 'error':
+								const errorMsg = parsed.error || 'Unknown error occurred';
+								callbacks?.onError?.(errorMsg);
+								reject(new Error(errorMsg));
+								break;
+						}
+					}
+				} catch (e) {
+					// 忽略无法解析的数据
+				}
+			},
+			onclose() {
+				// 连接关闭时，如果有数据但没有收到完成事件，自动完成
+				if (hasReceivedData) {
+					const result = {
+						chatMessage: chatMessageContent,
+						result: {}
+					};
+					callbacks?.onChatMessage?.('', true);
+					resolve(result);
+				}
+				cleanup();
+			},
+			onerror(error: Error) {
+				cleanup();
+				const errorMsg = error.message || 'Connection error';
+				callbacks?.onError?.(errorMsg);
+				// 抛出错误以停止自动重试
+				throw error;
+			},
+		};
+
+		// 启动SSE连接
+		fetchEventSource(`${request.defaults.baseURL}${other.adaptationUrl('/knowledge/aiFlow/execute')}`, fetchOptions)
+			.catch((error) => {
+				cleanup();
+				if (error.name === 'AbortError') {
+					reject(new Error('Request was cancelled'));
+				} else {
+					reject(error);
+				}
+			});
+	});
+}

src/api/knowledge/aiGen.ts

@@ -0,0 +1,80 @@
+import request from '/@/utils/request';
+
+export const genText = (content: object) => {
+	return request({
+		url: '/knowledge/chat/generate/text',
+		method: 'post',
+		data: content,
+	});
+};
+
+export const genTts = (prompt: String) => {
+	return request({
+		url: '/knowledge/chat/generate/tts',
+		method: 'post',
+		data: { prompt },
+	});
+};
+
+export const genImage = (params: {
+	prompt: string;
+	negativePrompt?: string;
+	imageSize: string;
+	batchSize: number;
+	seed?: number | string;
+	numInferenceSteps: number;
+	guidanceScale: number;
+	image?: string;
+	model: string;
+}) => {
+	return request({
+		url: '/knowledge/completions/image',
+		method: 'post',
+		data: params,
+	});
+};
+
+export interface VideoCompletionParams {
+	model: string;
+	imageSize: string;
+	seed?: number;
+	negativePrompt?: string;
+	prompt: string;
+	image?: string;
+}
+
+export const generateVideoCompletion = (params: VideoCompletionParams) => {
+	return request({
+		url: '/knowledge/completions/video',
+		method: 'post',
+		data: params,
+	});
+};
+
+export const getVideoCompletionStatus = (requestId: string, modelName: string) => {
+	return request({
+		url: `/knowledge/completions/video/status`,
+		params: {
+			requestId,
+			modelName,
+		},
+		method: 'get',
+	});
+};
+
+export interface VoiceCompletionParams {
+	input: string;
+	model: string;
+	voice?: string;
+	speed?: number; // Range: 0.25 <= x <= 4, default: 1
+	gain?: number; // Range: -10 <= x <= 10, default: 0
+}
+
+// mock 数据：  return { data: 'https://audio.transistor.fm/m/shows/15/dai/67e8213447a11492c2bd33d777d596bf.mp3' };
+export const genAudio = (params: VoiceCompletionParams) => {
+	return request({
+		url: '/knowledge/completions/voice',
+		method: 'post',
+		data: params,
+	});
+};

src/api/knowledge/aiMaterialLog.ts

@@ -0,0 +1,41 @@
+import request from "/@/utils/request"
+
+export function fetchList(query?: Object) {
+  return request({
+    url: '/knowledge/aiMaterialLog/page',
+    method: 'get',
+    params: query
+  })
+}
+
+export function addObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiMaterialLog',
+    method: 'post',
+    data: obj
+  })
+}
+
+export function getObj(id?: string) {
+  return request({
+    url: '/knowledge/aiMaterialLog/' + id,
+    method: 'get'
+  })
+}
+
+export function delObjs(ids?: Object) {
+  return request({
+    url: '/knowledge/aiMaterialLog',
+    method: 'delete',
+    data: ids
+  })
+}
+
+export function putObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiMaterialLog',
+    method: 'put',
+    data: obj
+  })
+}
+

src/api/knowledge/aiMcpConfig.ts

@@ -0,0 +1,57 @@
+import request from '/@/utils/request';
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiMcpConfig/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function list() {
+	return request({
+		url: '/knowledge/aiMcpConfig/list',
+		method: 'get',
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiMcpConfig',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiMcpConfig/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiMcpConfig',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiMcpConfig',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function getTools(mcpId: string) {
+	return request({
+		url: `/knowledge/aiMcpConfig/list/tools`,
+		method: 'get',
+		params: {
+			mcpId,
+		},
+	});
+}

src/api/knowledge/aiModel.ts

@@ -0,0 +1,77 @@
+import request from '/@/utils/request';
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiModel/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function details(query?: Object) {
+	return request({
+		url: '/knowledge/aiModel/details',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function list(query?: Object) {
+	return request({
+		url: '/knowledge/aiModel/list',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiModel',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function sync() {
+	return request({
+		url: '/knowledge/aiModel/sync',
+		method: 'post',
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiModel/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiModel',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiModel',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function validateExist(rule: any, value: any, callback: any, isEdit: boolean) {
+	if (isEdit) {
+		return callback();
+	}
+	details({ [rule.field]: value }).then((response) => {
+		const result = response.data;
+		if (result !== null && result.length > 0) {
+			callback(new Error('数据已经存在'));
+		} else {
+			callback();
+		}
+	});
+}

src/api/knowledge/aiPoster.ts

@@ -0,0 +1,48 @@
+import request from '/@/utils/request';
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiPoster/list',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiPoster',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiPoster/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiPoster',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiPoster',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function generate(obj?: Object) {
+	return request({
+		url: '/knowledge/aiPoster/generate',
+		method: 'post',
+		data: obj,
+	});
+}

src/api/knowledge/aiPrompt.ts

@@ -0,0 +1,64 @@
+import request from '/@/utils/request';
+
+export function list(query?: Object) {
+	return request({
+		url: '/knowledge/aiPrompt/list',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function functions(query?: Object) {
+	return request({
+		url: '/knowledge/aiFunc/functions',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiPrompt/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiPrompt',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiPrompt/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiPrompt',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiPrompt',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function optimizeAiPrompt(obj?: Object) {
+	return request({
+		url: '/knowledge/aiPrompt/optimize',
+		method: 'post',
+		data: obj,
+	});
+}

src/api/knowledge/aiReportConf.ts

@@ -0,0 +1,57 @@
+import request from '/@/utils/request';
+
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/aiReportConf/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiReportConf',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function getObj(id?: string) {
+	return request({
+		url: '/knowledge/aiReportConf/' + id,
+		method: 'get',
+	});
+}
+
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/aiReportConf',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/aiReportConf',
+		method: 'put',
+		data: obj,
+	});
+}
+
+export function parseDoc(obj?: Object) {
+	return request({
+		url: '/knowledge/aiReportConf/parse',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function generateReport(obj?: Object) {
+	return request({
+		url: '/knowledge/aiReportConf/download',
+		method: 'post',
+		data: obj,
+		responseType: 'blob',
+	});
+}

src/api/knowledge/aiSlice.ts

@@ -0,0 +1,49 @@
+import request from "/@/utils/request"
+
+export function fetchList(query?: Object) {
+  return request({
+    url: '/knowledge/aiSlice/page',
+    method: 'get',
+    params: query
+  })
+}
+
+export function fetchRecall(query?: Object) {
+  return request({
+    url: '/knowledge/aiSlice/recall',
+    method: 'get',
+    params: query
+  })
+}
+
+export function addObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiSlice',
+    method: 'post',
+    data: obj
+  })
+}
+
+export function getObj(id?: string) {
+  return request({
+    url: '/knowledge/aiSlice/' + id,
+    method: 'get'
+  })
+}
+
+export function delObjs(ids?: Object) {
+  return request({
+    url: '/knowledge/aiSlice',
+    method: 'delete',
+    data: ids
+  })
+}
+
+export function putObj(obj?: Object) {
+  return request({
+    url: '/knowledge/aiSlice',
+    method: 'put',
+    data: obj
+  })
+}
+

src/api/knowledge/ocr.ts

@@ -0,0 +1,107 @@
+import request from '/@/utils/request';
+
+/**
+ * 根据分页查询参数获取列表数据。
+ * @param {Object} [query] - 查询参数。
+ * @returns {Promise} 请求的 Promise 分页对象。
+ */
+export function fetchList(query?: Object) {
+	return request({
+		url: '/knowledge/ocr/page',
+		method: 'get',
+		params: query,
+	});
+}
+
+/**
+ * 添加一个新对象。
+ * @param {Object} [obj] - 要添加的对象。
+ * @returns {Promise} 请求的 Promise 对象 （true/false）。
+ */
+export function addObj(obj?: Object) {
+	return request({
+		url: '/knowledge/ocr',
+		method: 'post',
+		data: obj,
+	});
+}
+
+export function parseObj(obj?: Object) {
+	return request({
+		url: '/knowledge/ocr/parse',
+		method: 'post',
+		data: obj,
+		timeout: 100000, // 设置该请求的超时时间为100秒
+	});
+}
+
+/**
+ * 根据查询参数获取对象详情。
+ * @param {Object} [obj] - 查询参数。
+ * @returns {Promise} 请求的 Promise 对象数组。
+ */
+export function getObj(obj?: Object) {
+	return request({
+		url: '/knowledge/ocr/details',
+		method: 'get',
+		params: obj,
+	});
+}
+
+/**
+ * 根据 ID 删除对象。
+ * @param {Object} [ids] - 要删除的对象 ID。
+ * @returns {Promise} 请求的 Promise 对象。
+ */
+export function delObjs(ids?: Object) {
+	return request({
+		url: '/knowledge/ocr',
+		method: 'delete',
+		data: ids,
+	});
+}
+
+/**
+ * 更新一个已存在的对象。
+ * @param {Object} [obj] - 要更新的对象。
+ * @returns {Promise} 请求的 Promise 对象。
+ */
+export function putObj(obj?: Object) {
+	return request({
+		url: '/knowledge/ocr',
+		method: 'put',
+		data: obj,
+	});
+}
+
+/**
+ * 验证某个字段的值是否已经存在。
+ * @param {Object} rule - 验证规则对象。
+ * @param {*} value - 要验证的值。
+ * @param {Function} callback - 验证完成后的回调函数。
+ * @param {boolean} isEdit - 当前操作是否为编辑。
+ *
+ * 示例用法：
+ * 字段名: [
+ *   {
+ *     validator: (rule, value, callback) => {
+ *       validateExist(rule, value, callback, form.id !== '');
+ *     },
+ *     trigger: 'blur',
+ *   },
+ * ]
+ */
+export function validateExist(rule: any, value: any, callback: any, isEdit: boolean) {
+	if (isEdit) {
+		return callback();
+	}
+
+	getObj({ [rule.field]: value }).then((response) => {
+		const result = response.data;
+		if (result !== null && result.length > 0) {
+			callback(new Error('数据已经存在'));
+		} else {
+			callback();
+		}
+	});
+}