@antdv-next/x-sdk 0.0.1 → 0.0.2

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 };

package/dist/x-request-BSFGaKND.js

@@ -1,234 +0,0 @@
-import XStream from "./x-stream/index.js";
-//#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
-//#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) {
-		if (!baseURL || typeof baseURL !== "string") throw new Error("The baseURL is not valid!");
-		this.baseURL = baseURL;
-		this.options = options || {};
-	}
-};
-var XRequestClass = class extends AbstractXRequestClass {
-	_asyncHandler;
-	timeoutHandler;
-	_isTimeout = false;
-	streamTimeoutHandler;
-	_isStreamTimeout = false;
-	abortController;
-	_isRequesting = false;
-	_manual = false;
-	lastManualParams;
-	retryTimes = 0;
-	retryTimer;
-	lastEventId = void 0;
-	get asyncHandler() {
-		return this._asyncHandler;
-	}
-	get isTimeout() {
-		return this._isTimeout;
-	}
-	set isTimeout(value) {
-		this._isTimeout = value;
-	}
-	get isStreamTimeout() {
-		return this._isStreamTimeout;
-	}
-	set isStreamTimeout(value) {
-		this._isStreamTimeout = value;
-	}
-	get isRequesting() {
-		return this._isRequesting;
-	}
-	get manual() {
-		return this._manual;
-	}
-	constructor(baseURL, options) {
-		super(baseURL, options);
-		this._manual = options?.manual || false;
-		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) {
-		this.abortController = new AbortController();
-		const { callbacks, params, headers = {}, transformStream, fetch, timeout, streamTimeout, middlewares, streamSeparator, partSeparator, kvSeparator, ...otherOptions } = this.options;
-		const margeHeaders = Object.assign({}, globalOptions.headers || {}, 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 = window.setTimeout(() => {
-			this.isTimeout = true;
-			this.finishRequest();
-			callbacks?.onError?.(/* @__PURE__ */ new Error("TimeoutError"));
-		}, timeout);
-		this.startRequest();
-		this._asyncHandler = XFetch(this.baseURL, {
-			fetch,
-			...requestInit
-		}).then(async (response) => {
-			clearTimeout(this.timeoutHandler);
-			if (this.isTimeout) return;
-			if (transformStream) {
-				let transformer = transformStream;
-				if (typeof transformStream === "function") transformer = transformStream(this.baseURL, 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 retryInterval = typeof returnOfOnError === "number" ? returnOfOnError : this.options.retryInterval;
-				if (retryInterval && retryInterval > 0) {
-					if (typeof this.options.retryTimes === "number" && this.retryTimes >= this.options.retryTimes) return;
-					clearTimeout(this.retryTimer);
-					this.retryTimer = setTimeout(() => {
-						const extraHeaders = {};
-						if (typeof this.lastEventId !== "undefined") extraHeaders[LastEventId] = this.lastEventId;
-						this.init(this.lastManualParams, extraHeaders);
-					}, retryInterval);
-					this.retryTimes = this.retryTimes + 1;
-				}
-			}
-		});
-	}
-	startRequest() {
-		this._isRequesting = true;
-	}
-	finishRequest() {
-		this._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 = window.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) {
-			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 { setXRequestGlobalOptions as i, XRequest as n, XRequestClass as r, AbstractXRequestClass as t };