@ant-design-x-vue/x-sdk 0.0.0-stage → 2.0.0

package/README.md

@@ -1,3 +1,38 @@
-# Temporary Holding Version
+# @ant-design-x-vue/x-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+SDK toolkit for ant-design-x-vue, providing utilities for AI-powered applications.
+
+## Features
+
+- **useXChat** - Vue composable for managing chat messages
+- **useXConversations** - Vue composable for managing conversations
+- **XRequest** - HTTP request utility with streaming support
+- **XStream** - SSE (Server-Sent Events) stream parser
+- **XMcpClient** - Model Context Protocol client
+- **Chat Providers** - Pre-built providers for OpenAI, DeepSeek, etc.
+
+## Installation
+
+```bash
+pnpm add @ant-design-x-vue/x-sdk
+```
+
+## Usage
+
+```typescript
+import { useXChat, useXConversations, XRequest, XStream } from '@ant-design-x-vue/x-sdk';
+
+// Use chat composable
+const { messages, addMessage } = useXChat();
+
+// Use conversations composable
+const { conversations, activeId, addConversation } = useXConversations();
+
+// Use XRequest for API calls
+const request = XRequest({ baseURL: 'https://api.example.com' });
+const data = await request.request('/endpoint');
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,518 @@
+import { ComputedRef } from 'vue';
+import { ShallowRef } from 'vue';
+
+export declare abstract class AbstractChatProvider<ChatMessage, Input, Output> {
+    private _request;
+    private _getMessagesFn;
+    private _originalCallbacks?;
+    get request(): AbstractXRequestClass<Input, Output>;
+    constructor(config: ChatProviderConfig<Input, Output>);
+    abstract transformParams(requestParams: Partial<Input>, options: XRequestOptions<Input, Output>): Input;
+    abstract transformLocalMessage(requestParams: Partial<Input>): ChatMessage | ChatMessage[];
+    abstract transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+    getMessages(): ChatMessage[];
+    injectGetMessages(getMessages: () => ChatMessage[]): void;
+    injectRequest({ onUpdate, onSuccess, onError, }: {
+        onUpdate: (data: Output, responseHeaders: Headers) => void;
+        onSuccess: (data: Output[], responseHeaders: Headers) => void;
+        onError: (error: any) => void;
+    }): void;
+}
+
+export declare abstract class AbstractXRequestClass<Input, Output> {
+    baseURL: string;
+    options: XRequestOptions<Input, Output>;
+    constructor(baseURL: string, options?: XRequestOptions<Input, Output>);
+    abstract get asyncHandler(): Promise<any>;
+    abstract get isTimeout(): boolean;
+    abstract get isStreamTimeout(): boolean;
+    abstract get isRequesting(): boolean;
+    abstract get manual(): boolean;
+    abstract run(params?: Input): void;
+    abstract abort(): void;
+}
+
+declare type AnyObject = Record<PropertyKey, any>;
+
+export declare class ChatMessagesStore<T extends {
+    id: number | string;
+}> {
+    private messages;
+    private listeners;
+    private conversationKey;
+    private emitListeners;
+    constructor(defaultMessages: T[], conversationKey?: ConversationKey);
+    setMessages: (messages: T[] | ((ori: T[]) => T[])) => boolean;
+    getMessages: () => T[];
+    getMessage: (id: string | number) => T | undefined;
+    addMessage: (message: T) => boolean;
+    setMessage: (id: string | number, message: Partial<T> | ((message: T) => Partial<T>)) => boolean;
+    removeMessage: (id: string) => boolean;
+    getSnapshot: () => T[];
+    subscribe: (callback: () => void) => () => void;
+}
+
+export declare const chatMessagesStoreHelper: {
+    _chatMessagesStores: Map<string | number, ChatMessagesStore<any>>;
+    get: (conversationKey: ConversationKey) => ChatMessagesStore<any> | undefined;
+    set: (key: ConversationKey, store: ChatMessagesStore<any>) => void;
+    delete: (key: ConversationKey) => void;
+    getMessages: (conversationKey: ConversationKey) => any[] | undefined;
+};
+
+export declare interface ChatProviderConfig<Input, Output> extends AnyObject {
+    request: AbstractXRequestClass<Input, Output> | (() => AbstractXRequestClass<Input, Output>);
+}
+
+export declare interface ConversationData extends AnyObject {
+    key: string;
+}
+
+declare type ConversationKey = string | number;
+
+export declare class ConversationStore {
+    private conversations;
+    private listeners;
+    private storeKey;
+    private activeConversationKey;
+    constructor(defaultConversations: ConversationData[], defaultActiveConversationKey: string);
+    private emitListeners;
+    setActiveConversationKey: (key: string) => boolean;
+    setConversations: (list: ConversationData[]) => boolean;
+    getConversation: (key: ConversationData["key"]) => ConversationData | undefined;
+    addConversation: (conversation: ConversationData, placement?: "prepend" | "append") => boolean;
+    setConversation: (key: ConversationData["key"], conversation: ConversationData) => boolean;
+    removeConversation: (key: ConversationData["key"]) => boolean;
+    getMessages: (key: ConversationData["key"]) => any[] | undefined;
+    getSnapshot: () => ConversationData[];
+    getActiveConversationKey: () => string;
+    subscribe: (callback: () => void) => () => void;
+    destroy: () => void;
+}
+
+/**
+ * Global registry so that `useXChat` can reach back into conversation state
+ * (e.g. to read previous messages for a given conversation key).
+ */
+export declare const conversationStoreHelper: {
+    _allConversationStores: Map<string, ConversationStore>;
+    set(key: string, store: ConversationStore): void;
+    delete(key: string): void;
+    getConversation(conversationKey: string): ConversationData | undefined;
+};
+
+export declare function createOpenAIChatProvider<ChatMessage extends XModelMessage = XModelMessage, Input extends XModelParams = XModelParams>(config: OpenAIPresetConfig): OpenAIChatProvider<ChatMessage, Input, Partial<Record<SSEFields, any>>>;
+
+/**
+ * DeepSeek Chat Provider
+ */
+export declare 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>): Input;
+    transformLocalMessage(requestParams: Partial<Input>): ChatMessage[];
+    transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+}
+
+export declare class DefaultChatProvider<ChatMessage, Input, Output> extends AbstractChatProvider<ChatMessage, Input, Output> {
+    transformParams(requestParams: ChatMessage & Partial<Input>, options: XRequestOptions<Input, Output>): Input;
+    transformLocalMessage(requestParams: Partial<Input>): ChatMessage;
+    transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+}
+
+export declare type DefaultMessageInfo<Message extends SimpleType> = Pick<MessageInfo<Message>, 'message'> & Partial<Omit<MessageInfo<Message>, 'message'>>;
+
+declare type Getter<T> = () => T;
+
+export declare interface JSONOutPut extends Partial<Record<SSEFields, any>> {
+    success: boolean;
+    message?: string;
+    name?: string;
+}
+
+export declare interface MessageInfo<Message extends SimpleType> {
+    id: number | string;
+    message: Message;
+    status: MessageStatus;
+    extraInfo?: AnyObject;
+}
+
+export declare type MessageStatus = 'local' | 'loading' | 'updating' | 'success' | 'error' | 'abort';
+
+/**
+ * LLM OpenAI Compatible Chat Provider
+ */
+export declare 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>): Input;
+    transformLocalMessage(requestParams: Partial<Input>): ChatMessage[];
+    transformMessage(info: TransformMessage<ChatMessage, Output>): ChatMessage;
+}
+
+/**
+ * 1.x `useXAgent({ baseURL, model, dangerouslyApiKey | key })` preset.
+ * 2.0 sends that through `OpenAIChatProvider` and a manual `XRequest`.
+ */
+export declare interface OpenAIPresetConfig {
+    /** Chat Completions URL, for example `https://api.openai.com/v1/chat/completions`. */
+    baseURL: string;
+    model?: string;
+    /**
+     * Client-side credential. Prefer a backend proxy.
+     * A raw token is sent as `Bearer <token>`. Values that already start with
+     * `Bearer `, `Basic `, or `Tbox-` are sent unchanged.
+     */
+    dangerouslyApiKey?: string;
+    /** Alias of `dangerouslyApiKey`, kept from the 1.x preset config. */
+    key?: string;
+    /**
+     * Optional fetch implementation. Docs and tests pass a mock.
+     * Production calls use the platform `fetch`.
+     */
+    fetch?: (baseURL: Parameters<typeof fetch>[0], options: {
+        body?: BodyInit | null;
+    }) => Promise<Response>;
+}
+
+declare type RequestFallbackFn<Input, MessageInfoT, Message> = (requestParams: Partial<Input>, info: {
+    error: Error;
+    messages: Message[];
+    messageInfo: MessageInfoT;
+}) => Message | Promise<Message>;
+
+export declare type RequestParams<Message> = {
+    [Key: PropertyKey]: Message;
+} & AnyObject;
+
+declare type RequestPlaceholderFn<Input, Message> = (requestParams: Partial<Input>, info: {
+    messages: Message[];
+}) => Message;
+
+export declare function resolvePresetApiKey(config: {
+    dangerouslyApiKey?: string;
+    key?: string;
+}): string | undefined;
+
+export declare function setXRequestGlobalOptions<Input, Output>(options: XRequestGlobalOptions<Input, Output>): void;
+
+export declare type SimpleType = string | number | boolean | object;
+
+/**
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#fields
+ */
+export declare type SSEFields = 'data' | 'event' | 'id' | 'retry';
+
+export declare type SSEOutput = Partial<Record<SSEFields, any>>;
+
+export declare interface TransformMessage<ChatMessage, Output> {
+    originMessage?: ChatMessage;
+    chunk: Output;
+    chunks: Output[];
+    status: MessageStatus;
+    responseHeaders: Headers;
+}
+
+/**
+ * Vue composable for chat store. Accepts conversationKey as a reactive ref.
+ */
+export declare function useChatStore<T extends {
+    id: number | string;
+}>(defaultValue: T[] | Getter<T[]>, conversationKey?: ConversationKey | ShallowRef<ConversationKey | undefined>): UseChatStoreReturn<T>;
+
+declare interface UseChatStoreReturn<T extends {
+    id: number | string;
+}> {
+    messages: ShallowRef<T[]>;
+    addMessage: ChatMessagesStore<T>['addMessage'];
+    removeMessage: ChatMessagesStore<T>['removeMessage'];
+    setMessage: ChatMessagesStore<T>['setMessage'];
+    getMessage: ChatMessagesStore<T>['getMessage'];
+    setMessages: ChatMessagesStore<T>['setMessages'];
+    getMessages: ChatMessagesStore<T>['getMessages'];
+}
+
+export declare 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 messages: ShallowRef<MessageInfo<ChatMessage>[]>;
+    readonly parsedMessages: ComputedRef<MessageInfo<ParsedMessage>[]>;
+    readonly setMessages: (messages: MessageInfo<ChatMessage>[] | ((ori: MessageInfo<ChatMessage>[]) => MessageInfo<ChatMessage>[])) => boolean;
+    readonly setMessage: (id: string | number, message: Partial<MessageInfo<ChatMessage>> | ((message: MessageInfo<ChatMessage>) => Partial<MessageInfo<ChatMessage>>)) => boolean;
+    readonly abort: () => void;
+    readonly isRequesting: ComputedRef<boolean>;
+    readonly onReload: (id: string | number, requestParams: Partial<Input>, opts?: {
+        extraInfo: AnyObject;
+    }) => void;
+};
+
+/**
+ * Vue port of React's `useXConversations` – exposes reactive `conversations`
+ * and `activeConversationKey` refs plus the store mutations. The underlying
+ * `ConversationStore` is shared across hooks through `conversationStoreHelper`
+ * so `useXChat` can resolve history by conversation key.
+ */
+export declare function useXConversations(config?: XConversationConfig): UseXConversationsReturn;
+
+export declare interface UseXConversationsReturn {
+    conversations: ShallowRef<ConversationData[]>;
+    activeConversationKey: ShallowRef<string>;
+    setActiveConversationKey: (key: string) => boolean;
+    addConversation: (conversation: ConversationData, placement?: 'prepend' | 'append') => boolean;
+    removeConversation: (key: ConversationData['key']) => boolean;
+    setConversation: (key: ConversationData['key'], conversation: ConversationData) => boolean;
+    getConversation: (key: ConversationData['key']) => ConversationData | undefined;
+    setConversations: (list: ConversationData[]) => boolean;
+    getMessages: (key: ConversationData['key']) => unknown;
+}
+
+export declare const version: "2.0.0";
+
+export declare interface XChatConfig<ChatMessage extends SimpleType = string, BubbleMessage extends SimpleType = ChatMessage, Input = ChatMessage, Output = ChatMessage> {
+    provider?: AbstractChatProvider<ChatMessage, Input, Output>;
+    conversationKey?: ConversationData['key'] | ShallowRef<ConversationData['key'] | undefined>;
+    defaultMessages?: DefaultMessageInfo<ChatMessage>[];
+    /** Convert agent message to bubble usage message type */
+    parser?: (message: ChatMessage) => BubbleMessage | BubbleMessage[];
+    requestPlaceholder?: ChatMessage | RequestPlaceholderFn<Input, ChatMessage>;
+    requestFallback?: ChatMessage | RequestFallbackFn<Input, MessageInfo<ChatMessage>, ChatMessage>;
+}
+
+export declare interface XConversationConfig {
+    defaultConversations?: ConversationData[];
+    defaultActiveConversationKey?: string;
+}
+
+export declare interface XFetchMiddlewares<Input, Output> {
+    onRequest?: (baseURL: Parameters<typeof fetch>[0], options: XRequestOptions<Input, Output>) => Promise<[Parameters<typeof fetch>[0], XRequestOptions<Input, Output>]>;
+    onResponse?: (response: Response) => Promise<Response>;
+}
+
+export declare function XMCPClient(baseURL: string, options?: XMCPClientOptions): XMCPClientClass;
+
+export declare const XMcpClient: typeof XMCPClient;
+
+/**
+ * MCP (Model Context Protocol) client that talks to a server exposing an
+ * MCP-compatible HTTP endpoint, built on top of `XRequest` so that it reuses
+ * the shared middleware, timeouts and abort semantics.
+ */
+export declare class XMCPClientClass {
+    readonly baseURL: string;
+    private options;
+    constructor(baseURL: string, options?: XMCPClientOptions);
+    /**
+     * Fetch the list of tools published by the MCP server.
+     */
+    tools(): Promise<XMCPTool[]>;
+}
+
+export declare type XMCPClientOptions = Pick<XRequestOptions, 'params' | 'headers' | 'timeout' | 'fetch'>;
+
+export declare type XMcpClientOptions = XMCPClientOptions;
+
+export declare interface XMCPTool {
+    name: string;
+    description?: string;
+    inputSchema: {
+        type: 'object';
+        properties: AnyObject;
+    };
+    annotations?: {
+        title?: string;
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+}
+
+export declare interface XModelMessage extends AnyObject {
+    role: string;
+    content: string | {
+        text: string;
+        type: string;
+    };
+}
+
+export declare 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 declare 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;
+        };
+    };
+}
+
+export declare type XReadableStream<R = SSEOutput> = ReadableStream<R> & AsyncGenerator<R>;
+
+export declare function XRequest<Input = AnyObject, Output = SSEOutput>(baseURL: string, options?: XRequestOptions<Input, Output>): AbstractXRequestClass<Input, Output>;
+
+export declare interface XRequestCallbacks<Output> {
+    /**
+     * @description Callback when the request is successful
+     */
+    onSuccess: (chunks: Output[], responseHeaders: Headers) => void;
+    /**
+     * @description Callback when the request fails
+     */
+    onError: (error: Error) => void;
+    /**
+     * @description Callback when the request is updated (per chunk)
+     */
+    onUpdate?: (chunk: Output, responseHeaders: Headers) => void;
+}
+
+export declare class XRequestClass<Input = AnyObject, Output = SSEOutput> extends AbstractXRequestClass<Input, Output> {
+    private _asyncHandler;
+    private timeoutHandler;
+    private _isTimeout;
+    private streamTimeoutHandler;
+    private _isStreamTimeout;
+    private abortController;
+    private _isRequesting;
+    private _manual;
+    get asyncHandler(): Promise<any>;
+    get isTimeout(): boolean;
+    private set isTimeout(value);
+    get isStreamTimeout(): boolean;
+    private set isStreamTimeout(value);
+    get isRequesting(): boolean;
+    get manual(): boolean;
+    constructor(baseURL: string, options?: XRequestOptions<Input, Output>);
+    run(params?: Input): void;
+    abort(): void;
+    private init;
+    private startRequest;
+    private finishRequest;
+    private customResponseHandler;
+    private sseResponseHandler;
+    private processStream;
+    private jsonResponseHandler;
+}
+
+export declare type XRequestFunction<Input = AnyObject, Output = SSEOutput> = (baseURL: string, options?: XRequestOptions<Input, Output>) => XRequestClass<Input, Output>;
+
+export declare type XRequestGlobalOptions<Input, Output> = Pick<XRequestOptions<Input, Output>, 'headers' | 'timeout' | 'streamTimeout' | 'middlewares' | 'fetch' | 'transformStream' | 'manual'>;
+
+export declare interface XRequestOptions<Input = AnyObject, Output = SSEOutput> extends RequestInit {
+    callbacks?: XRequestCallbacks<Output>;
+    params?: Input;
+    headers?: Record<string, string>;
+    timeout?: number;
+    streamTimeout?: 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']);
+    manual?: boolean;
+}
+
+/**
+ * @description Transform Uint8Array binary stream to {@link SSEOutput} by default.
+ * Only supports utf-8 encoding for now.
+ */
+export declare function XStream<Output = SSEOutput>(options: XStreamOptions<Output>): XReadableStream<Output>;
+
+export declare interface XStreamOptions<Output> {
+    /**
+     * @description Readable stream of binary data
+     */
+    readableStream: ReadableStream<Uint8Array>;
+    /**
+     * @description Support customizable transformStream to transform streams
+     * @default sseTransformStream
+     */
+    transformStream?: TransformStream<string, Output>;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,4 @@
+"use strict";var ae=Object.defineProperty;var ue=(r,e,t)=>e in r?ae(r,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):r[e]=t;var a=(r,e,t)=>ue(r,typeof e!="symbol"?e+"":e,t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const T=require("vue"),b={_chatMessagesStores:new Map,get:r=>b._chatMessagesStores.get(r),set:(r,e)=>{b._chatMessagesStores.set(r,e)},delete:r=>{b._chatMessagesStores.delete(r)},getMessages:r=>{const e=b._chatMessagesStores.get(r);return e==null?void 0:e.getMessages()}};class J{constructor(e,t){a(this,"messages",[]);a(this,"listeners",[]);a(this,"conversationKey");a(this,"setMessages",e=>{let t;return typeof e=="function"?t=e(this.messages):t=e,this.messages=[...t],this.emitListeners(),!0});a(this,"getMessages",()=>this.messages);a(this,"getMessage",e=>this.messages.find(t=>t.id===e));a(this,"addMessage",e=>this.getMessage(e.id)?!1:(this.setMessages([...this.messages,e]),!0));a(this,"setMessage",(e,t)=>{const s=this.getMessage(e);if(s){const n=typeof t=="function"?t(s):t;return Object.assign(s,n),this.setMessages([...this.messages]),!0}return!1});a(this,"removeMessage",e=>{const t=this.messages.findIndex(s=>s.id===e);return t!==-1?(this.messages.splice(t,1),this.setMessages([...this.messages]),!0):!1});a(this,"getSnapshot",()=>this.messages);a(this,"subscribe",e=>(this.listeners.push(e),()=>{this.listeners=this.listeners.filter(t=>t!==e)}));this.setMessages(e),t!=null&&(this.conversationKey=t,b.set(this.conversationKey,this))}emitListeners(){this.listeners.forEach(e=>{e()})}}function z(r,e){const t=e&&typeof e=="object"&&"value"in e?e:T.shallowRef(e),s=u=>{if(u!==void 0&&b.get(u))return b.get(u);const g=typeof r=="function"?r():r;return new J(g||[],u)},n=T.shallowRef(s(t.value)),o=T.shallowRef(n.value.getMessages());let i=null;const f=()=>{i&&i(),o.value=n.value.getMessages(),i=n.value.subscribe(()=>{o.value=[...n.value.getMessages()]})};return f(),T.watch(()=>t.value,()=>{n.value=s(t.value),f()}),{messages:o,addMessage:u=>n.value.addMessage(u),removeMessage:u=>n.value.removeMessage(u),setMessage:(u,g)=>n.value.setMessage(u,g),getMessage:u=>n.value.getMessage(u),setMessages:u=>n.value.setMessages(u),getMessages:()=>n.value.getMessages()}}function le(r){return Array.isArray(r)?r:[r]}const P=new Map;function fe(r){const{defaultMessages:e,requestFallback:t,requestPlaceholder:s,parser:n,provider:o,conversationKey:i}=r,f=T.ref(0),u=T.shallowRef(void 0),g=T.ref(!1),l=i&&typeof i=="object"&&"value"in i?i:T.shallowRef(i),{messages:m,setMessages:v,getMessages:h,setMessage:A}=z(()=>(e||[]).map((d,c)=>({id:`default_${c}`,status:"local",...d})),l),E=(d,c,R)=>{const _={id:`msg_${f.value}`,message:d,status:c};return R&&(_.extraInfo=R),f.value+=1,_},S=T.computed(()=>{const d=[];return m.value.forEach(c=>{const R=n?n(c.message):c.message,_=le(R);_.forEach((x,j)=>{let K=c.id;_.length>1&&(K=`${K}_${j}`),d.push({id:K,message:x,status:c.status})})}),d}),C=d=>d.filter(c=>c.status!=="loading").map(c=>c.message);o&&(o.injectGetMessages(()=>C(h())),u.value=o.request);const se=()=>C(h()),N=(d,c)=>{if(!o)return;const{updatingId:R,reload:_}=c||{};let x=null;const j=o.transformLocalMessage(d),K=(Array.isArray(j)?j:[j]).map(M=>E(M,"local",c==null?void 0:c.extraInfo));_?(x=R,v(M=>{const p=[...M];if(s){let y;typeof s=="function"?y=s(d,{messages:C(p)}):y=s,p.forEach(w=>{w.id===R&&(w.status="loading",w.message=y,c!=null&&c.extraInfo&&(w.extraInfo=c.extraInfo))})}return p})):v(M=>{let p=[...M,...K];if(s){let y;typeof s=="function"?y=s(d,{messages:C(p)}):y=s;const w=E(y,"loading");x=w.id,p=[...p,w]}return p});let I=null;const B=(M,p,y,w)=>{let q=h().find(O=>O.id===I);if(q)v(O=>O.map(H=>{if(H.id===I){const U=o.transformMessage({originMessage:H.message,chunk:p,chunks:y,status:M,responseHeaders:w});return{...H,message:U,status:M}}return H}));else if(_&&R)q=h().find(O=>O.id===R),q&&(q.status=M,q.message=o.transformMessage({chunk:p,status:M,chunks:y,responseHeaders:w}),v(O=>[...O]),I=q.id);else{const O=o.transformMessage({chunk:p,status:M,chunks:y,responseHeaders:w}),H=E(O,M);v(U=>[...U.filter(ie=>ie.id!==x),H]),I=H.id,q=H}return q};o.injectRequest({onUpdate:(M,p)=>{B("updating",M,[],p)},onSuccess:(M,p)=>{g.value=!1,l.value!==void 0&&l.value!==null&&P.delete(l.value),B("success",void 0,M,p)},onError:async M=>{if(g.value=!1,l.value!==void 0&&l.value!==null&&P.delete(l.value),t){let p;if(typeof t=="function"){const y=se(),w=h().find(q=>q.id===x||q.id===I);p=await t(d,{error:M,messageInfo:w,messages:y})}else p=t;v(y=>[...y.filter(w=>w.id!==x&&w.id!==I),E(p,M.name==="AbortError"?"abort":"error")])}else v(p=>p.map(y=>y.id===x||y.id===I?{...y,status:M.name==="AbortError"?"abort":"error"}:y))}}),g.value=!0,l.value!==void 0&&l.value!==null&&P.set(l.value,!0),o.request.run(o.transformParams(d,o.request.options))},re=(d,c)=>{if(!o)throw new Error("provider is required");N(d,c)},ne=(d,c,R)=>{if(!o)throw new Error("provider is required");if(!d||!h().find(_=>_.id===d))throw new Error(`message [${d}] is not found`);N(c,{updatingId:d,reload:!0,extraInfo:R==null?void 0:R.extraInfo})},oe=T.computed(()=>{const d=l.value;return d!=null?P.get(d)||!1:g.value});return{onRequest:re,messages:m,parsedMessages:S,setMessages:v,setMessage:A,abort:()=>{var d;if(!o)throw new Error("provider is required");(d=u.value)==null||d.abort()},isRequesting:oe,onReload:ne}}class L{constructor(e){a(this,"_request");a(this,"_getMessagesFn");a(this,"_originalCallbacks");var s;const t=typeof e.request=="function"?e.request():e.request;if(!t.manual)throw new Error("request must be manual");this._request=t,this._originalCallbacks=(s=this._request.options)==null?void 0:s.callbacks}get request(){return this._request}getMessages(){return this==null?void 0:this._getMessagesFn()}injectGetMessages(e){this._getMessagesFn=e}injectRequest({onUpdate:e,onSuccess:t,onError:s}){var f,u,g;const n=(f=this._originalCallbacks)==null?void 0:f.onUpdate,o=(u=this._originalCallbacks)==null?void 0:u.onSuccess,i=(g=this._originalCallbacks)==null?void 0:g.onError;this._request.options.callbacks={onUpdate:(l,m)=>{e(l,m),n&&n(l,m)},onSuccess:(l,m)=>{t(l,m),o&&o(l,m)},onError:l=>{s(l),i&&i(l)}}}}class he extends L{transformParams(e,t){return{...(t==null?void 0:t.params)||{},...e,messages:this.getMessages()}}transformLocalMessage(e){return(e==null?void 0:e.messages)||[]}transformMessage(e){var v,h,A,E;const{originMessage:t,chunk:s,chunks:n,responseHeaders:o}=e;let i="",f="",u="assistant";try{let S;(v=o.get("content-type"))!=null&&v.includes("text/event-stream")?s&&((h=s.data)==null?void 0:h.trim())!=="[DONE]"&&(S=JSON.parse(s.data)):S=s||n[0],S&&((A=S==null?void 0:S.choices)==null||A.forEach(C=>{C!=null&&C.delta?(f=C.delta.reasoning_content||"",i+=C.delta.content||"",u=C.delta.role):C!=null&&C.message&&(f=C.message.reasoning_content||"",i+=C.message.content||"",u=C.message.role)}))}catch(S){console.error("transformMessage error",S)}let g="";const l=t;let m=typeof(l==null?void 0:l.content)=="string"?l==null?void 0:l.content:((E=l==null?void 0:l.content)==null?void 0:E.text)||"";return!m&&f?g=`<think>${f}`:m.includes("<think>")&&!m.includes("</think>")&&i?(m=m.replace("<think>",'<think status="done">'),g=`${m}</think>${i}`):g=`${m||""}${f}${i}`,{content:g,role:u||"assistant"}}}class ge extends L{transformParams(e,t){if(typeof e!="object")throw new Error("requestParams must be an object");return{...(t==null?void 0:t.params)||{},...e||{}}}transformLocalMessage(e){return e}transformMessage(e){const{chunk:t,chunks:s,originMessage:n}=e;if(t)return t;if(Array.isArray(s)){const o=(s==null?void 0:s.length)>0?s==null?void 0:s[(s==null?void 0:s.length)-1]:void 0;return n||o}return s}}class W extends L{transformParams(e,t){return{...(t==null?void 0:t.params)||{},...e,messages:this.getMessages()}}transformLocalMessage(e){return(e==null?void 0:e.messages)||[]}transformMessage(e){var g,l,m;const{originMessage:t,chunk:s,chunks:n,responseHeaders:o}=e;let i="",f="assistant";try{let v;(g=o.get("content-type"))!=null&&g.includes("text/event-stream")?s&&((l=s.data)==null?void 0:l.trim())!=="[DONE]"&&(v=JSON.parse(s.data)):v=s||n[0],v&&((m=v==null?void 0:v.choices)==null||m.forEach(h=>{h!=null&&h.delta?(i+=h.delta.content||"",f=h.delta.role||"assistant"):h!=null&&h.message&&(i+=h.message.content||"",f=h.message.role||"assistant")}))}catch(v){console.error("transformMessage error",v)}return{content:`${(t==null?void 0:t.content)||""}${i||""}`,role:f}}}const de=`
+
+`,me=`
+`,G=":",$=r=>(r??"").trim()!=="";function ce(){let r="";return new TransformStream({transform(e,t){r+=e;const s=r.split(de);s.slice(0,-1).forEach(n=>{$(n)&&t.enqueue(n)}),r=s[s.length-1]},flush(e){$(r)&&e.enqueue(r)}})}function ve(){return new TransformStream({transform(r,e){const s=r.split(me).reduce((n,o)=>{const i=o.indexOf(G);if(i===-1)throw new Error(`The key-value separator "${G}" is not found in the sse line chunk!`);const f=o.slice(0,i);if(!$(f))return n;const u=o.slice(i+1);return{...n,[f]:u}},{});Object.keys(s).length!==0&&e.enqueue(s)}})}function D(r){const{readableStream:e,transformStream:t}=r;if(!(e instanceof ReadableStream))throw new Error("The options.readableStream must be an instance of ReadableStream.");const s=new TextDecoderStream,n=t?e.pipeThrough(s).pipeThrough(t):e.pipeThrough(s).pipeThrough(ce()).pipeThrough(ve());return n[Symbol.asyncIterator]=async function*(){const o=this.getReader();for(;;){const{done:i,value:f}=await o.read();if(i)break;f&&(yield f)}},n}const pe=async(r,e)=>{const{fetch:t=globalThis.fetch,middlewares:s={},...n}=e;if(typeof t!="function")throw new Error("The options.fetch must be a typeof fetch function!");let o=[r,n];typeof s.onRequest=="function"&&(o=await s.onRequest(...o));let i=await t(...o);if(typeof s.onResponse=="function"){const f=await s.onResponse(i);if(!(f instanceof Response))throw new Error("The options.onResponse must return a Response instance!");i=f}if(!i.ok)throw new Error(`Fetch failed with status ${i.status}`);if(!i.body)throw new Error("The response body is empty.");return i},Q={manual:!1,headers:{"Content-Type":"application/json"}};function Me(r){Object.assign(Q,r)}class V{constructor(e,t){a(this,"baseURL");a(this,"options");if(!e||typeof e!="string")throw new Error("The baseURL is not valid!");this.baseURL=e,this.options=t||{}}}class Y extends V{constructor(t,s){super(t,s);a(this,"_asyncHandler");a(this,"timeoutHandler",0);a(this,"_isTimeout",!1);a(this,"streamTimeoutHandler",0);a(this,"_isStreamTimeout",!1);a(this,"abortController");a(this,"_isRequesting",!1);a(this,"_manual",!1);a(this,"customResponseHandler",async(t,s,n,o)=>{const i=D({readableStream:t.body,transformStream:n});await this.processStream(i,t,s,o)});a(this,"sseResponseHandler",async(t,s,n)=>{const o=D({readableStream:t.body});await this.processStream(o,t,s,n)});a(this,"jsonResponseHandler",async(t,s)=>{var o,i,f;const n=await t.json();if((n==null?void 0:n.success)===!1){const u=n,g=new Error(u.message||"System error");g.name=u.name||"SystemError",(o=s==null?void 0:s.onError)==null||o.call(s,g)}else(i=s==null?void 0:s.onUpdate)==null||i.call(s,n,t.headers),this.finishRequest(),(f=s==null?void 0:s.onSuccess)==null||f.call(s,[n],t.headers)});this._manual=(s==null?void 0:s.manual)||!1,this.manual||this.init()}get asyncHandler(){return this._asyncHandler}get isTimeout(){return this._isTimeout}set isTimeout(t){this._isTimeout=t}get isStreamTimeout(){return this._isStreamTimeout}set isStreamTimeout(t){this._isStreamTimeout=t}get isRequesting(){return this._isRequesting}get manual(){return this._manual}run(t){this.manual?this.init(t):console.warn("The request is not manual, so it cannot be run!")}abort(){var t;clearTimeout(this.timeoutHandler),clearTimeout(this.streamTimeoutHandler),(t=this.abortController)==null||t.abort()}init(t){this.abortController=new AbortController;const{callbacks:s,params:n,headers:o={},transformStream:i,fetch:f,timeout:u,streamTimeout:g,middlewares:l,...m}=this.options,v={...m,method:m.method||"POST",body:m.body??JSON.stringify({...n,...t||{}}),params:{...n,...t},headers:Object.assign({},Q.headers||{},o),signal:this.abortController.signal,middlewares:l};u&&u>0&&(this.timeoutHandler=setTimeout(()=>{var h;this.isTimeout=!0,this.finishRequest(),(h=s==null?void 0:s.onError)==null||h.call(s,new Error("TimeoutError"))},u)),this.startRequest(),this._asyncHandler=pe(this.baseURL,{fetch:f,...v}).then(async h=>{if(clearTimeout(this.timeoutHandler),this.isTimeout)return;if(i){let S=i;typeof i=="function"&&(S=i(this.baseURL,h.headers)),await this.customResponseHandler(h,s,S,g);return}const A=h.headers.get("content-type")||"";switch(A.split(";")[0].trim()){case"text/event-stream":await this.sseResponseHandler(h,s,g);break;case"application/json":await this.jsonResponseHandler(h,s);break;default:throw new Error(`The response content-type: ${A} is not support!`)}}).catch(h=>{var E;clearTimeout(this.timeoutHandler),this.finishRequest();const A=h instanceof Error||typeof DOMException<"u"&&h instanceof DOMException?h:new Error("Unknown error!");(E=s==null?void 0:s.onError)==null||E.call(s,A)})}startRequest(){this._isRequesting=!0}finishRequest(){this._isRequesting=!1}async processStream(t,s,n,o){var g,l;const i=[],f=t[Symbol.asyncIterator]();let u;do if(o&&(this.streamTimeoutHandler=setTimeout(()=>{var m;this.isStreamTimeout=!0,this.finishRequest(),(m=n==null?void 0:n.onError)==null||m.call(n,new Error("StreamTimeoutError"))},o)),u=await f.next(),u.value!==void 0&&(i.push(u.value),(g=n==null?void 0:n.onUpdate)==null||g.call(n,u.value,s.headers)),clearTimeout(this.streamTimeoutHandler),this.isStreamTimeout)break;while(!u.done);if(o&&(clearTimeout(this.streamTimeoutHandler),this.isStreamTimeout)){this.finishRequest();return}this.finishRequest(),(l=n==null?void 0:n.onSuccess)==null||l.call(n,i,s.headers)}}function F(r,e){return new Y(r,e)}function Z(r){const e=r.dangerouslyApiKey||r.key;if(e)return/^(Bearer |Basic |Tbox-)/.test(e)?e:`Bearer ${e}`}function ye(r){const e=Z(r);return new W({request:F(r.baseURL,{manual:!0,params:{...r.model?{model:r.model}:{},stream:!0},headers:e?{Authorization:e}:{},...r.fetch?{fetch:r.fetch}:{}})})}const X={_allConversationStores:new Map,set(r,e){X._allConversationStores.set(r,e)},delete(r){X._allConversationStores.delete(r)},getConversation(r){for(const e of Array.from(X._allConversationStores.values())){const t=e.getConversation(r);if(t)return t}}};class k{constructor(e,t){a(this,"conversations",[]);a(this,"listeners",[]);a(this,"storeKey");a(this,"activeConversationKey");a(this,"setActiveConversationKey",e=>(this.activeConversationKey=e,this.emitListeners(),!0));a(this,"setConversations",e=>(this.conversations=[...e],this.emitListeners(),!0));a(this,"getConversation",e=>this.conversations.find(t=>t.key===e));a(this,"addConversation",(e,t)=>this.getConversation(e.key)?!1:(this.setConversations(t==="prepend"?[e,...this.conversations]:[...this.conversations,e]),!0));a(this,"setConversation",(e,t)=>{const s=this.getConversation(e);return s?(Object.assign(s,t),this.setConversations([...this.conversations]),!0):!1});a(this,"removeConversation",e=>{const t=this.conversations.findIndex(s=>s.key===e);return t!==-1?(this.conversations.splice(t,1),this.setConversations([...this.conversations]),!0):!1});a(this,"getMessages",e=>b.getMessages(e));a(this,"getSnapshot",()=>this.conversations);a(this,"getActiveConversationKey",()=>this.activeConversationKey);a(this,"subscribe",e=>(this.listeners.push(e),()=>{this.listeners=this.listeners.filter(t=>t!==e)}));a(this,"destroy",()=>{X.delete(this.storeKey)});this.conversations=[...e],this.storeKey=Math.random().toString(),X.set(this.storeKey,this),this.activeConversationKey=t}emitListeners(){for(const e of this.listeners)e()}}function Ce(r={}){const e=new k(r.defaultConversations||[],r.defaultActiveConversationKey||""),t=T.shallowRef(e.getSnapshot()),s=T.shallowRef(e.getActiveConversationKey()),n=e.subscribe(()=>{t.value=[...e.getSnapshot()],s.value=e.getActiveConversationKey()});return T.onBeforeUnmount(()=>{n(),e.destroy()}),{conversations:t,activeConversationKey:s,setActiveConversationKey:e.setActiveConversationKey,addConversation:e.addConversation,removeConversation:e.removeConversation,setConversation:e.setConversation,getConversation:e.getConversation,setConversations:e.setConversations,getMessages:e.getMessages}}class ee{constructor(e,t){a(this,"baseURL");a(this,"options");if(!e||typeof e!="string")throw new Error("The baseURL is not valid!");this.baseURL=e,this.options=t}async tools(){return new Promise((e,t)=>{F(this.baseURL,{...this.options||{},callbacks:{onSuccess(s){e((s==null?void 0:s[0])||[])},onError(s){t(s)}}})})}}function te(r,e){return new ee(r,e)}const we=te,Se="2.0.0";exports.AbstractChatProvider=L;exports.AbstractXRequestClass=V;exports.ChatMessagesStore=J;exports.ConversationStore=k;exports.DeepSeekChatProvider=he;exports.DefaultChatProvider=ge;exports.OpenAIChatProvider=W;exports.XMCPClient=te;exports.XMCPClientClass=ee;exports.XMcpClient=we;exports.XRequest=F;exports.XRequestClass=Y;exports.XStream=D;exports.chatMessagesStoreHelper=b;exports.conversationStoreHelper=X;exports.createOpenAIChatProvider=ye;exports.resolvePresetApiKey=Z;exports.setXRequestGlobalOptions=Me;exports.useChatStore=z;exports.useXChat=fe;exports.useXConversations=Ce;exports.version=Se;