@antdv-next/x-sdk 0.0.1 → 0.0.2

package/dist/node_modules/vitest/dist/vendor/tinyrainbow.js

@@ -0,0 +1,84 @@
+//#region ../../node_modules/vitest/dist/vendor/tinyrainbow.mjs
+var d = {
+	reset: [0, 0],
+	bold: [
+		1,
+		22,
+		"\x1B[22m\x1B[1m"
+	],
+	dim: [
+		2,
+		22,
+		"\x1B[22m\x1B[2m"
+	],
+	italic: [3, 23],
+	underline: [4, 24],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29],
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	gray: [90, 39],
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49],
+	blackBright: [90, 39],
+	redBright: [91, 39],
+	greenBright: [92, 39],
+	yellowBright: [93, 39],
+	blueBright: [94, 39],
+	magentaBright: [95, 39],
+	cyanBright: [96, 39],
+	whiteBright: [97, 39],
+	bgBlackBright: [100, 49],
+	bgRedBright: [101, 49],
+	bgGreenBright: [102, 49],
+	bgYellowBright: [103, 49],
+	bgBlueBright: [104, 49],
+	bgMagentaBright: [105, 49],
+	bgCyanBright: [106, 49],
+	bgWhiteBright: [107, 49]
+};
+function g(e) {
+	return String(e);
+}
+g.open = "";
+g.close = "";
+function h() {
+	let e = typeof process != "undefined" ? process : void 0, n = (e == null ? void 0 : e.env) || {}, a = n.FORCE_TTY !== "false", i = (e == null ? void 0 : e.argv) || [];
+	return !("NO_COLOR" in n || i.includes("--no-color")) && ("FORCE_COLOR" in n || i.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && n.TERM !== "dumb" || "CI" in n) || typeof window != "undefined" && !!window.chrome;
+}
+function f() {
+	let e = h(), n = (r, t, u, o) => {
+		let l = "", s = 0;
+		do
+			l += r.substring(s, o) + u, s = o + t.length, o = r.indexOf(t, s);
+		while (~o);
+		return l + r.substring(s);
+	}, a = (r, t, u = r) => {
+		let o = (l) => {
+			let s = String(l), b = s.indexOf(t, r.length);
+			return ~b ? r + n(s, t, u, b) + t : r + s + t;
+		};
+		return o.open = r, o.close = t, o;
+	}, i = { isColorSupported: e }, c = (r) => `\x1B[${r}m`;
+	for (let r in d) {
+		let t = d[r];
+		i[r] = e ? a(c(t[0]), c(t[1]), t[2]) : g;
+	}
+	return i;
+}
+var C = f();
+//#endregion
+export { C };

package/dist/x-chat/__tests__/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/x-chat/__tests__/index.test.js

@@ -0,0 +1,257 @@
+import AbstractChatProvider from "../../chat-providers/AbstractChatProvider.js";
+import { AbstractXRequestClass } from "../../x-request/index.js";
+import { chatMessagesStoreHelper } from "../store.js";
+import useXChat from "../index.js";
+import { describe, it } from "../../node_modules/vitest/dist/@vitest/runner/chunk-artifact.js";
+import { globalExpect, vi } from "../../node_modules/vitest/dist/chunks/test.CBQUpOM3.js";
+import { computed, effectScope, nextTick, reactive, readonly, ref } from "vue";
+//#region src/x-chat/__tests__/index.test.ts
+var MockManualRequest = class extends AbstractXRequestClass {
+	_asyncHandler = Promise.resolve();
+	_state = reactive({
+		isTimeout: false,
+		isStreamTimeout: false,
+		isRequesting: false
+	});
+	constructor(shouldFail) {
+		super("https://mock.request", { manual: true });
+		this.shouldFail = shouldFail;
+	}
+	get asyncHandler() {
+		return this._asyncHandler;
+	}
+	get isTimeout() {
+		return this._state.isTimeout;
+	}
+	get isStreamTimeout() {
+		return this._state.isStreamTimeout;
+	}
+	get isRequesting() {
+		return this._state.isRequesting;
+	}
+	get manual() {
+		return true;
+	}
+	get state() {
+		return readonly(this._state);
+	}
+	run(params) {
+		const callbacks = this.options.callbacks;
+		this._state.isRequesting = true;
+		this._asyncHandler = new Promise((resolve) => {
+			setTimeout(() => {
+				const headers = new Headers({ "content-type": "application/json" });
+				if (this.shouldFail.value) callbacks?.onError?.(/* @__PURE__ */ new Error("MockError"), { error: { message: "mock failed" } }, headers);
+				else {
+					const chunk = `echo:${params?.input || ""}`;
+					callbacks?.onUpdate?.(chunk, headers);
+					callbacks?.onSuccess?.([chunk], headers);
+				}
+				this._state.isRequesting = false;
+				resolve();
+			}, 0);
+		});
+	}
+	abort() {
+		this._state.isRequesting = false;
+	}
+};
+var MockProvider = class extends AbstractChatProvider {
+	transformParams(requestParams) {
+		return { input: requestParams.input || "" };
+	}
+	transformLocalMessage(requestParams) {
+		return requestParams.input || "";
+	}
+	transformMessage(info) {
+		if (info.chunk) return info.chunk;
+		if (Array.isArray(info.chunks) && info.chunks.length > 0) return info.chunks[info.chunks.length - 1];
+		return info.originMessage || "";
+	}
+};
+var DeferredManualRequest = class extends AbstractXRequestClass {
+	_state = reactive({
+		isTimeout: false,
+		isStreamTimeout: false,
+		isRequesting: false
+	});
+	callbacks;
+	params;
+	constructor() {
+		super("https://mock.request", { manual: true });
+	}
+	get asyncHandler() {
+		return Promise.resolve();
+	}
+	get isTimeout() {
+		return this._state.isTimeout;
+	}
+	get isStreamTimeout() {
+		return this._state.isStreamTimeout;
+	}
+	get isRequesting() {
+		return this._state.isRequesting;
+	}
+	get manual() {
+		return true;
+	}
+	get state() {
+		return readonly(this._state);
+	}
+	run(params) {
+		this.params = params;
+		this.callbacks = this.options.callbacks;
+		this._state.isRequesting = true;
+	}
+	resolve() {
+		const headers = new Headers({ "content-type": "application/json" });
+		const chunk = `echo:${this.params?.input || ""}`;
+		this.callbacks?.onUpdate?.(chunk, headers);
+		this.callbacks?.onSuccess?.([chunk], headers);
+		this._state.isRequesting = false;
+	}
+	abort() {
+		this._state.isRequesting = false;
+	}
+};
+describe("useXChat", () => {
+	it("uses reactive requestPlaceholder and requestFallback refs", async () => {
+		vi.useFakeTimers();
+		const shouldFail = ref(false);
+		const request = new MockManualRequest(shouldFail);
+		const provider = new MockProvider({ request });
+		const requestPlaceholder = ref("Thinking #1");
+		const requestFallback = ref("Fallback #1");
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({
+			provider,
+			requestPlaceholder,
+			requestFallback
+		}));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		chat.onRequest({ input: "hello" });
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("loading");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Thinking #1");
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		requestPlaceholder.value = "Thinking #2";
+		chat.onRequest({ input: "again" });
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("loading");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Thinking #2");
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		shouldFail.value = true;
+		chat.onRequest({ input: "error" });
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("error");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Fallback #1");
+		requestFallback.value = "Fallback #2";
+		chat.onRequest({ input: "error-again" });
+		await vi.runAllTimersAsync();
+		await request.asyncHandler;
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("error");
+		globalExpect(chat.messages.value.at(-1)?.message).toBe("Fallback #2");
+		scope.stop();
+		vi.useRealTimers();
+	});
+	it("refreshes default messages when defaultMessages ref changes", async () => {
+		const defaultMessages = ref([{ message: "history-1" }]);
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({ defaultMessages }));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		await Promise.resolve();
+		await nextTick();
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["history-1"]);
+		defaultMessages.value = [{ message: "history-2" }];
+		await nextTick();
+		await Promise.resolve();
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["history-2"]);
+		scope.stop();
+	});
+	it("accepts computed provider refs", async () => {
+		vi.useFakeTimers();
+		const shouldFail = ref(false);
+		const provider = computed(() => new MockProvider({ request: new MockManualRequest(shouldFail) }));
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({ provider }));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		chat.onRequest({ input: "provider" });
+		await vi.runAllTimersAsync();
+		globalExpect(chat.messages.value.at(-1)?.status).toBe("success");
+		scope.stop();
+		vi.useRealTimers();
+	});
+	it("derives parsedMessages from parser output", async () => {
+		vi.useFakeTimers();
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({ parser: (message) => [message.toUpperCase(), `${message}!`] }));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		await Promise.resolve();
+		await nextTick();
+		chat.setMessages([{
+			id: "msg_1",
+			message: "hello",
+			status: "success"
+		}]);
+		await vi.advanceTimersByTimeAsync(60);
+		await nextTick();
+		globalExpect(chat.parsedMessages.value).toEqual([{
+			id: "msg_1_0",
+			message: "HELLO",
+			status: "success"
+		}, {
+			id: "msg_1_1",
+			message: "hello!",
+			status: "success"
+		}]);
+		scope.stop();
+		vi.useRealTimers();
+	});
+	it("keeps streaming updates isolated to the request conversation after switching", async () => {
+		const activeConversationKey = ref("a");
+		const requestA = new DeferredManualRequest();
+		const requestB = new DeferredManualRequest();
+		const providers = {
+			a: new MockProvider({ request: requestA }),
+			b: new MockProvider({ request: requestB })
+		};
+		const scope = effectScope();
+		const chat = scope.run(() => useXChat({
+			provider: computed(() => providers[activeConversationKey.value]),
+			conversationKey: activeConversationKey
+		}));
+		globalExpect(chat).toBeTruthy();
+		if (!chat) return;
+		await Promise.resolve();
+		await nextTick();
+		chat.onRequest({ input: "from-a" });
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["from-a"]);
+		activeConversationKey.value = "b";
+		await nextTick();
+		globalExpect(chat.messages.value).toEqual([]);
+		requestA.resolve();
+		await nextTick();
+		globalExpect(chat.messages.value).toEqual([]);
+		globalExpect(chatMessagesStoreHelper.getMessages("a")?.map((item) => ({
+			message: item.message,
+			status: item.status
+		}))).toEqual([{
+			message: "from-a",
+			status: "local"
+		}, {
+			message: "echo:from-a",
+			status: "success"
+		}]);
+		globalExpect(chatMessagesStoreHelper.getMessages("b")).toEqual([]);
+		activeConversationKey.value = "a";
+		await nextTick();
+		globalExpect(chat.messages.value.map((item) => item.message)).toEqual(["from-a", "echo:from-a"]);
+		scope.stop();
+	});
+});
+//#endregion

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

@@ -1,4 +1,4 @@
-import { Ref } from 'vue';
+import { MaybeRef } from 'vue';
 import { AnyObject } from '../_util/types';
 import { ConversationData } from '../x-conversations';
 import { SSEOutput } from '../x-stream';
@@ -26,18 +26,19 @@ type RequestFallbackFn<Input, MessageInfoType, Message> = (requestParams: Partia
 export type RequestParams<Message> = {
     [Key: PropertyKey]: Message;
 } & AnyObject;
-type MaybeRef<T> = T | Ref<T>;
+type ParserFn<ChatMessage, BubbleMessage> = (message: ChatMessage) => BubbleMessage | BubbleMessage[];
+type DefaultMessagesFn<ChatMessage extends SimpleType> = ((info: {
+    conversationKey?: ConversationData["key"];
+}) => Promise<DefaultMessageInfo<ChatMessage>[]>) | ((info?: {
+    conversationKey?: ConversationData["key"];
+}) => DefaultMessageInfo<ChatMessage>[]);
 export interface XChatConfig<ChatMessage extends SimpleType = string, BubbleMessage extends SimpleType = ChatMessage, Input = ChatMessage, Output = ChatMessage> {
-    provider?: AbstractChatProvider<ChatMessage, Input, Output>;
+    provider?: MaybeRef<AbstractChatProvider<ChatMessage, Input, Output>>;
     conversationKey?: MaybeRef<ConversationData["key"] | undefined>;
-    defaultMessages?: DefaultMessageInfo<ChatMessage>[] | ((info: {
-        conversationKey?: ConversationData["key"];
-    }) => Promise<DefaultMessageInfo<ChatMessage>[]>) | ((info?: {
-        conversationKey?: ConversationData["key"];
-    }) => DefaultMessageInfo<ChatMessage>[]);
-    parser?: (message: ChatMessage) => BubbleMessage | BubbleMessage[];
-    requestPlaceholder?: ChatMessage | RequestPlaceholderFn<Input, ChatMessage>;
-    requestFallback?: ChatMessage | RequestFallbackFn<Input, MessageInfo<ChatMessage>, ChatMessage>;
+    defaultMessages?: MaybeRef<DefaultMessageInfo<ChatMessage>[]> | DefaultMessagesFn<ChatMessage>;
+    parser?: ParserFn<ChatMessage, BubbleMessage> | undefined;
+    requestPlaceholder?: MaybeRef<ChatMessage> | RequestPlaceholderFn<Input, ChatMessage>;
+    requestFallback?: MaybeRef<ChatMessage> | RequestFallbackFn<Input, MessageInfo<ChatMessage>, ChatMessage>;
 }
 export interface MessageInfo<Message extends SimpleType> {
     id: number | string;
@@ -58,18 +59,8 @@ export default function useXChat<ChatMessage extends SimpleType = string, Parsed
     readonly onRequest: (requestParams: Partial<Input>, opts?: {
         extraInfo: AnyObject;
     }) => void;
-    readonly isDefaultMessagesRequesting: Ref<boolean, boolean>;
-    readonly messages: Ref<{
-        id: number | string;
-        message: import('vue').UnwrapRef<ChatMessage>;
-        status: MessageStatus;
-        extraInfo?: AnyObject | undefined;
-    }[], MessageInfo<ChatMessage>[] | {
-        id: number | string;
-        message: import('vue').UnwrapRef<ChatMessage>;
-        status: MessageStatus;
-        extraInfo?: AnyObject | undefined;
-    }[]>;
+    readonly isDefaultMessagesRequesting: Readonly<import('vue').Ref<boolean, boolean>>;
+    readonly messages: import('vue').ShallowRef<MessageInfo<ChatMessage>[], MessageInfo<ChatMessage>[]>;
     readonly parsedMessages: import('vue').ComputedRef<MessageInfo<ParsedMessage>[]>;
     readonly setMessages: (updater: MessageInfo<ChatMessage>[] | ((ori: MessageInfo<ChatMessage>[]) => MessageInfo<ChatMessage>[])) => boolean;
     readonly removeMessage: (id: string | number) => boolean;

package/dist/x-chat/index.js

@@ -1,28 +1,49 @@
-import { n as chatMessagesStoreHelper, t as ChatMessagesStore } from "../store-C1diHqNH.js";
-import { computed, isRef, onScopeDispose, reactive, ref, shallowRef, watch } from "vue";
+import resolveMaybeRef from "../_util/resolveMaybeRef.js";
+import "../chat-providers/index.js";
+import "../x-request/index.js";
+import { ChatMessagesStore, chatMessagesStoreHelper } from "./store.js";
+import { computed, isRef, onScopeDispose, reactive, readonly, 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 providerRef = isRef(config.provider) ? config.provider : shallowRef(config.provider);
+	let provider = providerRef.value;
 	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);
+	const messages = shallowRef([]);
+	const isDefaultMessagesRequestingRef = shallowRef(false);
+	const parsedMessages = computed(() => {
+		const parser = config.parser;
+		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;
+	});
 	let unsubscribeStore = null;
 	const resolveDefaultMessages = async (currentConversationKey) => {
+		const sourceDefaultMessages = config.defaultMessages;
+		const defaultMessages = typeof sourceDefaultMessages === "function" ? sourceDefaultMessages : resolveMaybeRef(sourceDefaultMessages);
 		return ((typeof defaultMessages === "function" ? await defaultMessages({ conversationKey: currentConversationKey }) : defaultMessages) || []).map((info, index) => ({
 			id: `default_${index}`,
 			status: "local",
@@ -37,12 +58,12 @@ function useXChat(config) {
 	const syncStoreSnapshot = () => {
 		if (!activeStore.value) {
 			messages.value = [];
-			isDefaultMessagesRequesting.value = false;
+			isDefaultMessagesRequestingRef.value = false;
 			return;
 		}
 		const snapshot = activeStore.value.getSnapshot();
 		messages.value = snapshot.messages;
-		isDefaultMessagesRequesting.value = snapshot.isDefaultMessagesRequesting;
+		isDefaultMessagesRequestingRef.value = snapshot.isDefaultMessagesRequesting;
 	};
 	const bindStore = (currentConversationKey) => {
 		if (unsubscribeStore) {
@@ -85,38 +106,32 @@ function useXChat(config) {
 		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 setupProvider = (nextProvider) => {
+		provider = nextProvider;
+		if (nextProvider) {
+			nextProvider.injectGetMessages(() => {
+				return getFilteredMessages(getMessages());
+			});
+			requestHandlerRef.value = nextProvider.request;
+		} else requestHandlerRef.value = void 0;
+	};
+	setupProvider(provider);
+	watch(providerRef, setupProvider);
 	const innerOnRequest = (requestParams, opts) => {
 		if (!provider) return;
+		const activeProvider = provider;
+		const requestKey = conversationKey.value;
+		const requestStore = createStore(requestKey);
 		const { updatingId, reload } = opts || {};
 		let loadingMsgId = null;
-		const localMessage = provider.transformLocalMessage(requestParams);
+		const sourceRequestPlaceholder = config.requestPlaceholder;
+		const requestPlaceholder = typeof sourceRequestPlaceholder === "function" ? sourceRequestPlaceholder : resolveMaybeRef(sourceRequestPlaceholder);
+		const localMessage = activeProvider.transformLocalMessage(requestParams);
 		const localMessages = (Array.isArray(localMessage) ? localMessage : [localMessage]).map((message) => createMessage(message, "local", opts?.extraInfo));
 		if (reload) {
 			loadingMsgId = updatingId;
-			setMessages((ori) => {
+			requestStore.setMessages((ori) => {
 				const nextMessages = [...ori];
 				if (requestPlaceholder) {
 					let placeholderMsg;
@@ -132,7 +147,7 @@ function useXChat(config) {
 				}
 				return nextMessages;
 			});
-		} else setMessages((ori) => {
+		} else requestStore.setMessages((ori) => {
 			let nextMessages = [...ori, ...localMessages];
 			if (requestPlaceholder) {
 				let placeholderMsg;
@@ -146,38 +161,38 @@ function useXChat(config) {
 		});
 		let updatingMsgId = null;
 		const updateMessage = (status, chunk, chunks, responseHeaders) => {
-			let msg = getMessages().find((info) => info.id === updatingMsgId);
+			let msg = requestStore.getMessages().find((info) => info.id === updatingMsgId);
 			if (!msg) if (reload && updatingId) {
-				msg = getMessages().find((info) => info.id === updatingId);
+				msg = requestStore.getMessages().find((info) => info.id === updatingId);
 				if (msg) {
 					msg.status = status;
-					msg.message = provider.transformMessage({
+					msg.message = activeProvider.transformMessage({
 						chunk,
 						status,
 						chunks,
 						responseHeaders
 					});
-					setMessages((ori) => {
+					requestStore.setMessages((ori) => {
 						return [...ori];
 					});
 					updatingMsgId = msg.id;
 				}
 			} else {
-				msg = createMessage(provider.transformMessage({
+				msg = createMessage(activeProvider.transformMessage({
 					chunk,
 					status,
 					chunks,
 					responseHeaders
 				}), status);
-				setMessages((ori) => {
+				requestStore.setMessages((ori) => {
 					return [...ori.filter((info) => info.id !== loadingMsgId), msg];
 				});
 				updatingMsgId = msg.id;
 			}
-			else setMessages((ori) => {
+			else requestStore.setMessages((ori) => {
 				return ori.map((info) => {
 					if (info.id === updatingMsgId) {
-						const transformData = provider.transformMessage({
+						const transformData = activeProvider.transformMessage({
 							originMessage: info.message,
 							chunk,
 							chunks,
@@ -193,34 +208,36 @@ function useXChat(config) {
 					return info;
 				});
 			});
-			msg = getMessages().find((info) => info.id === updatingMsgId) || msg;
+			msg = requestStore.getMessages().find((info) => info.id === updatingMsgId) || msg;
 			return msg;
 		};
-		provider.injectRequest({
+		activeProvider.injectRequest({
 			onUpdate: (chunk, headers) => {
 				return updateMessage("updating", chunk, [], headers);
 			},
 			onSuccess: (chunks, headers) => {
-				if (conversationKey.value) IsRequestingMap.delete(conversationKey.value);
+				if (requestKey) IsRequestingMap.delete(requestKey);
 				return updateMessage("success", void 0, chunks, headers);
 			},
 			onError: async (error, errorInfo) => {
-				if (conversationKey.value) IsRequestingMap.delete(conversationKey.value);
+				if (requestKey) IsRequestingMap.delete(requestKey);
 				let fallbackMsg;
+				const sourceRequestFallback = config.requestFallback;
+				const requestFallback = typeof sourceRequestFallback === "function" ? sourceRequestFallback : resolveMaybeRef(sourceRequestFallback);
 				if (requestFallback) {
 					if (typeof requestFallback === "function") {
-						const currentMessages = getRequestMessages();
+						const currentMessages = getFilteredMessages(requestStore.getMessages());
 						fallbackMsg = await requestFallback(requestParams, {
 							error,
 							errorInfo,
-							messageInfo: getMessages().find((info) => info.id === loadingMsgId || info.id === updatingMsgId),
+							messageInfo: requestStore.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")]);
+					requestStore.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) => {
+					fallbackMsg = requestStore.getMessages().find((info) => info.id !== loadingMsgId && info.id !== updatingMsgId)?.message;
+					requestStore.setMessages((ori) => {
 						return ori.map((info) => {
 							if (info.id === loadingMsgId || info.id === updatingMsgId) return {
 								...info,
@@ -233,15 +250,15 @@ function useXChat(config) {
 				return fallbackMsg;
 			}
 		});
-		if (conversationKey.value) IsRequestingMap.set(conversationKey.value, true);
-		provider.request.run(provider.transformParams(requestParams, provider.request.options));
+		if (requestKey) IsRequestingMap.set(requestKey, true);
+		activeProvider.request.run(activeProvider.transformParams(requestParams, activeProvider.request.options));
 	};
 	const onRequest = (requestParams, opts) => {
-		if (!provider) throw new Error("provider is required");
+		if (!providerRef.value) throw new Error("provider is required");
 		innerOnRequest(requestParams, opts);
 	};
 	const onReload = (id, requestParams, opts) => {
-		if (!provider) throw new Error("provider is required");
+		if (!providerRef.value) 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,
@@ -251,19 +268,19 @@ function useXChat(config) {
 	};
 	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);
+		if (requestParamsList && requestParamsList.length > 0) setTimeout(() => {
+			requestParamsList.forEach(({ requestParams, opts }) => {
+				onRequest(requestParams, opts);
 			});
-		}
+			messageQueueMap.delete(conversationKey.value);
+		});
 	};
-	watch(isDefaultMessagesRequesting, (requesting) => {
+	watch(isDefaultMessagesRequestingRef, (requesting) => {
 		if (!requesting) processMessageQueue();
 	});
+	if (config.defaultMessages && isRef(config.defaultMessages)) watch(config.defaultMessages, () => {
+		activeStore.value?.refreshDefaultMessages();
+	}, { deep: true });
 	const queueRequest = (currentConversationKey, requestParams, opts) => {
 		if (!messageQueueMap.has(currentConversationKey)) messageQueueMap.set(currentConversationKey, []);
 		messageQueueMap.get(currentConversationKey).push({
@@ -273,7 +290,7 @@ function useXChat(config) {
 	};
 	return {
 		onRequest,
-		isDefaultMessagesRequesting,
+		isDefaultMessagesRequesting: readonly(isDefaultMessagesRequestingRef),
 		messages,
 		parsedMessages,
 		setMessages,