@antdv-next/x-sdk 0.0.1 → 0.0.3

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

@@ -1,3 +1,4 @@
+import { MaybeRef } from 'vue';
 import { AnyObject } from '../_util/types';
 import { MessageInfo, SimpleType } from '../x-chat';
 import { SSEOutput, XStreamOptions } from '../x-stream';
@@ -23,30 +24,49 @@ export interface XRequestOptions<Input = AnyObject, Output = SSEOutput, ChatMess
     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 type XRequestConfigOptions<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any> = Omit<XRequestOptions<Input, Output, ChatMessage>, "callbacks" | "params" | "headers" | "timeout" | "streamTimeout" | "fetch" | "middlewares" | "transformStream" | "streamSeparator" | "partSeparator" | "kvSeparator" | "manual" | "retryInterval" | "retryTimes"> & {
+    callbacks?: XRequestCallbacks<Output, ChatMessage>;
+    params?: MaybeRef<Partial<Input>>;
+    headers?: MaybeRef<Record<string, string>>;
+    timeout?: MaybeRef<number>;
+    streamTimeout?: MaybeRef<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?: MaybeRef<string>;
+    partSeparator?: MaybeRef<string>;
+    kvSeparator?: MaybeRef<string>;
+    manual?: MaybeRef<boolean>;
+    retryInterval?: MaybeRef<number>;
+    retryTimes?: MaybeRef<number>;
+};
+export type XRequestGlobalOptions<Input, Output> = Pick<XRequestConfigOptions<Input, Output>, "headers" | "timeout" | "streamTimeout" | "middlewares" | "fetch" | "transformStream" | "manual">;
+export type XRequestFunction<Input = AnyObject, Output = SSEOutput> = (baseURL: MaybeRef<string>, options?: XRequestConfigOptions<Input, Output>) => XRequestClass<Input, Output>;
+export interface XRequestReactiveState {
+    isTimeout: boolean;
+    isStreamTimeout: boolean;
+    isRequesting: boolean;
+}
 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>);
+    baseURL: MaybeRef<string>;
+    options: XRequestConfigOptions<Input, Output, ChatMessage>;
+    constructor(baseURL: MaybeRef<string>, options?: XRequestConfigOptions<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 get state(): Readonly<XRequestReactiveState>;
     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 _state;
     private lastManualParams?;
     private retryTimes;
     private retryTimer;
@@ -58,7 +78,12 @@ export declare class XRequestClass<Input = AnyObject, Output = SSEOutput, ChatMe
     private set isStreamTimeout(value);
     get isRequesting(): boolean;
     get manual(): boolean;
-    constructor(baseURL: string, options?: XRequestOptions<Input, Output, ChatMessage>);
+    get state(): {
+        readonly isTimeout: boolean;
+        readonly isStreamTimeout: boolean;
+        readonly isRequesting: boolean;
+    };
+    constructor(baseURL: MaybeRef<string>, options?: XRequestConfigOptions<Input, Output, ChatMessage>);
     run(params?: Input): boolean;
     abort(): void;
     private init;
@@ -70,5 +95,5 @@ export declare class XRequestClass<Input = AnyObject, Output = SSEOutput, ChatMe
     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>;
+declare function XRequest<Input = AnyObject, Output = SSEOutput, ChatMessage extends SimpleType = any>(baseURL: MaybeRef<string>, options?: XRequestConfigOptions<Input, Output, ChatMessage>): AbstractXRequestClass<Input, Output, ChatMessage>;
 export default XRequest;

package/dist/x-request/index.js

@@ -1,2 +1,247 @@
-import { i as setXRequestGlobalOptions, n as XRequest, r as XRequestClass, t as AbstractXRequestClass } from "../x-request-BSFGaKND.js";
+import resolveMaybeRef from "../_util/resolveMaybeRef.js";
+import XStream from "../x-stream/index.js";
+import XFetch from "./x-fetch.js";
+import { reactive, readonly } from "vue";
+//#region src/x-request/index.ts
+var globalOptions = {
+	manual: false,
+	headers: { "Content-Type": "application/json" }
+};
+function setXRequestGlobalOptions(options) {
+	Object.assign(globalOptions, options);
+}
+var LastEventId = "Last-Event-ID";
+var AbstractXRequestClass = class {
+	baseURL;
+	options;
+	constructor(baseURL, options) {
+		const resolvedBaseURL = resolveMaybeRef(baseURL);
+		if (!resolvedBaseURL || typeof resolvedBaseURL !== "string") throw new Error("The baseURL is not valid!");
+		this.baseURL = baseURL;
+		this.options = options || {};
+	}
+};
+var XRequestClass = class extends AbstractXRequestClass {
+	_asyncHandler;
+	timeoutHandler;
+	streamTimeoutHandler;
+	abortController;
+	_state = reactive({
+		isTimeout: false,
+		isStreamTimeout: false,
+		isRequesting: false
+	});
+	lastManualParams;
+	retryTimes = 0;
+	retryTimer;
+	lastEventId = void 0;
+	get asyncHandler() {
+		return this._asyncHandler;
+	}
+	get isTimeout() {
+		return this._state.isTimeout;
+	}
+	set isTimeout(value) {
+		this._state.isTimeout = value;
+	}
+	get isStreamTimeout() {
+		return this._state.isStreamTimeout;
+	}
+	set isStreamTimeout(value) {
+		this._state.isStreamTimeout = value;
+	}
+	get isRequesting() {
+		return this._state.isRequesting;
+	}
+	get manual() {
+		const localManual = resolveMaybeRef(this.options.manual);
+		if (typeof localManual === "boolean") return localManual;
+		const globalManual = resolveMaybeRef(globalOptions.manual);
+		if (typeof globalManual === "boolean") return globalManual;
+		return false;
+	}
+	get state() {
+		return readonly(this._state);
+	}
+	constructor(baseURL, options) {
+		super(baseURL, options);
+		if (!this.manual) this.init();
+	}
+	run(params) {
+		if (this.manual) {
+			this.resetRetry();
+			this.lastManualParams = params;
+			this.init(params);
+			return true;
+		}
+		console.warn("The request is not manual, so it cannot be run!");
+		return false;
+	}
+	abort() {
+		clearTimeout(this.timeoutHandler);
+		clearTimeout(this.streamTimeoutHandler);
+		this.abortController.abort();
+	}
+	init(extraParams, extraHeaders) {
+		const currentBaseURL = resolveMaybeRef(this.baseURL);
+		if (!currentBaseURL || typeof currentBaseURL !== "string") throw new Error("The baseURL is not valid!");
+		this.abortController = new AbortController();
+		this.isTimeout = false;
+		this.isStreamTimeout = false;
+		const { callbacks: sourceCallbacks, params: sourceParams, headers: sourceHeaders, transformStream: sourceTransformStream, fetch: sourceFetch, timeout: sourceTimeout, streamTimeout: sourceStreamTimeout, middlewares: sourceMiddlewares, streamSeparator: sourceStreamSeparator, partSeparator: sourcePartSeparator, kvSeparator: sourceKvSeparator, manual: _sourceManual, retryInterval: sourceRetryInterval, retryTimes: sourceRetryTimes, ...otherOptions } = this.options;
+		const callbacks = sourceCallbacks;
+		const params = resolveMaybeRef(sourceParams);
+		const headers = resolveMaybeRef(sourceHeaders) || {};
+		const transformStream = sourceTransformStream;
+		const fetch = sourceFetch;
+		const timeout = resolveMaybeRef(sourceTimeout);
+		const streamTimeout = resolveMaybeRef(sourceStreamTimeout);
+		const middlewares = sourceMiddlewares;
+		const streamSeparator = resolveMaybeRef(sourceStreamSeparator);
+		const partSeparator = resolveMaybeRef(sourcePartSeparator);
+		const kvSeparator = resolveMaybeRef(sourceKvSeparator);
+		const retryInterval = resolveMaybeRef(sourceRetryInterval);
+		const retryTimes = resolveMaybeRef(sourceRetryTimes);
+		const globalHeaders = resolveMaybeRef(globalOptions.headers) || {};
+		const margeHeaders = Object.assign({}, globalHeaders, headers, extraHeaders || {});
+		const requestInit = {
+			...otherOptions,
+			method: "POST",
+			body: JSON.stringify({
+				...params,
+				...extraParams
+			}),
+			params: {
+				...params,
+				...extraParams
+			},
+			headers: margeHeaders,
+			signal: this.abortController.signal,
+			middlewares
+		};
+		if (timeout && timeout > 0) this.timeoutHandler = setTimeout(() => {
+			this.isTimeout = true;
+			this.finishRequest();
+			callbacks?.onError?.(/* @__PURE__ */ new Error("TimeoutError"));
+		}, timeout);
+		this.startRequest();
+		this._asyncHandler = XFetch(currentBaseURL, {
+			fetch,
+			...requestInit
+		}).then(async (response) => {
+			clearTimeout(this.timeoutHandler);
+			if (this.isTimeout) return;
+			if (transformStream) {
+				let transformer = transformStream;
+				if (typeof transformStream === "function") transformer = transformStream(currentBaseURL, response.headers);
+				await this.customResponseHandler(response, callbacks, transformer, streamTimeout, streamSeparator, partSeparator, kvSeparator);
+				return;
+			}
+			const contentType = response.headers.get("content-type") || "";
+			switch (contentType.split(";")[0].trim()) {
+				case "text/event-stream":
+					await this.sseResponseHandler(response, callbacks, streamTimeout, streamSeparator, partSeparator, kvSeparator);
+					break;
+				case "application/json":
+					await this.jsonResponseHandler(response, callbacks);
+					break;
+				default: throw new Error(`The response content-type: ${contentType} is not support!`);
+			}
+		}).catch((error) => {
+			clearTimeout(this.timeoutHandler);
+			this.finishRequest();
+			const err = error instanceof Error || error instanceof DOMException ? error : /* @__PURE__ */ new Error("Unknown error!");
+			const returnOfOnError = callbacks?.onError?.(err);
+			if (err.name !== "AbortError") {
+				const actualRetryInterval = typeof returnOfOnError === "number" ? returnOfOnError : retryInterval;
+				if (actualRetryInterval && actualRetryInterval > 0) {
+					if (typeof retryTimes === "number" && this.retryTimes >= retryTimes) return;
+					clearTimeout(this.retryTimer);
+					this.retryTimer = setTimeout(() => {
+						const extraHeaders = {};
+						if (typeof this.lastEventId !== "undefined") extraHeaders[LastEventId] = this.lastEventId;
+						this.init(this.lastManualParams, extraHeaders);
+					}, actualRetryInterval);
+					this.retryTimes = this.retryTimes + 1;
+				}
+			}
+		});
+	}
+	startRequest() {
+		this._state.isRequesting = true;
+	}
+	finishRequest() {
+		this._state.isRequesting = false;
+	}
+	customResponseHandler = async (response, callbacks, transformStream, streamTimeout, streamSeparator, partSeparator, kvSeparator) => {
+		const stream = XStream({
+			readableStream: response.body,
+			transformStream,
+			streamSeparator,
+			partSeparator,
+			kvSeparator
+		});
+		await this.processStream(stream, response, callbacks, streamTimeout);
+	};
+	sseResponseHandler = async (response, callbacks, streamTimeout, streamSeparator, partSeparator, kvSeparator) => {
+		const stream = XStream({
+			readableStream: response.body,
+			streamSeparator,
+			partSeparator,
+			kvSeparator
+		});
+		await this.processStream(stream, response, callbacks, streamTimeout);
+	};
+	async processStream(stream, response, callbacks, streamTimeout) {
+		const chunks = [];
+		const iterator = stream[Symbol.asyncIterator]();
+		let result;
+		do {
+			if (streamTimeout) this.streamTimeoutHandler = setTimeout(() => {
+				this.isStreamTimeout = true;
+				this.finishRequest();
+				callbacks?.onError?.(/* @__PURE__ */ new Error("StreamTimeoutError"), void 0, response.headers);
+			}, streamTimeout);
+			result = await iterator.next();
+			clearTimeout(this.streamTimeoutHandler);
+			if (this.isStreamTimeout) break;
+			if (result.value) {
+				chunks.push(result.value);
+				callbacks?.onUpdate?.(result.value, response.headers);
+				if (typeof result?.value?.id !== "undefined") this.lastEventId = result.value.id;
+			}
+		} while (!result.done);
+		if (streamTimeout) {
+			clearTimeout(this.streamTimeoutHandler);
+			if (this.isStreamTimeout) {
+				this.finishRequest();
+				return;
+			}
+		}
+		this.finishRequest();
+		callbacks?.onSuccess?.(chunks, response.headers);
+	}
+	jsonResponseHandler = async (response, callbacks) => {
+		const chunk = await response.json();
+		if (chunk?.success === false) {
+			this.finishRequest();
+			const error = new Error(chunk.message || "System error");
+			error.name = chunk.name || "SystemError";
+			callbacks?.onError?.(error, chunk, response.headers);
+		} else {
+			callbacks?.onUpdate?.(chunk, response.headers);
+			this.finishRequest();
+			callbacks?.onSuccess?.([chunk], response.headers);
+		}
+	};
+	resetRetry() {
+		clearTimeout(this.retryTimer);
+		this.retryTimes = 0;
+		this.lastEventId = void 0;
+	}
+};
+function XRequest(baseURL, options) {
+	return new XRequestClass(baseURL, options);
+}
+//#endregion
 export { AbstractXRequestClass, XRequestClass, XRequest as default, setXRequestGlobalOptions };

package/dist/x-request/x-fetch.js

@@ -0,0 +1,18 @@
+//#region src/x-request/x-fetch.ts
+var XFetch = async (baseURL, options) => {
+	const { fetch: fetchFn = globalThis.fetch, middlewares = {}, ...requestInit } = options;
+	if (typeof fetchFn !== "function") throw new Error("The options.fetch must be a typeof fetch function!");
+	let fetchArgs = [baseURL, requestInit];
+	if (typeof middlewares.onRequest === "function") fetchArgs = await middlewares.onRequest(...fetchArgs);
+	let response = await fetchFn(...fetchArgs);
+	if (typeof middlewares.onResponse === "function") {
+		const modifiedResponse = await middlewares.onResponse(response);
+		if (!(modifiedResponse instanceof Response)) throw new Error("The options.onResponse must return a Response instance!");
+		response = modifiedResponse;
+	}
+	if (!response.ok) throw new Error(`Fetch failed with status ${response.status}`);
+	if (!response.body) throw new Error("The response body is empty.");
+	return response;
+};
+//#endregion
+export { XFetch as default };

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

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

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

@@ -0,0 +1,62 @@
+import XStream 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";
+//#region src/x-stream/__tests__/index.test.ts
+var encoder = new TextEncoder();
+describe("XStream", () => {
+	it("cancels the source and releases the reader lock on early exit", async () => {
+		const cancel = vi.fn();
+		const stream = XStream({ readableStream: new ReadableStream({
+			start(controller) {
+				controller.enqueue(encoder.encode("data: first\n\n"));
+			},
+			cancel
+		}) });
+		for await (const value of stream) {
+			globalExpect(value).toEqual({ data: "first" });
+			break;
+		}
+		globalExpect(stream.locked).toBe(false);
+		await vi.waitFor(() => globalExpect(cancel).toHaveBeenCalledOnce());
+		const reader = stream.getReader();
+		await globalExpect(reader.read()).resolves.toEqual({
+			done: true,
+			value: void 0
+		});
+		reader.releaseLock();
+	});
+	it("preserves the consumer error when cancellation fails", async () => {
+		const consumerError = /* @__PURE__ */ new Error("consumer failed");
+		const cancelError = /* @__PURE__ */ new Error("cancel failed");
+		const cancel = vi.fn(() => Promise.reject(cancelError));
+		const stream = XStream({ readableStream: new ReadableStream({
+			start(controller) {
+				controller.enqueue(encoder.encode("data: first\n\n"));
+			},
+			cancel
+		}) });
+		const consume = async () => {
+			for await (const _value of stream) throw consumerError;
+		};
+		await globalExpect(consume()).rejects.toBe(consumerError);
+		globalExpect(cancel).toHaveBeenCalledOnce();
+		globalExpect(stream.locked).toBe(false);
+	});
+	it("releases the reader lock without cancellation after normal completion", async () => {
+		const cancel = vi.fn();
+		const stream = XStream({ readableStream: new ReadableStream({
+			start(controller) {
+				controller.enqueue(encoder.encode("data: first\n\n"));
+				controller.enqueue(encoder.encode("data: second\n\n"));
+				controller.close();
+			},
+			cancel
+		}) });
+		const values = [];
+		for await (const value of stream) values.push(value);
+		globalExpect(values).toEqual([{ data: "first" }, { data: "second" }]);
+		globalExpect(cancel).not.toHaveBeenCalled();
+		globalExpect(stream.locked).toBe(false);
+	});
+});
+//#endregion

package/dist/x-stream/index.js

@@ -101,11 +101,22 @@ function XStream(options) {
 	/** support async iterator */
 	stream[Symbol.asyncIterator] = async function* () {
 		const reader = this.getReader();
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			if (!value) continue;
-			yield value;
+		let completed = false;
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					completed = true;
+					break;
+				}
+				if (!value) continue;
+				yield value;
+			}
+		} finally {
+			if (!completed) try {
+				await reader.cancel();
+			} catch {}
+			reader.releaseLock();
 		}
 	};
 	return stream;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@antdv-next/x-sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
+  "license": "MIT",
   "files": [
     "dist"
   ],

package/dist/chat-providers-5x9Va7p5.js

@@ -1,167 +0,0 @@
-//#region src/chat-providers/AbstractChatProvider.ts
-var AbstractChatProvider = class {
-	_request;
-	_getMessagesFn;
-	_originalCallbacks;
-	get request() {
-		return this._request;
-	}
-	constructor(config) {
-		const request = typeof config.request === "function" ? config.request() : config.request;
-		if (!request.manual) throw new Error("request must be manual");
-		this._request = request;
-		this._originalCallbacks = this._request.options?.callbacks;
-	}
-	getMessages() {
-		return this?._getMessagesFn();
-	}
-	injectGetMessages(getMessages) {
-		this._getMessagesFn = getMessages;
-	}
-	injectRequest({ onUpdate, onSuccess, onError }) {
-		const originalOnUpdate = this._originalCallbacks?.onUpdate;
-		const originalOnSuccess = this._originalCallbacks?.onSuccess;
-		const originalOnError = this._originalCallbacks?.onError;
-		this._request.options.callbacks = {
-			onUpdate: (data, responseHeaders) => {
-				const msg = onUpdate(data, responseHeaders);
-				if (originalOnUpdate) originalOnUpdate(data, responseHeaders, msg);
-			},
-			onSuccess: (data, responseHeaders) => {
-				const msg = onSuccess(data, responseHeaders);
-				if (originalOnSuccess) originalOnSuccess(data, responseHeaders, msg);
-			},
-			onError: (error, errorInfo, responseHeaders) => {
-				const fallbackMsg = onError(error, errorInfo);
-				if (originalOnError) originalOnError(error, errorInfo, responseHeaders, fallbackMsg);
-			}
-		};
-	}
-};
-//#endregion
-//#region src/chat-providers/DeepSeekChatProvider.ts
-/**
-* DeepSeek Chat Provider
-* @template ChatMessage 消息类型
-* @template Input 请求参数类型
-* @template Output 响应数据类型
-*/
-var DeepSeekChatProvider = class extends AbstractChatProvider {
-	transformParams(requestParams, options) {
-		return {
-			...options?.params,
-			...requestParams,
-			messages: this.getMessages()
-		};
-	}
-	transformLocalMessage(requestParams) {
-		return requestParams?.messages || [];
-	}
-	transformMessage(info) {
-		const { originMessage, chunk, responseHeaders } = info;
-		let currentContent = "";
-		let currentThink = "";
-		let role = "assistant";
-		try {
-			let message;
-			if (responseHeaders.get("content-type")?.includes("text/event-stream")) {
-				if (chunk && chunk.data?.trim() !== "[DONE]") message = JSON.parse(chunk.data);
-			} else message = chunk;
-			if (message) message?.choices?.forEach((choice) => {
-				if (choice?.delta) {
-					currentThink = choice.delta.reasoning_content || "";
-					currentContent += choice.delta.content || "";
-					role = choice.delta.role;
-				} else if (choice?.message) {
-					currentThink = choice.message.reasoning_content || "";
-					currentContent += choice.message.content || "";
-					role = choice.message.role;
-				}
-			});
-		} catch (error) {
-			console.error("transformMessage error", error);
-		}
-		let content = "";
-		let originMessageContent = typeof originMessage?.content === "string" ? originMessage?.content : originMessage?.content.text || "";
-		if (!originMessageContent && currentThink) content = `\n\n<think>\n\n${currentThink?.replace?.(/^\n{0,2}/, "")}`;
-		else if (originMessageContent.includes("<think>") && !originMessageContent.includes("</think>") && currentContent) {
-			originMessageContent = originMessageContent.replace("<think>", "<think status=\"done\">");
-			content = `${originMessageContent?.replace?.(/[\s\n]{0,2}$/, "")}\n\n</think>\n\n${currentContent}`;
-		} else content = `${originMessageContent || ""}${currentThink}${currentContent}`;
-		return {
-			content,
-			role: role || "assistant"
-		};
-	}
-};
-//#endregion
-//#region src/chat-providers/DefaultChatProvider.ts
-var DefaultChatProvider = class extends AbstractChatProvider {
-	transformParams(requestParams, options) {
-		if (typeof requestParams !== "object") throw new Error("requestParams must be an object");
-		return {
-			...options?.params,
-			...requestParams
-		};
-	}
-	transformLocalMessage(requestParams) {
-		return requestParams;
-	}
-	transformMessage(info) {
-		const { chunk, chunks, originMessage } = info;
-		if (chunk) return chunk;
-		if (Array.isArray(chunks)) {
-			const chunk = chunks?.length > 0 ? chunks?.[chunks?.length - 1] : void 0;
-			return originMessage ? originMessage : chunk;
-		}
-		return chunks;
-	}
-};
-//#endregion
-//#region src/chat-providers/OpenAIChatProvider.ts
-/**
-* LLM OpenAI Compatible Chat Provider
-* @template ChatMessage 消息类型
-* @template Input 请求参数类型
-* @template Output 响应数据类型
-*/
-var OpenAIChatProvider = class extends AbstractChatProvider {
-	transformParams(requestParams, options) {
-		return {
-			...options?.params,
-			...requestParams,
-			messages: this.getMessages()
-		};
-	}
-	transformLocalMessage(requestParams) {
-		return requestParams?.messages || [];
-	}
-	transformMessage(info) {
-		const { originMessage, chunk, responseHeaders } = info;
-		let currentContent = "";
-		let role = "assistant";
-		try {
-			let message;
-			if (responseHeaders.get("content-type")?.includes("text/event-stream")) {
-				if (chunk && chunk.data?.trim() !== "[DONE]") message = JSON.parse(chunk.data);
-			} else message = chunk;
-			if (message) message?.choices?.forEach((choice) => {
-				if (choice?.delta) {
-					currentContent += choice.delta.content || "";
-					role = choice.delta.role || "assistant";
-				} else if (choice?.message) {
-					currentContent += choice.message.content || "";
-					role = choice.message.role || "assistant";
-				}
-			});
-		} catch (error) {
-			console.error("transformMessage error", error);
-		}
-		return {
-			content: `${originMessage?.content || ""}${currentContent || ""}`,
-			role
-		};
-	}
-};
-//#endregion
-export { AbstractChatProvider as i, DefaultChatProvider as n, DeepSeekChatProvider as r, OpenAIChatProvider as t };