@mujian/js-sdk 0.0.6-beta.1

package/dist/react.js

@@ -0,0 +1,832 @@
+import { useMount, useRequest, useUpdateEffect } from "ahooks";
+import react, { createContext, forwardRef, useCallback, useContext, useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import css_tools from "@adobe/css-tools";
+import dompurify from "dompurify";
+import showdown from "showdown";
+import postmate from "postmate";
+import { Virtualizer } from "virtua";
+addDOMPurifyHooks();
+function canUseNegativeLookbehind() {
+    try {
+        new RegExp('(?<!_)');
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function addDOMPurifyHooks() {
+    dompurify.addHook('afterSanitizeAttributes', function(node) {
+        if ('target' in node) {
+            node.setAttribute('target', '_blank');
+            node.setAttribute('rel', 'noopener');
+        }
+    });
+    dompurify.addHook('uponSanitizeAttribute', (node, data, config)=>{
+        if (!config['MESSAGE_SANITIZE']) return;
+        const permittedNodeTypes = [
+            'BUTTON',
+            'DIV'
+        ];
+        if (config['MESSAGE_ALLOW_SYSTEM_UI'] && node.classList.contains('menu_button') && permittedNodeTypes.includes(node.nodeName)) return;
+        switch(data.attrName){
+            case 'class':
+                if (data.attrValue) data.attrValue = data.attrValue.split(' ').map((v)=>{
+                    if (v.startsWith('fa-') || v.startsWith('note-') || 'monospace' === v) return v;
+                    return 'custom-' + v;
+                }).join(' ');
+                break;
+        }
+    });
+    dompurify.addHook('uponSanitizeElement', (node, _, config)=>{
+        if (!config['MESSAGE_SANITIZE']) return;
+        if (node instanceof HTMLUnknownElement) node.innerHTML = node.innerHTML.trim().replaceAll('\n', '<br>');
+        const isMediaAllowed = true;
+        if (isMediaAllowed) return;
+        if (!(node instanceof Element)) return;
+        let mediaBlocked = false;
+        switch(node.tagName){
+            case 'AUDIO':
+            case 'VIDEO':
+            case 'SOURCE':
+            case 'TRACK':
+            case 'EMBED':
+            case 'OBJECT':
+            case 'IMG':
+                {
+                    const isExternalUrl = (url)=>(url.indexOf('://') > 0 || 0 === url.indexOf('//')) && !url.startsWith(window.location.origin);
+                    const src = node.getAttribute('src');
+                    const data = node.getAttribute('data');
+                    const srcset = node.getAttribute('srcset');
+                    if (srcset) {
+                        const srcsetUrls = srcset.split(',');
+                        for (const srcsetUrl of srcsetUrls){
+                            const [url] = srcsetUrl.trim().split(' ');
+                            if (isExternalUrl(url)) {
+                                console.warn('External media blocked', url);
+                                node.remove();
+                                mediaBlocked = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (src && isExternalUrl(src)) {
+                        console.warn('External media blocked', src);
+                        mediaBlocked = true;
+                        node.remove();
+                    }
+                    if (data && isExternalUrl(data)) {
+                        console.warn('External media blocked', data);
+                        mediaBlocked = true;
+                        node.remove();
+                    }
+                    if (mediaBlocked && node instanceof HTMLMediaElement) {
+                        node.autoplay = false;
+                        node.pause();
+                    }
+                }
+                break;
+        }
+    });
+}
+/**
+ * Replaces style tags in the message text with custom tags with encoded content.
+ * @param {string} text
+ * @returns {string} Encoded message text
+ * @copyright https://github.com/kwaroran/risuAI
+ */ function encodeStyleTags(text) {
+    const styleRegex = /<style>(.+?)<\/style>/gi;
+    return text.replaceAll(styleRegex, (_, match)=>`<custom-style>${encodeURIComponent(match)}</custom-style>`);
+}
+/**
+ * Sanitizes custom style tags in the message text to prevent DOM pollution.
+ * @param {string} text Message text
+ * @param {object} options Options object
+ * @param {string} options.prefix Prefix the selectors with this value
+ * @returns {string} Sanitized message text
+ * @copyright https://github.com/kwaroran/risuAI
+ */ function decodeStyleTags(text, { prefix } = {
+    prefix: '.mes_text '
+}) {
+    const styleDecodeRegex = /<custom-style>(.+?)<\/custom-style>/g;
+    function sanitizeRule(rule) {
+        if (Array.isArray(rule.selectors)) for(let i = 0; i < rule.selectors.length; i++){
+            const selector = rule.selectors[i];
+            if (selector) rule.selectors[i] = prefix + sanitizeSelector(selector);
+        }
+    }
+    function sanitizeSelector(selector) {
+        const pseudoClasses = [
+            'has',
+            'not',
+            'where',
+            'is',
+            'matches',
+            'any'
+        ];
+        const pseudoRegex = new RegExp(`:(${pseudoClasses.join('|')})\\(([^)]+)\\)`, 'g');
+        selector = selector.replace(pseudoRegex, (_match, pseudoClass, content)=>{
+            const sanitizedContent = sanitizeSimpleSelector(content);
+            return `:${pseudoClass}(${sanitizedContent})`;
+        });
+        return sanitizeSimpleSelector(selector);
+    }
+    function sanitizeSimpleSelector(selector) {
+        return selector.split(/\s+/).map((part)=>part.replace(/\.([\w-]+)/g, (match, className)=>{
+                if (className.startsWith('custom-')) return match;
+                return `.custom-${className}`;
+            })).join(' ');
+    }
+    function sanitizeRuleSet(ruleSet) {
+        if (Array.isArray(ruleSet.selectors) || Array.isArray(ruleSet.declarations)) sanitizeRule(ruleSet);
+        if (Array.isArray(ruleSet.rules)) {
+            ruleSet.rules = ruleSet.rules.filter((rule)=>'import' !== rule.type);
+            for (const mediaRule of ruleSet.rules)sanitizeRuleSet(mediaRule);
+        }
+    }
+    return text.replaceAll(styleDecodeRegex, (_, style)=>{
+        try {
+            const styleCleaned = decodeURIComponent(style).replaceAll(/<br\/>/g, '');
+            const ast = css_tools.parse(styleCleaned);
+            const sheet = ast?.stylesheet;
+            if (sheet) sanitizeRuleSet(ast.stylesheet);
+            return `<style>${css_tools.stringify(ast)}</style>`;
+        } catch (error) {
+            return `CSS ERROR: ${error}`;
+        }
+    });
+}
+const markdownUnderscoreExt = ()=>{
+    try {
+        if (!canUseNegativeLookbehind()) {
+            console.log('Showdown-underscore extension: Negative lookbehind not supported. Skipping.');
+            return [];
+        }
+        return [
+            {
+                type: 'output',
+                regex: new RegExp('(<code(?:\\s+[^>]*)?>[\\s\\S]*?<\\/code>|<style(?:\\s+[^>]*)?>[\\s\\S]*?<\\/style>)|\\b(?<!_)_(?!_)(.*?)(?<!_)_(?!_)\\b', 'gi'),
+                replace: function(match, tagContent, italicContent) {
+                    if (tagContent) ;
+                    else if (italicContent) return '<em>' + italicContent + '</em>';
+                    return match;
+                }
+            }
+        ];
+    } catch (e) {
+        console.error('Error in Showdown-underscore extension:', e);
+        return [];
+    }
+};
+const converter = new showdown.Converter({
+    emoji: true,
+    literalMidWordUnderscores: true,
+    parseImgDimensions: true,
+    tables: true,
+    underline: true,
+    simpleLineBreaks: true,
+    strikethrough: true,
+    disableForced4SpacesIndentedSublists: true,
+    extensions: [
+        markdownUnderscoreExt()
+    ]
+});
+function messageFormatting(mes, sanitizerOverrides = {}) {
+    if (!mes) return '';
+    mes = mes.replace(/<([^>]+)>/g, function(_, contents) {
+        return '<' + contents.replace(/"/g, '\ufffe') + '>';
+    });
+    mes = mes.replace(/<style>[\s\S]*?<\/style>|```[\s\S]*?```|~~~[\s\S]*?~~~|``[\s\S]*?``|`[\s\S]*?`|(".*?")|(\u201C.*?\u201D)|(\u00AB.*?\u00BB)|(\u300C.*?\u300D)|(\u300E.*?\u300F)|(\uFF02.*?\uFF02)/gim, function(match, p1, p2, p3, p4, p5, p6) {
+        if (p1) return `<q>"${p1.slice(1, -1)}"</q>`;
+        if (p2) return `<q>“${p2.slice(1, -1)}”</q>`;
+        if (p3) return `<q>«${p3.slice(1, -1)}»</q>`;
+        if (p4) return `<q>「${p4.slice(1, -1)}」</q>`;
+        if (p5) return `<q>『${p5.slice(1, -1)}』</q>`;
+        else if (p6) return `<q>＂${p6.slice(1, -1)}＂</q>`;
+        else return match;
+    });
+    mes = mes.replace(/\ufffe/g, '"');
+    mes = mes.replaceAll('\\begin{align*}', '$$');
+    mes = mes.replaceAll('\\end{align*}', '$$');
+    mes = converter.makeHtml(mes);
+    mes = mes.replace(/<code(.*)>[\s\S]*?<\/code>/g, function(match) {
+        return match.replace(/\n/gm, '\u0000');
+    });
+    mes = mes.replace(/\u0000/g, '\n');
+    mes = mes.trim();
+    mes = mes.replace(/<code(.*)>[\s\S]*?<\/code>/g, function(match) {
+        return match.replace(/&amp;/g, '&');
+    });
+    const config = {
+        RETURN_DOM: false,
+        RETURN_DOM_FRAGMENT: false,
+        RETURN_TRUSTED_TYPE: false,
+        MESSAGE_SANITIZE: true,
+        ADD_TAGS: [
+            'custom-style'
+        ],
+        ...sanitizerOverrides
+    };
+    mes = encodeStyleTags(mes);
+    mes = dompurify.sanitize(mes, config);
+    mes = decodeStyleTags(mes, {
+        prefix: '.mes_text '
+    });
+    return mes;
+}
+const MdRendererBase = ({ content })=>{
+    const mes = messageFormatting(content);
+    return /*#__PURE__*/ jsx("div", {
+        className: "mes_text",
+        dangerouslySetInnerHTML: {
+            __html: mes
+        }
+    });
+};
+const MdRenderer = /*#__PURE__*/ react.memo(MdRendererBase, (prev, next)=>prev.content === next.content);
+MdRendererBase.displayName = 'MdRenderer';
+MdRenderer.displayName = 'MdRenderer';
+const chat_complete = async function(message, onData, signal) {
+    return await this.call("mujian:ai:chat:complete", {
+        content: message
+    }, {
+        onData,
+        signal
+    });
+};
+const applyRegex = async function(props) {
+    return await this.call("mujian:ai:chat:applyRegex", props);
+};
+const continueComplete = async function(onData, signal) {
+    return await this.call("mujian:ai:chat:complete", {
+        isContinue: true
+    }, {
+        onData,
+        signal
+    });
+};
+const chat_regenerate = async function(onData, signal) {
+    return await this.call("mujian:ai:chat:complete", {
+        isRegenerate: true
+    }, {
+        onData,
+        signal
+    });
+};
+const getAll = async function() {
+    return await this.call("mujian:ai:chat:message:getAll");
+};
+const messageDeleteOne = async function(messageId) {
+    return await this.call("mujian:ai:chat:message:deleteOne", {
+        messageId
+    });
+};
+const messageEditOne = async function(messageId, content) {
+    return await this.call("mujian:ai:chat:message:editOne", {
+        messageId,
+        content
+    });
+};
+const messageSwipe = async function(messageId, swipeId) {
+    return await this.call("mujian:ai:chat:message:swipe", {
+        messageId,
+        swipeId
+    });
+};
+const getPrompt = async function(messageId) {
+    return await this.call("mujian:ai:chat:message:getPrompt", {
+        messageId
+    });
+};
+const getInfo = async function() {
+    return await this.call("mujian:ai:chat:project:getInfo");
+};
+const getActive = async function() {
+    return await this.call("mujian:ai:settings:persona:getActive");
+};
+const setActive = async function(personaId) {
+    return await this.call("mujian:ai:settings:persona:setActive", {
+        personaId
+    });
+};
+const model_getActive = async function() {
+    return await this.call("mujian:ai:settings:model:getActive");
+};
+const model_setActive = async function(modelId) {
+    return await this.call("mujian:ai:settings:model:setActive", {
+        modelId
+    });
+};
+const model_getAll = async function() {
+    return await this.call("mujian:ai:settings:model:getAll");
+};
+const generate = async function() {
+    return await this.call("mujian:ai:text:generate", {
+        content: 'q'
+    });
+};
+const saveGame = async function() {};
+const loadGame = async function() {};
+class MujianSdk {
+    constructor(){}
+    static getInstance() {
+        if (!window.$mujian) window.$mujian = new MujianSdk();
+        return window.$mujian;
+    }
+    parent = null;
+    ready = false;
+    get isReady() {
+        return this.ready;
+    }
+    pendingRequests = new Map();
+    async init() {
+        const handshake = new postmate.Model({
+            reply: ({ id, complete, data })=>{
+                const call = this.pendingRequests.get(id);
+                if (!call) return;
+                call.onData?.(data);
+                if (complete) {
+                    call.onComplete?.();
+                    call.resolve(data);
+                    this.pendingRequests.delete(id);
+                }
+            }
+        });
+        try {
+            const parent = await handshake;
+            this.ready = true;
+            this.parent = parent;
+            console.log('mujian sdk client init');
+            await this.call("mujian:init");
+        } catch (error) {
+            console.log('init error', error);
+        }
+    }
+    emit(event, data) {
+        if (!this.ready) throw new Error('Mujian is not initialized');
+        this.parent?.emit(event, data);
+    }
+    nextCallId = 0;
+    getCallId() {
+        const id = this.nextCallId;
+        this.nextCallId += 1;
+        return id;
+    }
+    async call(event, data, controller) {
+        if (!this.ready) throw new Error('Mujian is not initialized');
+        const callId = this.getCallId();
+        return new Promise((resolve, reject)=>{
+            this.pendingRequests.set(callId, {
+                resolve,
+                reject,
+                ...controller
+            });
+            this.emit(event, {
+                id: callId,
+                data
+            });
+            controller?.signal?.addEventListener('abort', ()=>{
+                this.emit("mujian:ai:chat:stop", {
+                    id: callId
+                });
+            });
+        });
+    }
+    ai = {
+        chat: {
+            project: {
+                getInfo: getInfo.bind(this)
+            },
+            settings: {
+                model: {
+                    getAll: model_getAll.bind(this),
+                    getActive: model_getActive.bind(this),
+                    setActive: model_setActive.bind(this)
+                },
+                persona: {
+                    getActive: getActive.bind(this),
+                    setActive: setActive.bind(this)
+                }
+            },
+            complete: chat_complete.bind(this),
+            applyRegex: applyRegex.bind(this),
+            continue: continueComplete.bind(this),
+            regenerate: chat_regenerate.bind(this),
+            message: {
+                getAll: getAll.bind(this),
+                deleteOne: messageDeleteOne.bind(this),
+                editOne: messageEditOne.bind(this),
+                swipe: messageSwipe.bind(this),
+                getPrompt: getPrompt.bind(this)
+            }
+        },
+        text: {
+            complete: generate.bind(this)
+        }
+    };
+    ui = {};
+    util = {
+        cn: ()=>{
+            console.log('cn');
+        }
+    };
+    hybrid = {};
+    player = {};
+    game = {
+        assets: ()=>{
+            console.log('assets');
+        },
+        saves: {
+            saveGame: saveGame.bind(this),
+            loadGame: loadGame.bind(this)
+        },
+        ranking: ()=>{
+            console.log('ranking');
+        }
+    };
+}
+const MujianContext = /*#__PURE__*/ createContext(null);
+const MujianProvider = ({ children, loadingComponent })=>{
+    const [mujian, setMujian] = useState(null);
+    useEffect(()=>{
+        (async ()=>{
+            const mujian = MujianSdk.getInstance();
+            await mujian.init();
+            setMujian(mujian);
+        })();
+    }, []);
+    return /*#__PURE__*/ jsx(MujianContext.Provider, {
+        value: mujian,
+        children: mujian ? children : loadingComponent ?? 'Mujian is loading'
+    });
+};
+const useMujian = ()=>{
+    const mujian = useContext(MujianContext);
+    if (!mujian) {
+        const message = 'Mujian is not initialized. Please check that useMujian is called inside MujianProvider';
+        console.error(message);
+        throw new Error(message);
+    }
+    return mujian;
+};
+const MessageItem = (props)=>{
+    const { message, children, depth, index } = props;
+    const mujian = useMujian();
+    const { data: renderedMessage } = useRequest(async ()=>{
+        const { isStreaming } = message;
+        if (isStreaming) return message;
+        return await mujian.ai.chat.applyRegex({
+            message,
+            depth,
+            index
+        });
+    }, {
+        refreshDeps: [
+            message
+        ]
+    });
+    return children(renderedMessage || message, message);
+};
+const MessageList = /*#__PURE__*/ forwardRef((props, ref)=>{
+    const { children, messages, vListProps } = props;
+    return /*#__PURE__*/ jsx(Virtualizer, {
+        ...vListProps,
+        data: messages,
+        ref: ref,
+        children: (msg, i)=>children({
+                message: msg,
+                index: i,
+                depth: messages.length - 1 - i
+            })
+    });
+});
+const Thread = {
+    MessageItem: MessageItem,
+    MessageList: MessageList
+};
+class SendMessageError extends Error {
+    constructor(message, cause){
+        super(message);
+        this.name = this.constructor.name;
+        this.cause = cause;
+    }
+}
+class InvalidDeltaContentError extends Error {
+    constructor(message, cause){
+        super(message);
+        this.name = this.constructor.name;
+        this.cause = cause;
+    }
+}
+class UnexpectedSseEndingError extends Error {
+    constructor(message, cause){
+        super(message);
+        this.name = this.constructor.name;
+        this.cause = cause;
+    }
+}
+class InsufficientBalanceError extends Error {
+    constructor(message, cause){
+        super(message);
+        this.name = this.constructor.name;
+        this.cause = cause;
+    }
+}
+async function* callSdk(mujian, content, type = 'generate', signal) {
+    const queue = [];
+    let resolveWait = null;
+    let done = false;
+    let error = null;
+    try {
+        const onData = (data)=>{
+            if (error) return;
+            queue.push(data);
+            if (resolveWait) {
+                resolveWait();
+                resolveWait = null;
+            }
+        };
+        const then = ()=>{
+            done = true;
+            if (resolveWait) {
+                resolveWait();
+                resolveWait = null;
+            }
+        };
+        const catcher = (e)=>{
+            error = e;
+            if (resolveWait) {
+                resolveWait();
+                resolveWait = null;
+            }
+        };
+        if ('generate' === type) mujian.ai.chat.complete(content, onData, signal).then(then).catch(catcher);
+        else if ('regenerate' === type) mujian.ai.chat.regenerate(onData, signal).then(then).catch(catcher);
+        else mujian.ai.chat.continue(onData, signal).then(then).catch(catcher);
+    } catch (err) {
+        error = err;
+        done = true;
+    }
+    while(true)if (queue.length > 0) yield queue.shift();
+    else if (done) break;
+    else if (error) throw error;
+    else await new Promise((resolve)=>{
+        resolveWait = resolve;
+    });
+}
+const useChatStreaming = ({ common, setError, setMessages, mujian })=>{
+    const { body } = common;
+    const [isStreaming, setIsStreaming] = useState(false);
+    const chatStreaming = useCallback(async ({ query, regenerate, is_continue, signal })=>{
+        try {
+            setError(void 0);
+            setIsStreaming(true);
+            const userMessage = {
+                id: Date.now().toString(),
+                content: query || '',
+                role: 'user',
+                swipes: [],
+                activeSwipeId: 0,
+                isStreaming: false,
+                sendAt: new Date()
+            };
+            const aiMessage = {
+                id: Date.now().toString() + '1',
+                content: '',
+                role: 'assistant',
+                swipes: [],
+                activeSwipeId: 0,
+                isStreaming: true,
+                sendAt: new Date()
+            };
+            if (regenerate) setMessages((prev)=>{
+                const newMessages = [
+                    ...prev
+                ];
+                const lastMessage = newMessages[newMessages.length - 1];
+                newMessages[newMessages.length - 1] = {
+                    ...lastMessage,
+                    activeSwipeId: lastMessage.swipes.length,
+                    swipes: [
+                        ...lastMessage.swipes,
+                        ''
+                    ],
+                    content: '',
+                    isStreaming: true
+                };
+                return newMessages;
+            });
+            else is_continue ? setMessages((prev)=>[
+                    ...prev,
+                    aiMessage
+                ]) : setMessages((prev)=>[
+                    ...prev,
+                    userMessage,
+                    aiMessage
+                ]);
+            const stream = callSdk(mujian, query || '', is_continue ? 'continue' : regenerate ? 'regenerate' : 'generate', signal);
+            let buffer = '';
+            let content = '';
+            try {
+                for await (const chunk of stream){
+                    buffer += chunk;
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines)if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        try {
+                            const parsedData = JSON.parse(data);
+                            if (!regenerate && parsedData.question_id) {
+                                const { question_id, reply_id } = parsedData;
+                                setMessages((prev)=>{
+                                    const newMessages = [
+                                        ...prev
+                                    ];
+                                    if (question_id && !is_continue) newMessages[newMessages.length - 2].id = question_id;
+                                    const lastMessage = newMessages[newMessages.length - 1];
+                                    newMessages[newMessages.length - 1] = {
+                                        ...lastMessage,
+                                        id: reply_id
+                                    };
+                                    return newMessages;
+                                });
+                                continue;
+                            }
+                            if (!parsedData.choices?.[0]) continue;
+                            const partialContent = parsedData.choices[0].delta.content;
+                            parsedData.choices[0].delta.reasoning;
+                            content += partialContent;
+                            if (content || '' === content) {
+                                setMessages((prev)=>{
+                                    const newMessages = [
+                                        ...prev
+                                    ];
+                                    const lastMessage = newMessages[newMessages.length - 1];
+                                    lastMessage.swipes[lastMessage.activeSwipeId] = content;
+                                    newMessages[newMessages.length - 1] = {
+                                        ...lastMessage,
+                                        content: content,
+                                        isStreaming: true
+                                    };
+                                    return newMessages;
+                                });
+                                await new Promise((resolve)=>setTimeout(resolve, 10));
+                            } else {
+                                console.error('data', data);
+                                setError(new InvalidDeltaContentError(data));
+                            }
+                        } catch  {
+                            if ('[DONE]' !== data) {
+                                console.error('Received plain SSE message:', data);
+                                setError(new UnexpectedSseEndingError(data));
+                            }
+                        }
+                    }
+                }
+            } finally{
+                console.log('stream end finally');
+                setMessages((prev)=>{
+                    const newMessages = [
+                        ...prev
+                    ];
+                    newMessages[newMessages.length - 1] = {
+                        ...newMessages[newMessages.length - 1],
+                        isStreaming: false
+                    };
+                    return newMessages;
+                });
+            }
+        } catch (error) {
+            console.error('Error:', error);
+            error instanceof Error && JSON.parse(error.message || '{}')?.code === 111 ? setError(new InsufficientBalanceError()) : setError(new SendMessageError('Send message failed', error));
+            setMessages((prev)=>prev.slice(0, -1));
+        } finally{
+            setIsStreaming(false);
+        }
+    }, [
+        body,
+        mujian
+    ]);
+    return {
+        chatStreaming,
+        isStreaming
+    };
+};
+const useChat = ({ body, onError, onFinish })=>{
+    const [error, _setError] = useState();
+    const [messages, setMessages] = useState([]);
+    const [input, setInput] = useState('');
+    const [abortController, setAbortController] = useState();
+    const mujian = useMujian();
+    const setError = (error)=>{
+        _setError(error);
+        if (error) onError?.(error);
+    };
+    const { chatStreaming, isStreaming } = useChatStreaming({
+        common: {
+            body
+        },
+        setError,
+        setMessages,
+        mujian
+    });
+    useMount(async ()=>{
+        const resp = await mujian.ai.chat.message.getAll();
+        setMessages(resp);
+    });
+    useUpdateEffect(()=>{
+        if (!isStreaming) {
+            const lastMessage = messages[messages.length - 1];
+            onFinish?.(lastMessage);
+        }
+    }, [
+        isStreaming
+    ]);
+    const append = async (query)=>{
+        if (isStreaming) throw new Error('useChat is streaming already.');
+        const controller = new AbortController();
+        setAbortController(controller);
+        await chatStreaming({
+            query,
+            signal: controller.signal
+        });
+        setAbortController(void 0);
+    };
+    const regenerate = async ()=>{
+        if (isStreaming) throw new Error('useChat is streaming already.');
+        const controller = new AbortController();
+        setAbortController(controller);
+        const lastMessage = messages.findLast((message)=>'user' === message.role);
+        await chatStreaming({
+            query: lastMessage?.content || '',
+            regenerate: true,
+            signal: controller.signal
+        });
+        setAbortController(void 0);
+    };
+    const continueGenerate = async ()=>{
+        if (isStreaming) throw new Error('useChat is streaming already.');
+        const controller = new AbortController();
+        setAbortController(controller);
+        await chatStreaming({
+            query: '',
+            is_continue: true,
+            signal: controller.signal
+        });
+        setAbortController(void 0);
+    };
+    const stop = ()=>{
+        abortController?.abort();
+    };
+    const setSwipe = async (messageId, swipeId)=>{
+        await mujian.ai.chat.message.swipe(messageId, swipeId);
+        setMessages((prev)=>prev.map((msg)=>msg.id === messageId ? {
+                    ...msg,
+                    activeSwipeId: swipeId
+                } : msg));
+    };
+    const editMessage = async (messageId, content)=>{
+        await mujian.ai.chat.message.editOne(messageId, content);
+        const patchMessage = (msg)=>{
+            const newMsg = {
+                ...msg,
+                content
+            };
+            if ('assistant' === newMsg.role) {
+                newMsg.swipes = [
+                    ...newMsg.swipes
+                ];
+                newMsg.swipes[newMsg.activeSwipeId] = content;
+            }
+            return newMsg;
+        };
+        setMessages((prev)=>prev.map((msg)=>msg.id === messageId ? patchMessage(msg) : msg));
+    };
+    const deleteMessage = async (messageId)=>{
+        await mujian.ai.chat.message.deleteOne(messageId);
+        setMessages((prev)=>prev.filter((msg)=>msg.id !== messageId));
+    };
+    return {
+        append,
+        regenerate,
+        continueGenerate,
+        stop,
+        messages: messages,
+        status: (()=>{
+            if (error) return 'error';
+            if (isStreaming) return 'streaming';
+            return 'ready';
+        })(),
+        error,
+        setMessages: setMessages,
+        input,
+        setInput,
+        handleSubmit: ()=>{
+            append(input);
+        },
+        setSwipe,
+        editMessage,
+        deleteMessage
+    };
+};
+export { MdRenderer, MujianProvider, Thread, useChat, useMujian };