@antdv-next/x-sdk 0.0.1

package/dist/x-chat/index.js

@@ -0,0 +1,292 @@
+import { n as chatMessagesStoreHelper, t as ChatMessagesStore } from "../store-C1diHqNH.js";
+import { computed, isRef, onScopeDispose, reactive, ref, shallowRef, watch } from "vue";
+//#region src/x-chat/index.ts
+function toArray(item) {
+	return Array.isArray(item) ? item : [item];
+}
+function resolveMaybeRef(value) {
+	return isRef(value) ? value.value : value;
+}
+var IsRequestingMap = reactive(/* @__PURE__ */ new Map());
+var generateConversationKey = () => Symbol("ConversationKey");
+function useXChat(config) {
+	const { defaultMessages, requestFallback, requestPlaceholder, parser, provider } = config;
+	const idRef = ref(0);
+	const requestHandlerRef = shallowRef();
+	const conversationKey = ref((config.conversationKey ? resolveMaybeRef(config.conversationKey) : void 0) ?? generateConversationKey());
+	if (config.conversationKey && isRef(config.conversationKey)) watch(config.conversationKey, (value) => {
+		if (value !== void 0 && value !== null) conversationKey.value = value;
+	});
+	const messageQueueMap = /* @__PURE__ */ new Map();
+	const activeStore = shallowRef();
+	const messages = ref([]);
+	const isDefaultMessagesRequesting = ref(false);
+	let unsubscribeStore = null;
+	const resolveDefaultMessages = async (currentConversationKey) => {
+		return ((typeof defaultMessages === "function" ? await defaultMessages({ conversationKey: currentConversationKey }) : defaultMessages) || []).map((info, index) => ({
+			id: `default_${index}`,
+			status: "local",
+			...info
+		}));
+	};
+	const createStore = (currentConversationKey) => {
+		const existingStore = chatMessagesStoreHelper.get(currentConversationKey);
+		if (existingStore) return existingStore;
+		return new ChatMessagesStore(() => resolveDefaultMessages(currentConversationKey), currentConversationKey);
+	};
+	const syncStoreSnapshot = () => {
+		if (!activeStore.value) {
+			messages.value = [];
+			isDefaultMessagesRequesting.value = false;
+			return;
+		}
+		const snapshot = activeStore.value.getSnapshot();
+		messages.value = snapshot.messages;
+		isDefaultMessagesRequesting.value = snapshot.isDefaultMessagesRequesting;
+	};
+	const bindStore = (currentConversationKey) => {
+		if (unsubscribeStore) {
+			unsubscribeStore();
+			unsubscribeStore = null;
+		}
+		activeStore.value = createStore(currentConversationKey);
+		syncStoreSnapshot();
+		unsubscribeStore = activeStore.value.subscribe(syncStoreSnapshot);
+	};
+	bindStore(conversationKey.value);
+	watch(conversationKey, (nextConversationKey) => {
+		bindStore(nextConversationKey);
+	});
+	onScopeDispose(() => {
+		if (unsubscribeStore) {
+			unsubscribeStore();
+			unsubscribeStore = null;
+		}
+	});
+	const setMessages = (updater) => {
+		return activeStore.value?.setMessages(updater) ?? false;
+	};
+	const getMessages = () => {
+		return activeStore.value?.getMessages() ?? [];
+	};
+	const setMessage = (id, message) => {
+		return activeStore.value?.setMessage(id, message) ?? false;
+	};
+	const removeMessage = (id) => {
+		return activeStore.value?.removeMessage(id) ?? false;
+	};
+	const createMessage = (message, status, extraInfo) => {
+		const msg = {
+			id: `msg_${idRef.value}`,
+			message,
+			status
+		};
+		if (extraInfo) msg.extraInfo = extraInfo;
+		idRef.value += 1;
+		return msg;
+	};
+	const parsedMessages = computed(() => {
+		const list = [];
+		messages.value.forEach((agentMsg) => {
+			const sourceMessage = agentMsg.message;
+			const bubbleMsgs = toArray(parser ? parser(sourceMessage) : sourceMessage);
+			bubbleMsgs.forEach((bubbleMsg, bubbleMsgIndex) => {
+				let key = agentMsg.id;
+				if (bubbleMsgs.length > 1) key = `${key}_${bubbleMsgIndex}`;
+				list.push({
+					id: key,
+					message: bubbleMsg,
+					status: agentMsg.status
+				});
+			});
+		});
+		return list;
+	});
+	const getFilteredMessages = (msgs) => msgs.filter((info) => info.status !== "loading").map((info) => info.message);
+	provider?.injectGetMessages(() => {
+		return getFilteredMessages(getMessages());
+	});
+	requestHandlerRef.value = provider?.request;
+	const getRequestMessages = () => getFilteredMessages(getMessages());
+	const innerOnRequest = (requestParams, opts) => {
+		if (!provider) return;
+		const { updatingId, reload } = opts || {};
+		let loadingMsgId = null;
+		const localMessage = provider.transformLocalMessage(requestParams);
+		const localMessages = (Array.isArray(localMessage) ? localMessage : [localMessage]).map((message) => createMessage(message, "local", opts?.extraInfo));
+		if (reload) {
+			loadingMsgId = updatingId;
+			setMessages((ori) => {
+				const nextMessages = [...ori];
+				if (requestPlaceholder) {
+					let placeholderMsg;
+					if (typeof requestPlaceholder === "function") placeholderMsg = requestPlaceholder(requestParams, { messages: getFilteredMessages(nextMessages) });
+					else placeholderMsg = requestPlaceholder;
+					nextMessages.forEach((info) => {
+						if (info.id === updatingId) {
+							info.status = "loading";
+							info.message = placeholderMsg;
+							if (opts?.extraInfo) info.extraInfo = opts?.extraInfo;
+						}
+					});
+				}
+				return nextMessages;
+			});
+		} else setMessages((ori) => {
+			let nextMessages = [...ori, ...localMessages];
+			if (requestPlaceholder) {
+				let placeholderMsg;
+				if (typeof requestPlaceholder === "function") placeholderMsg = requestPlaceholder(requestParams, { messages: getFilteredMessages(nextMessages) });
+				else placeholderMsg = requestPlaceholder;
+				const loadingMsg = createMessage(placeholderMsg, "loading");
+				loadingMsgId = loadingMsg.id;
+				nextMessages = [...nextMessages, loadingMsg];
+			}
+			return nextMessages;
+		});
+		let updatingMsgId = null;
+		const updateMessage = (status, chunk, chunks, responseHeaders) => {
+			let msg = getMessages().find((info) => info.id === updatingMsgId);
+			if (!msg) if (reload && updatingId) {
+				msg = getMessages().find((info) => info.id === updatingId);
+				if (msg) {
+					msg.status = status;
+					msg.message = provider.transformMessage({
+						chunk,
+						status,
+						chunks,
+						responseHeaders
+					});
+					setMessages((ori) => {
+						return [...ori];
+					});
+					updatingMsgId = msg.id;
+				}
+			} else {
+				msg = createMessage(provider.transformMessage({
+					chunk,
+					status,
+					chunks,
+					responseHeaders
+				}), status);
+				setMessages((ori) => {
+					return [...ori.filter((info) => info.id !== loadingMsgId), msg];
+				});
+				updatingMsgId = msg.id;
+			}
+			else setMessages((ori) => {
+				return ori.map((info) => {
+					if (info.id === updatingMsgId) {
+						const transformData = provider.transformMessage({
+							originMessage: info.message,
+							chunk,
+							chunks,
+							status,
+							responseHeaders
+						});
+						return {
+							...info,
+							message: transformData,
+							status
+						};
+					}
+					return info;
+				});
+			});
+			msg = getMessages().find((info) => info.id === updatingMsgId) || msg;
+			return msg;
+		};
+		provider.injectRequest({
+			onUpdate: (chunk, headers) => {
+				return updateMessage("updating", chunk, [], headers);
+			},
+			onSuccess: (chunks, headers) => {
+				if (conversationKey.value) IsRequestingMap.delete(conversationKey.value);
+				return updateMessage("success", void 0, chunks, headers);
+			},
+			onError: async (error, errorInfo) => {
+				if (conversationKey.value) IsRequestingMap.delete(conversationKey.value);
+				let fallbackMsg;
+				if (requestFallback) {
+					if (typeof requestFallback === "function") {
+						const currentMessages = getRequestMessages();
+						fallbackMsg = await requestFallback(requestParams, {
+							error,
+							errorInfo,
+							messageInfo: getMessages().find((info) => info.id === loadingMsgId || info.id === updatingMsgId),
+							messages: currentMessages
+						});
+					} else fallbackMsg = requestFallback;
+					setMessages((ori) => [...ori.filter((info) => info.id !== loadingMsgId && info.id !== updatingMsgId), createMessage(fallbackMsg, error.name === "AbortError" ? "abort" : "error")]);
+				} else {
+					fallbackMsg = getMessages().find((info) => info.id !== loadingMsgId && info.id !== updatingMsgId);
+					setMessages((ori) => {
+						return ori.map((info) => {
+							if (info.id === loadingMsgId || info.id === updatingMsgId) return {
+								...info,
+								status: error.name === "AbortError" ? "abort" : "error"
+							};
+							return info;
+						});
+					});
+				}
+				return fallbackMsg;
+			}
+		});
+		if (conversationKey.value) IsRequestingMap.set(conversationKey.value, true);
+		provider.request.run(provider.transformParams(requestParams, provider.request.options));
+	};
+	const onRequest = (requestParams, opts) => {
+		if (!provider) throw new Error("provider is required");
+		innerOnRequest(requestParams, opts);
+	};
+	const onReload = (id, requestParams, opts) => {
+		if (!provider) throw new Error("provider is required");
+		if (!id || !getMessages().find((info) => info.id === id)) throw new Error(`message [${id}] is not found`);
+		innerOnRequest(requestParams, {
+			updatingId: id,
+			reload: true,
+			extraInfo: opts?.extraInfo
+		});
+	};
+	const processMessageQueue = () => {
+		const requestParamsList = messageQueueMap.get(conversationKey.value);
+		if (requestParamsList && requestParamsList.length > 0) {
+			const timer = setTimeout(() => {
+				clearTimeout(timer);
+				requestParamsList.forEach(({ requestParams, opts }) => {
+					onRequest(requestParams, opts);
+				});
+				messageQueueMap.delete(conversationKey.value);
+			});
+		}
+	};
+	watch(isDefaultMessagesRequesting, (requesting) => {
+		if (!requesting) processMessageQueue();
+	});
+	const queueRequest = (currentConversationKey, requestParams, opts) => {
+		if (!messageQueueMap.has(currentConversationKey)) messageQueueMap.set(currentConversationKey, []);
+		messageQueueMap.get(currentConversationKey).push({
+			requestParams,
+			opts
+		});
+	};
+	return {
+		onRequest,
+		isDefaultMessagesRequesting,
+		messages,
+		parsedMessages,
+		setMessages,
+		removeMessage,
+		setMessage,
+		abort: () => {
+			if (!provider) throw new Error("provider is required");
+			requestHandlerRef.value?.abort();
+		},
+		isRequesting: computed(() => conversationKey.value ? IsRequestingMap.get(conversationKey.value) || false : false),
+		onReload,
+		queueRequest
+	};
+}
+//#endregion
+export { useXChat as default };

package/dist/x-chat/store.d.ts

@@ -0,0 +1,38 @@
+export type ConversationKey = string | number | symbol;
+export declare const chatMessagesStoreHelper: {
+    _chatMessagesStores: Map<ConversationKey, ChatMessagesStore<any>>;
+    get: (conversationKey: ConversationKey) => ChatMessagesStore<any> | undefined;
+    set: (key: ConversationKey, store: ChatMessagesStore<any>) => void;
+    delete: (key: ConversationKey) => void;
+    getMessages: (conversationKey: ConversationKey) => any[] | undefined;
+};
+export interface ChatStoreSnapshot<T> {
+    messages: T[];
+    isDefaultMessagesRequesting: boolean;
+}
+export declare class ChatMessagesStore<T extends {
+    id: number | string;
+}> {
+    private listeners;
+    private conversationKey;
+    private snapshotResult;
+    private throttleTimer;
+    private pendingEmit;
+    private readonly throttleInterval;
+    private isDestroyed;
+    private emitListeners;
+    private throttledEmitListeners;
+    constructor(defaultMessages: () => Promise<T[]>, conversationKey?: ConversationKey);
+    private initializeMessages;
+    private setSnapshotResult;
+    private setMessagesInternal;
+    setMessages: (messages: T[] | ((ori: T[]) => T[])) => boolean;
+    getMessages: () => T[];
+    getMessage: (id: string | number) => T | undefined;
+    addMessage: (message: T) => boolean;
+    setMessage: (id: string | number, message: Partial<T> | ((message: T) => Partial<T>)) => boolean;
+    removeMessage: (id: string | number) => boolean;
+    getSnapshot: () => ChatStoreSnapshot<T>;
+    subscribe: (callback: () => void) => () => void;
+    destroy: () => void;
+}

package/dist/x-conversations/index.d.ts

@@ -0,0 +1,20 @@
+import { AnyObject } from '../_util/types';
+export interface ConversationData extends AnyObject {
+    key: string;
+}
+interface XConversationConfig {
+    defaultConversations?: ConversationData[];
+    defaultActiveConversationKey?: string;
+}
+export default function useXConversations(config: XConversationConfig): {
+    conversations: import('vue').ShallowRef<ConversationData[], ConversationData[]>;
+    activeConversationKey: import('vue').Ref<string, string>;
+    setActiveConversationKey: (key: string) => boolean;
+    addConversation: (conversation: ConversationData, placement?: "prepend" | "append") => boolean;
+    removeConversation: (key: ConversationData["key"]) => boolean;
+    setConversation: (key: ConversationData["key"], conversation: ConversationData) => boolean;
+    getConversation: (key: ConversationData["key"]) => ConversationData | undefined;
+    setConversations: (list: ConversationData[]) => boolean;
+    getMessages: (key: ConversationData["key"]) => any[] | undefined;
+};
+export {};

package/dist/x-conversations/index.js

@@ -0,0 +1,2 @@
+import { t as useXConversations } from "../x-conversations-BrKWhj5r.js";
+export { useXConversations as default };

package/dist/x-conversations/store.d.ts

@@ -0,0 +1,26 @@
+import { ConversationData } from '.';
+export declare const conversationStoreHelper: {
+    _allConversationStores: Map<string, ConversationStore>;
+    set: (key: string, store: ConversationStore) => void;
+    delete: (key: string) => void;
+    getConversation: (conversationKey: string) => ConversationData | undefined;
+};
+export declare class ConversationStore {
+    private conversations;
+    private listeners;
+    private storeKey;
+    private activeConversationKey;
+    private emitListeners;
+    constructor(defaultConversations: ConversationData[], defaultActiveConversationKey: string);
+    setActiveConversationKey: (key: string) => boolean;
+    setConversations: (list: ConversationData[]) => boolean;
+    getConversation: (key: ConversationData["key"]) => ConversationData | undefined;
+    addConversation: (conversation: ConversationData, placement?: "prepend" | "append") => boolean;
+    setConversation: (key: ConversationData["key"], conversation: ConversationData) => boolean;
+    removeConversation: (key: ConversationData["key"]) => boolean;
+    getMessages: (key: ConversationData["key"]) => any[] | undefined;
+    getSnapshot: () => ConversationData[];
+    getActiveConversationKey: () => string;
+    subscribe: (callback: () => void) => () => void;
+    destroy: () => void;
+}

package/dist/x-conversations-BrKWhj5r.js

@@ -0,0 +1,122 @@
+import { n as chatMessagesStoreHelper } from "./store-C1diHqNH.js";
+import { onScopeDispose, ref, shallowRef } from "vue";
+//#region src/x-conversations/store.ts
+var conversationStoreHelper = {
+	_allConversationStores: /* @__PURE__ */ new Map(),
+	set: (key, store) => {
+		conversationStoreHelper._allConversationStores.set(key, store);
+	},
+	delete: (key) => {
+		conversationStoreHelper._allConversationStores.delete(key);
+	},
+	getConversation: (conversationKey) => {
+		for (const store of conversationStoreHelper._allConversationStores.values()) if (store) {
+			const conversation = store.getConversation(conversationKey);
+			if (conversation) return conversation;
+		}
+	}
+};
+var ConversationStore = class {
+	conversations = [];
+	listeners = [];
+	storeKey;
+	activeConversationKey;
+	emitListeners() {
+		this.listeners.forEach((listener) => {
+			listener();
+		});
+	}
+	constructor(defaultConversations, defaultActiveConversationKey) {
+		this.setConversations(defaultConversations);
+		this.storeKey = Math.random().toString();
+		conversationStoreHelper.set(this.storeKey, this);
+		this.activeConversationKey = defaultActiveConversationKey;
+	}
+	setActiveConversationKey = (key) => {
+		if (this.activeConversationKey === key) return true;
+		this.activeConversationKey = key;
+		this.emitListeners();
+		return true;
+	};
+	setConversations = (list) => {
+		this.conversations = [...list];
+		this.emitListeners();
+		return true;
+	};
+	getConversation = (key) => {
+		return this.conversations.find((item) => item.key === key);
+	};
+	addConversation = (conversation, placement) => {
+		if (!this.getConversation(conversation.key)) {
+			this.setConversations(placement === "prepend" ? [conversation, ...this.conversations] : [...this.conversations, conversation]);
+			return true;
+		}
+		return false;
+	};
+	setConversation = (key, conversation) => {
+		const exist = this.getConversation(key);
+		if (exist) {
+			Object.assign(exist, conversation);
+			this.setConversations([...this.conversations]);
+			return true;
+		}
+		return false;
+	};
+	removeConversation = (key) => {
+		const index = this.conversations.findIndex((item) => item.key === key);
+		if (index !== -1) {
+			this.conversations.splice(index, 1);
+			this.setConversations([...this.conversations]);
+			return true;
+		}
+		return false;
+	};
+	getMessages = (key) => {
+		return chatMessagesStoreHelper.getMessages(key);
+	};
+	getSnapshot = () => {
+		return this.conversations;
+	};
+	getActiveConversationKey = () => {
+		return this.activeConversationKey;
+	};
+	subscribe = (callback) => {
+		this.listeners.push(callback);
+		return () => {
+			this.listeners = this.listeners.filter((listener) => listener !== callback);
+		};
+	};
+	destroy = () => {
+		conversationStoreHelper.delete(this.storeKey);
+	};
+};
+//#endregion
+//#region src/x-conversations/index.ts
+function useXConversations(config) {
+	const store = new ConversationStore(config?.defaultConversations || [], config?.defaultActiveConversationKey || "");
+	const conversations = shallowRef(store.getSnapshot());
+	const activeConversationKey = ref(store.getActiveConversationKey());
+	const syncStore = () => {
+		conversations.value = store.getSnapshot();
+		activeConversationKey.value = store.getActiveConversationKey();
+	};
+	const unsubscribe = store.subscribe(syncStore);
+	syncStore();
+	onScopeDispose(() => {
+		unsubscribe();
+		store.destroy();
+	});
+	return {
+		conversations,
+		activeConversationKey,
+		setActiveConversationKey: store.setActiveConversationKey,
+		addConversation: store.addConversation,
+		removeConversation: store.removeConversation,
+		setConversation: store.setConversation,
+		getConversation: store.getConversation,
+		setConversations: store.setConversations,
+		getMessages: store.getMessages
+	};
+}
+//#endregion
+export { useXConversations as t };

package/dist/x-request/index.d.ts

@@ -0,0 +1,74 @@
+import { AnyObject } from '../_util/types';
+import { MessageInfo, SimpleType } from '../x-chat';
+import { SSEOutput, XStreamOptions } from '../x-stream';
+import { XFetchMiddlewares } from './x-fetch';
+export interface XRequestCallbacks<Output, ChatMessage extends SimpleType = any> {
+    onSuccess: (chunks: Output[], responseHeaders: Headers, chatMessage?: MessageInfo<ChatMessage>) => void;
+    onError: (error: Error, errorInfo?: any, responseHeaders?: Headers, fallbackMsg?: MessageInfo<ChatMessage>) => void;
+    onUpdate?: (chunk: Output, responseHeaders: Headers, chatMessage?: MessageInfo<ChatMessage>) => void;
+}
+export interface XRequestOptions<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any> extends RequestInit {
+    callbacks?: XRequestCallbacks<Output, ChatMessage>;
+    params?: Partial<Input>;
+    headers?: Record<string, string>;
+    timeout?: number;
+    streamTimeout?: number;
+    fetch?: (baseURL: Parameters<typeof fetch>[0], options: XRequestOptions<Input, Output>) => Promise<Response>;
+    middlewares?: XFetchMiddlewares<Input, Output>;
+    transformStream?: XStreamOptions<Output>["transformStream"] | ((baseURL: string, responseHeaders: Headers) => XStreamOptions<Output>["transformStream"]);
+    streamSeparator?: string;
+    partSeparator?: string;
+    kvSeparator?: string;
+    manual?: boolean;
+    retryInterval?: number;
+    retryTimes?: number;
+}
+export type XRequestGlobalOptions<Input, Output> = Pick<XRequestOptions<Input, Output>, "headers" | "timeout" | "streamTimeout" | "middlewares" | "fetch" | "transformStream" | "manual">;
+export type XRequestFunction<Input = AnyObject, Output = SSEOutput> = (baseURL: string, options?: XRequestOptions<Input, Output>) => XRequestClass<Input, Output>;
+export declare function setXRequestGlobalOptions<Input, Output>(options: XRequestGlobalOptions<Input, Output>): void;
+export declare abstract class AbstractXRequestClass<Input, Output, ChatMessage extends SimpleType = any> {
+    baseURL: string;
+    options: XRequestOptions<Input, Output, ChatMessage>;
+    constructor(baseURL: string, options?: XRequestOptions<Input, Output, ChatMessage>);
+    abstract get asyncHandler(): Promise<any>;
+    abstract get isTimeout(): boolean;
+    abstract get isStreamTimeout(): boolean;
+    abstract get isRequesting(): boolean;
+    abstract get manual(): boolean;
+    abstract run(params?: Input): void;
+    abstract abort(): void;
+}
+export declare class XRequestClass<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any> extends AbstractXRequestClass<Input, Output, ChatMessage> {
+    private _asyncHandler;
+    private timeoutHandler;
+    private _isTimeout;
+    private streamTimeoutHandler;
+    private _isStreamTimeout;
+    private abortController;
+    private _isRequesting;
+    private _manual;
+    private lastManualParams?;
+    private retryTimes;
+    private retryTimer;
+    private lastEventId;
+    get asyncHandler(): Promise<any>;
+    get isTimeout(): boolean;
+    private set isTimeout(value);
+    get isStreamTimeout(): boolean;
+    private set isStreamTimeout(value);
+    get isRequesting(): boolean;
+    get manual(): boolean;
+    constructor(baseURL: string, options?: XRequestOptions<Input, Output, ChatMessage>);
+    run(params?: Input): boolean;
+    abort(): void;
+    private init;
+    private startRequest;
+    private finishRequest;
+    private customResponseHandler;
+    private sseResponseHandler;
+    private processStream;
+    private jsonResponseHandler;
+    private resetRetry;
+}
+declare function XRequest<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any>(baseURL: string, options?: XRequestOptions<Input, Output, ChatMessage>): AbstractXRequestClass<Input, Output, ChatMessage>;
+export default XRequest;

package/dist/x-request/index.js

@@ -0,0 +1,2 @@
+import { i as setXRequestGlobalOptions, n as XRequest, r as XRequestClass, t as AbstractXRequestClass } from "../x-request-BSFGaKND.js";
+export { AbstractXRequestClass, XRequestClass, XRequest as default, setXRequestGlobalOptions };

package/dist/x-request/x-fetch.d.ts

@@ -0,0 +1,8 @@
+import { XRequestOptions } from '.';
+export interface XFetchMiddlewares<Input, Output> {
+    onRequest?: (baseURL: Parameters<typeof fetch>[0], options: XRequestOptions<Input, Output>) => Promise<[Parameters<typeof fetch>[0], XRequestOptions<Input, Output>]>;
+    onResponse?: (response: Response) => Promise<Response>;
+}
+export type XFetchType<Input, Output> = (baseURL: Parameters<typeof fetch>[0], options?: XRequestOptions<Input, Output>) => Promise<Response>;
+declare const XFetch: <Input, Output>(baseURL: Parameters<typeof fetch>[0], options: XRequestOptions<Input, Output>) => Promise<Response>;
+export default XFetch;