@antdv-next/x-sdk 0.0.1

package/dist/_util/types.d.ts

@@ -0,0 +1 @@
+export type AnyObject = Record<PropertyKey, any>;

package/dist/chat-providers/AbstractChatProvider.d.ts

@@ -0,0 +1,42 @@
+import { MessageStatus, SimpleType } from '../x-chat';
+import { AbstractXRequestClass, XRequestOptions } from '../x-request';
+export interface ChatProviderConfig<Input, Output, ChatMessage extends SimpleType = any> {
+    request: AbstractXRequestClass<Input, Output, ChatMessage> | (() => AbstractXRequestClass<Input, Output, ChatMessage>);
+}
+export interface TransformMessage<ChatMessage extends SimpleType, Output> {
+    originMessage?: ChatMessage;
+    chunk: Output;
+    chunks: Output[];
+    status: MessageStatus;
+    responseHeaders: Headers;
+}
+export default abstract class AbstractChatProvider<ChatMessage extends SimpleType, Input, Output> {
+    private _request;
+    private _getMessagesFn;
+    private _originalCallbacks?;
+    get request(): AbstractXRequestClass<Input, Output, ChatMessage>;
+    constructor(config: ChatProviderConfig<Input, Output, ChatMessage>);
+    /**
+     * 转换onRequest传入的参数，你可以和Provider实例化时request配置中的params进行合并或者额外处理
+     * @param requestParams 请求参数
+     * @param options 请求配置，从Provider实例化时request配置中来
+     */
+    abstract transformParams(requestParams: Partial<Input>, options: XRequestOptions<Input, Output, ChatMessage>): Input;
+    /**
+     * 将onRequest传入的参数转换为本地（用户发送）的ChatMessage，用于消息渲染
+     * @param requestParams onRequest传入的参数
+     */
+    abstract transformLocalMessage(requestParams: Partial<Input>): ChatMessage | ChatMessage[];
+    /**
+     * 可在更新返回数据时对messages做转换，同时会更新到messages
+     * @param info
+     */
+    abstract transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+    getMessages(): ChatMessage[];
+    injectGetMessages(getMessages: () => ChatMessage[]): void;
+    injectRequest({ onUpdate, onSuccess, onError, }: {
+        onUpdate: (data: Output, responseHeaders: Headers) => any;
+        onSuccess: (data: Output[], responseHeaders: Headers) => any;
+        onError: (error: any, errorInfo?: any) => any;
+    }): void;
+}

package/dist/chat-providers/DeepSeekChatProvider.d.ts

@@ -0,0 +1,15 @@
+import { XRequestOptions } from '../x-request';
+import { SSEFields } from '../x-stream';
+import { TransformMessage, default as AbstractChatProvider } from './AbstractChatProvider';
+import { XModelMessage, XModelParams } from './types/model';
+/**
+ * DeepSeek Chat Provider
+ * @template ChatMessage 消息类型
+ * @template Input 请求参数类型
+ * @template Output 响应数据类型
+ */
+export default class DeepSeekChatProvider<ChatMessage extends XModelMessage = XModelMessage, Input extends XModelParams = XModelParams, Output extends Partial<Record<SSEFields, any>> = Partial<Record<SSEFields, any>>> extends AbstractChatProvider<ChatMessage, Input, Output> {
+    transformParams(requestParams: Partial<Input>, options: XRequestOptions<Input, Output, ChatMessage>): Input;
+    transformLocalMessage(requestParams: Partial<Input>): ChatMessage[];
+    transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+}

package/dist/chat-providers/DefaultChatProvider.d.ts

@@ -0,0 +1,8 @@
+import { SimpleType } from '../x-chat';
+import { XRequestOptions } from '../x-request';
+import { TransformMessage, default as AbstractChatProvider } from './AbstractChatProvider';
+export default class DefaultChatProvider<ChatMessage extends SimpleType, Input, Output> extends AbstractChatProvider<ChatMessage, Input, Output> {
+    transformParams(requestParams: ChatMessage & Partial<Input>, options: XRequestOptions<Input, Output, ChatMessage>): Input;
+    transformLocalMessage(requestParams: Partial<Input>): ChatMessage;
+    transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+}

package/dist/chat-providers/OpenAIChatProvider.d.ts

@@ -0,0 +1,15 @@
+import { XRequestOptions } from '../x-request';
+import { SSEFields } from '../x-stream';
+import { TransformMessage, default as AbstractChatProvider } from './AbstractChatProvider';
+import { XModelMessage, XModelParams } from './types/model';
+/**
+ * LLM OpenAI Compatible Chat Provider
+ * @template ChatMessage 消息类型
+ * @template Input 请求参数类型
+ * @template Output 响应数据类型
+ */
+export default class OpenAIChatProvider<ChatMessage extends XModelMessage = XModelMessage, Input extends XModelParams = XModelParams, Output extends Partial<Record<SSEFields, any>> = Partial<Record<SSEFields, any>>> extends AbstractChatProvider<ChatMessage, Input, Output> {
+    transformParams(requestParams: Partial<Input>, options: XRequestOptions<Input, Output, ChatMessage>): Input;
+    transformLocalMessage(requestParams: Partial<Input>): ChatMessage[];
+    transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+}

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

@@ -0,0 +1,5 @@
+export type { ChatProviderConfig, TransformMessage, } from './AbstractChatProvider';
+export { default as AbstractChatProvider } from './AbstractChatProvider';
+export { default as DeepSeekChatProvider } from './DeepSeekChatProvider';
+export { default as DefaultChatProvider } from './DefaultChatProvider';
+export { default as OpenAIChatProvider } from './OpenAIChatProvider';

package/dist/chat-providers/index.js

@@ -0,0 +1,2 @@
+import { i as AbstractChatProvider, n as DefaultChatProvider, r as DeepSeekChatProvider, t as OpenAIChatProvider } from "../chat-providers-5x9Va7p5.js";
+export { AbstractChatProvider, DeepSeekChatProvider, DefaultChatProvider, OpenAIChatProvider };

package/dist/chat-providers/types/model.d.ts

@@ -0,0 +1,108 @@
+import { AnyObject } from '../../_util/types';
+export interface XModelMessage extends AnyObject {
+    role: string;
+    content: string | {
+        text: string;
+        type: string;
+    };
+}
+export interface XModelParams extends AnyObject {
+    model?: string;
+    messages?: XModelMessage[];
+    frequency_penalty?: number;
+    logit_bias?: AnyObject;
+    logprobs?: boolean;
+    max_completion_tokens?: number;
+    metadata?: AnyObject;
+    modalities?: string[];
+    n?: number;
+    parallel_tool_calls?: boolean;
+    prediction?: {
+        content: string;
+        type: string;
+    };
+    presence_penalty?: number;
+    reasoning_effort?: string;
+    response_format?: "text" | {
+        type: "json_object";
+    } | {
+        type: "json_schema";
+        json_schema: {
+            name: string;
+            description?: string;
+            schema?: AnyObject;
+            strict?: boolean;
+        };
+    };
+    seed?: number;
+    service_tier?: string;
+    stop?: string | string[];
+    store?: boolean;
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+    };
+    temperature?: number;
+    tool_choice?: string | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    top_logprobs?: number;
+    top_p?: number;
+    user?: string;
+    web_search_options?: {
+        search_context_size?: string;
+        user_location?: {
+            type: "approximate";
+            approximate?: {
+                city?: string;
+                country?: string;
+                region?: string;
+                timezone?: string;
+            };
+        };
+    };
+}
+export interface XModelResponse {
+    choices: {
+        index: number;
+        message: {
+            role: string;
+            content: string | null;
+            reasoning_content: string | null;
+            refusal: string | null;
+            annotations: {
+                type: "url_citation";
+                end_index: number;
+                start_index: number;
+                url: string;
+                title: string;
+            }[];
+        };
+        logprobs: AnyObject | null;
+        finish_reason: "stop" | "length" | "content_filter" | "tool_calls" | string;
+    }[];
+    created: number;
+    id: string;
+    model: string;
+    object: "chat.completion" | "chat.completion.chunk";
+    service_tier: string | null;
+    system_fingerprint: string | null;
+    usage: {
+        completion_tokens: number;
+        prompt_tokens: number;
+        total_tokens: number;
+        completion_tokens_details: {
+            reasoning_tokens: number;
+            audio_tokens: number;
+            accepted_prediction_tokens: number;
+            rejected_prediction_tokens: number;
+        };
+        prompt_tokens_details: {
+            cached_tokens: number;
+            audio_tokens: number;
+        };
+    };
+}

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

@@ -0,0 +1,167 @@
+//#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/index.d.ts

@@ -0,0 +1,25 @@
+export * from './chat-providers';
+export type { XModelMessage, XModelParams, XModelResponse, } from './chat-providers/types/model';
+export type { DefaultMessageInfo, MessageInfo } from './x-chat';
+export { default as useXChat } from './x-chat';
+export type { ConversationData } from './x-conversations';
+export { default as useXConversations } from './x-conversations';
+export type { XRequestCallbacks, XRequestClass, XRequestFunction, XRequestGlobalOptions, XRequestOptions, } from './x-request';
+export { AbstractXRequestClass, default as XRequest, setXRequestGlobalOptions, } from './x-request';
+export type { SSEFields, SSEOutput, XReadableStream, XStreamOptions, } from './x-stream';
+export { default as XStream } from './x-stream';
+export interface XSdkClientOptions {
+    baseURL: string;
+    fetcher?: typeof fetch;
+}
+export interface RequestOptions {
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+}
+export declare class XSdkClient {
+    private readonly baseURL;
+    private readonly fetcher;
+    constructor(options: XSdkClientOptions);
+    get<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+}
+export declare function createXSdkClient(options: XSdkClientOptions): XSdkClient;

package/dist/index.js

@@ -0,0 +1,26 @@
+import { i as AbstractChatProvider, n as DefaultChatProvider, r as DeepSeekChatProvider, t as OpenAIChatProvider } from "./chat-providers-5x9Va7p5.js";
+import XStream from "./x-stream/index.js";
+import { i as setXRequestGlobalOptions, n as XRequest, t as AbstractXRequestClass } from "./x-request-BSFGaKND.js";
+import useXChat from "./x-chat/index.js";
+import { t as useXConversations } from "./x-conversations-BrKWhj5r.js";
+//#region src/index.ts
+var XSdkClient = class {
+	baseURL;
+	fetcher;
+	constructor(options) {
+		this.baseURL = options.baseURL.replace(/\/$/, "");
+		this.fetcher = options.fetcher ?? fetch;
+	}
+	async get(path, options = {}) {
+		return (await this.fetcher(`${this.baseURL}/${path.replace(/^\//, "")}`, {
+			method: "GET",
+			headers: options.headers,
+			signal: options.signal
+		})).json();
+	}
+};
+function createXSdkClient(options) {
+	return new XSdkClient(options);
+}
+//#endregion
+export { AbstractChatProvider, AbstractXRequestClass, DeepSeekChatProvider, DefaultChatProvider, OpenAIChatProvider, XRequest, XSdkClient, XStream, createXSdkClient, setXRequestGlobalOptions, useXChat, useXConversations };

package/dist/store-C1diHqNH.js

@@ -0,0 +1,145 @@
+//#region src/x-chat/store.ts
+var chatMessagesStoreHelper = {
+	_chatMessagesStores: /* @__PURE__ */ new Map(),
+	get: (conversationKey) => {
+		return chatMessagesStoreHelper._chatMessagesStores.get(conversationKey);
+	},
+	set: (key, store) => {
+		chatMessagesStoreHelper._chatMessagesStores.set(key, store);
+	},
+	delete: (key) => {
+		chatMessagesStoreHelper._chatMessagesStores.delete(key);
+	},
+	getMessages: (conversationKey) => {
+		return chatMessagesStoreHelper._chatMessagesStores.get(conversationKey)?.getMessages();
+	}
+};
+var ChatMessagesStore = class {
+	listeners = [];
+	conversationKey;
+	snapshotResult = {
+		messages: [],
+		isDefaultMessagesRequesting: false
+	};
+	throttleTimer = null;
+	pendingEmit = false;
+	throttleInterval = 50;
+	isDestroyed = false;
+	emitListeners() {
+		this.listeners.forEach((listener) => {
+			listener();
+		});
+	}
+	throttledEmitListeners() {
+		if (!this.throttleTimer) {
+			this.emitListeners();
+			this.pendingEmit = false;
+			this.throttleTimer = setTimeout(() => {
+				this.throttleTimer = null;
+				if (this.pendingEmit) {
+					this.emitListeners();
+					this.pendingEmit = false;
+				}
+			}, this.throttleInterval);
+		} else this.pendingEmit = true;
+	}
+	constructor(defaultMessages, conversationKey) {
+		this.initializeMessages(defaultMessages, (value) => {
+			this.setSnapshotResult("isDefaultMessagesRequesting", value);
+			this.emitListeners();
+		});
+		if (conversationKey) {
+			this.conversationKey = conversationKey;
+			chatMessagesStoreHelper.set(this.conversationKey, this);
+		}
+	}
+	async initializeMessages(defaultMessages, setDefaultMessagesRequesting) {
+		try {
+			setDefaultMessagesRequesting(true);
+			const messages = await defaultMessages();
+			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);
+		}
+	}
+	setSnapshotResult = (key, value) => {
+		this.snapshotResult = {
+			...this.snapshotResult,
+			[key]: value
+		};
+	};
+	setMessagesInternal = (messages, throttle = true) => {
+		let list;
+		if (typeof messages === "function") list = messages(this.snapshotResult.messages);
+		else list = messages;
+		this.setSnapshotResult("messages", list);
+		if (throttle) this.throttledEmitListeners();
+		else this.emitListeners();
+		return true;
+	};
+	setMessages = (messages) => {
+		return this.setMessagesInternal(messages, true);
+	};
+	getMessages = () => {
+		return this.snapshotResult.messages;
+	};
+	getMessage = (id) => {
+		return this.getMessages().find((item) => item.id === id);
+	};
+	addMessage = (message) => {
+		if (!this.getMessage(message.id)) {
+			this.setMessages([...this.snapshotResult.messages, message]);
+			return true;
+		}
+		return false;
+	};
+	setMessage = (id, message) => {
+		const originMessage = this.getMessage(id);
+		if (originMessage) {
+			const mergeMessage = typeof message === "function" ? message(originMessage) : message;
+			Object.assign(originMessage, mergeMessage);
+			this.setMessages([...this.snapshotResult.messages]);
+			return true;
+		}
+		return false;
+	};
+	removeMessage = (id) => {
+		const index = this.getMessages().findIndex((item) => item.id === id);
+		if (index !== -1) {
+			this.snapshotResult.messages.splice(index, 1);
+			this.setMessages([...this.getMessages()]);
+			return true;
+		}
+		return false;
+	};
+	getSnapshot = () => {
+		return this.snapshotResult;
+	};
+	subscribe = (callback) => {
+		this.listeners.push(callback);
+		return () => {
+			this.listeners = this.listeners.filter((listener) => listener !== callback);
+			if (this.listeners.length === 0) {
+				if (this.throttleTimer) {
+					clearTimeout(this.throttleTimer);
+					this.throttleTimer = null;
+				}
+				this.pendingEmit = false;
+			}
+		};
+	};
+	destroy = () => {
+		this.isDestroyed = true;
+		if (this.throttleTimer) {
+			clearTimeout(this.throttleTimer);
+			this.throttleTimer = null;
+		}
+		this.pendingEmit = false;
+		this.listeners = [];
+	};
+};
+//#endregion
+export { chatMessagesStoreHelper as n, ChatMessagesStore as t };

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

@@ -0,0 +1,86 @@
+import { Ref } from 'vue';
+import { AnyObject } from '../_util/types';
+import { ConversationData } from '../x-conversations';
+import { SSEOutput } from '../x-stream';
+import { ConversationKey } from './store';
+import { AbstractChatProvider } from '../chat-providers';
+export type SimpleType = string | number | boolean | object;
+declare enum MessageStatusEnum {
+    local = "local",
+    loading = "loading",
+    updating = "updating",
+    success = "success",
+    error = "error",
+    abort = "abort"
+}
+export type MessageStatus = `${MessageStatusEnum}`;
+type RequestPlaceholderFn<Input, Message> = (requestParams: Partial<Input>, info: {
+    messages: Message[];
+}) => Message;
+type RequestFallbackFn<Input, MessageInfoType, Message> = (requestParams: Partial<Input>, info: {
+    error: Error;
+    errorInfo?: any;
+    messages: Message[];
+    messageInfo: MessageInfoType;
+}) => Message | Promise<Message>;
+export type RequestParams<Message> = {
+    [Key: PropertyKey]: Message;
+} & AnyObject;
+type MaybeRef<T> = T | Ref<T>;
+export interface XChatConfig<ChatMessage extends SimpleType = string, BubbleMessage extends SimpleType = ChatMessage, Input = ChatMessage, Output = ChatMessage> {
+    provider?: 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>;
+}
+export interface MessageInfo<Message extends SimpleType> {
+    id: number | string;
+    message: Message;
+    status: MessageStatus;
+    extraInfo?: AnyObject;
+}
+export type DefaultMessageInfo<Message extends SimpleType> = Pick<MessageInfo<Message>, "message"> & Partial<Omit<MessageInfo<Message>, "message">>;
+export type RequestResultObject<Message> = {
+    message: Message | Message[];
+    status: MessageStatus;
+};
+export type StandardRequestResult<Message extends SimpleType> = Omit<RequestResultObject<Message>, "message" | "status"> & {
+    message: Message;
+    status?: MessageStatus;
+};
+export default function useXChat<ChatMessage extends SimpleType = string, ParsedMessage extends SimpleType = ChatMessage, Input = RequestParams<ChatMessage>, Output = SSEOutput>(config: XChatConfig<ChatMessage, ParsedMessage, Input, Output>): {
+    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 parsedMessages: import('vue').ComputedRef<MessageInfo<ParsedMessage>[]>;
+    readonly setMessages: (updater: MessageInfo<ChatMessage>[] | ((ori: MessageInfo<ChatMessage>[]) => MessageInfo<ChatMessage>[])) => boolean;
+    readonly removeMessage: (id: string | number) => boolean;
+    readonly setMessage: (id: string | number, message: Partial<MessageInfo<ChatMessage>> | ((message: MessageInfo<ChatMessage>) => Partial<MessageInfo<ChatMessage>>)) => boolean;
+    readonly abort: () => void;
+    readonly isRequesting: import('vue').ComputedRef<boolean>;
+    readonly onReload: (id: string | number, requestParams: Partial<Input>, opts?: {
+        extraInfo: AnyObject;
+    }) => void;
+    readonly queueRequest: (currentConversationKey: ConversationKey, requestParams: Partial<Input>, opts?: {
+        extraInfo: AnyObject;
+    }) => void;
+};
+export {};