@antdv-next/x-sdk 0.0.1 → 0.0.3

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,39 @@ 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({
+				const transformData = activeProvider.transformMessage({
 					chunk,
 					status,
 					chunks,
 					responseHeaders
-				}), status);
-				setMessages((ori) => {
+				});
+				msg = createMessage(transformData, status);
+				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 +209,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 +251,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 +269,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 +291,7 @@ function useXChat(config) {
 	};
 	return {
 		onRequest,
-		isDefaultMessagesRequesting,
+		isDefaultMessagesRequesting: readonly(isDefaultMessagesRequestingRef),
 		messages,
 		parsedMessages,
 		setMessages,

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

@@ -20,10 +20,12 @@ export declare class ChatMessagesStore<T extends {
     private pendingEmit;
     private readonly throttleInterval;
     private isDestroyed;
+    private defaultMessagesLoader;
     private emitListeners;
     private throttledEmitListeners;
     constructor(defaultMessages: () => Promise<T[]>, conversationKey?: ConversationKey);
     private initializeMessages;
+    refreshDefaultMessages: () => boolean;
     private setSnapshotResult;
     private setMessagesInternal;
     setMessages: (messages: T[] | ((ori: T[]) => T[])) => boolean;

package/dist/{store-C1diHqNH.js → x-chat/store.js}

@@ -25,6 +25,7 @@ var ChatMessagesStore = class {
 	pendingEmit = false;
 	throttleInterval = 50;
 	isDestroyed = false;
+	defaultMessagesLoader;
 	emitListeners() {
 		this.listeners.forEach((listener) => {
 			listener();
@@ -44,27 +45,32 @@ var ChatMessagesStore = class {
 		} else this.pendingEmit = true;
 	}
 	constructor(defaultMessages, conversationKey) {
-		this.initializeMessages(defaultMessages, (value) => {
-			this.setSnapshotResult("isDefaultMessagesRequesting", value);
-			this.emitListeners();
-		});
+		this.defaultMessagesLoader = defaultMessages;
+		this.initializeMessages();
 		if (conversationKey) {
 			this.conversationKey = conversationKey;
 			chatMessagesStoreHelper.set(this.conversationKey, this);
 		}
 	}
-	async initializeMessages(defaultMessages, setDefaultMessagesRequesting) {
+	async initializeMessages() {
 		try {
-			setDefaultMessagesRequesting(true);
-			const messages = await defaultMessages();
+			this.setSnapshotResult("isDefaultMessagesRequesting", true);
+			this.emitListeners();
+			const messages = await this.defaultMessagesLoader();
 			if (!this.isDestroyed) this.setMessagesInternal(messages, false);
 		} catch (error) {
 			console.warn("Failed to initialize messages:", error);
 			if (!this.isDestroyed) this.setMessagesInternal([], false);
 		} finally {
-			setDefaultMessagesRequesting(false);
+			this.setSnapshotResult("isDefaultMessagesRequesting", false);
+			this.emitListeners();
 		}
 	}
+	refreshDefaultMessages = () => {
+		if (this.isDestroyed) return false;
+		this.initializeMessages();
+		return true;
+	};
 	setSnapshotResult = (key, value) => {
 		this.snapshotResult = {
 			...this.snapshotResult,
@@ -142,4 +148,4 @@ var ChatMessagesStore = class {
 	};
 };
 //#endregion
-export { chatMessagesStoreHelper as n, ChatMessagesStore as t };
+export { ChatMessagesStore, chatMessagesStoreHelper };

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

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

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

@@ -0,0 +1,36 @@
+import useXConversations from "../index.js";
+import { h as describe, m as it } from "../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/runner/chunk-artifact.js";
+import { g as globalExpect } from "../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/chunks/test.CBQUpOM3.js";
+import { effectScope, nextTick, ref } from "vue";
+//#region src/x-conversations/__tests__/index.test.ts
+describe("useXConversations", () => {
+	it("syncs default conversations and active key from refs", async () => {
+		const defaultConversations = ref([{
+			key: "session_1",
+			label: "Session 1"
+		}, {
+			key: "session_2",
+			label: "Session 2"
+		}]);
+		const defaultActiveConversationKey = ref("session_1");
+		const scope = effectScope();
+		const conversationsHandler = scope.run(() => useXConversations({
+			defaultConversations,
+			defaultActiveConversationKey
+		}));
+		globalExpect(conversationsHandler).toBeTruthy();
+		if (!conversationsHandler) return;
+		globalExpect(conversationsHandler.conversations.value.map((item) => item.key)).toEqual(["session_1", "session_2"]);
+		globalExpect(conversationsHandler.activeConversationKey.value).toBe("session_1");
+		defaultConversations.value = [{
+			key: "session_3",
+			label: "Session 3"
+		}];
+		defaultActiveConversationKey.value = "session_3";
+		await nextTick();
+		globalExpect(conversationsHandler.conversations.value.map((item) => item.key)).toEqual(["session_3"]);
+		globalExpect(conversationsHandler.activeConversationKey.value).toBe("session_3");
+		scope.stop();
+	});
+});
+//#endregion

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

@@ -1,10 +1,11 @@
+import { MaybeRef } from 'vue';
 import { AnyObject } from '../_util/types';
 export interface ConversationData extends AnyObject {
     key: string;
 }
-interface XConversationConfig {
-    defaultConversations?: ConversationData[];
-    defaultActiveConversationKey?: string;
+export interface XConversationConfig {
+    defaultConversations?: MaybeRef<ConversationData[]>;
+    defaultActiveConversationKey?: MaybeRef<string>;
 }
 export default function useXConversations(config: XConversationConfig): {
     conversations: import('vue').ShallowRef<ConversationData[], ConversationData[]>;
@@ -17,4 +18,3 @@ export default function useXConversations(config: XConversationConfig): {
     setConversations: (list: ConversationData[]) => boolean;
     getMessages: (key: ConversationData["key"]) => any[] | undefined;
 };
-export {};

package/dist/x-conversations/index.js

@@ -1,2 +1,38 @@
-import { t as useXConversations } from "../x-conversations-BrKWhj5r.js";
+import resolveMaybeRef from "../_util/resolveMaybeRef.js";
+import { ConversationStore } from "./store.js";
+import { isRef, onScopeDispose, ref, shallowRef, watch } from "vue";
+//#region src/x-conversations/index.ts
+function useXConversations(config) {
+	const store = new ConversationStore(resolveMaybeRef(config?.defaultConversations) || [], resolveMaybeRef(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();
+	if (config?.defaultConversations && isRef(config.defaultConversations)) watch(config.defaultConversations, (list) => {
+		store.setConversations(list || []);
+	}, { deep: true });
+	if (config?.defaultActiveConversationKey && isRef(config.defaultActiveConversationKey)) watch(config.defaultActiveConversationKey, (key) => {
+		if (typeof key === "string") store.setActiveConversationKey(key);
+	});
+	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 default };

package/dist/{x-conversations-BrKWhj5r.js → x-conversations/store.js}

@@ -1,5 +1,4 @@
-import { n as chatMessagesStoreHelper } from "./store-C1diHqNH.js";
-import { onScopeDispose, ref, shallowRef } from "vue";
+import { chatMessagesStoreHelper } from "../x-chat/store.js";
 //#region src/x-conversations/store.ts
 var conversationStoreHelper = {
 	_allConversationStores: /* @__PURE__ */ new Map(),
@@ -91,32 +90,4 @@ var ConversationStore = class {
 	};
 };
 //#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 };
+export { ConversationStore, conversationStoreHelper };

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

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

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

@@ -0,0 +1,90 @@
+import XRequest from "../index.js";
+import { h as describe, m as it } from "../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/runner/chunk-artifact.js";
+import { g as globalExpect, v as vi } from "../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/chunks/test.CBQUpOM3.js";
+import { ref } from "vue";
+//#region src/x-request/__tests__/index.test.ts
+describe("XRequest", () => {
+	it("uses reactive baseURL / params / headers refs on each run", async () => {
+		const baseURL = ref("https://example.com/api/v1");
+		const params = ref({ a: 1 });
+		const headers = ref({ Authorization: "Bearer token-1" });
+		const fetchMock = vi.fn(async (_url, _options) => {
+			return new Response(JSON.stringify({ success: true }), {
+				status: 200,
+				headers: { "content-type": "application/json" }
+			});
+		});
+		const request = XRequest(baseURL, {
+			manual: true,
+			params,
+			headers,
+			fetch: fetchMock
+		});
+		request.run({ b: 2 });
+		await request.asyncHandler;
+		globalExpect(fetchMock).toHaveBeenCalledTimes(1);
+		const firstCall = fetchMock.mock.calls[0];
+		const firstUrl = firstCall[0];
+		const firstOptions = firstCall[1];
+		globalExpect(firstUrl).toBe("https://example.com/api/v1");
+		globalExpect(JSON.parse(firstOptions.body)).toEqual({
+			a: 1,
+			b: 2
+		});
+		globalExpect(firstOptions.headers.Authorization).toBe("Bearer token-1");
+		baseURL.value = "https://example.com/api/v2";
+		params.value = { a: 3 };
+		headers.value = { Authorization: "Bearer token-2" };
+		request.run({ b: 4 });
+		await request.asyncHandler;
+		globalExpect(fetchMock).toHaveBeenCalledTimes(2);
+		const secondCall = fetchMock.mock.calls[1];
+		const secondUrl = secondCall[0];
+		const secondOptions = secondCall[1];
+		globalExpect(secondUrl).toBe("https://example.com/api/v2");
+		globalExpect(JSON.parse(secondOptions.body)).toEqual({
+			a: 3,
+			b: 4
+		});
+		globalExpect(secondOptions.headers.Authorization).toBe("Bearer token-2");
+	});
+	it("tracks reactive manual option", () => {
+		const manual = ref(true);
+		const request = XRequest("https://example.com/manual", {
+			manual,
+			fetch: vi.fn()
+		});
+		globalExpect(request.manual).toBe(true);
+		manual.value = false;
+		globalExpect(request.manual).toBe(false);
+		manual.value = true;
+		globalExpect(request.manual).toBe(true);
+	});
+	it("supports plain middlewares object", async () => {
+		const onRequest = vi.fn(async (baseURL, options) => {
+			return [`${baseURL.toString()}?mw=1`, options];
+		});
+		const onResponse = vi.fn(async (response) => response);
+		const fetchMock = vi.fn(async (_url) => {
+			return new Response(JSON.stringify({ success: true }), {
+				status: 200,
+				headers: { "content-type": "application/json" }
+			});
+		});
+		const request = XRequest("https://example.com/middlewares", {
+			manual: true,
+			fetch: fetchMock,
+			middlewares: {
+				onRequest,
+				onResponse
+			}
+		});
+		request.run();
+		await request.asyncHandler;
+		globalExpect(onRequest).toHaveBeenCalledTimes(1);
+		globalExpect(onResponse).toHaveBeenCalledTimes(1);
+		globalExpect(fetchMock).toHaveBeenCalledTimes(1);
+		globalExpect(fetchMock.mock.calls[0]?.[0]).toBe("https://example.com/middlewares?mw=1");
+	});
+});
+//#endregion