@mujian/js-sdk 0.0.6-beta.mjv.68 → 0.1.0-beta.1

package/dist/react.js

@@ -1,4 +1,4 @@
-import { useInfiniteScroll, useLatest, useRequest, useUpdateEffect } from "ahooks";
+import { useInfiniteScroll, useLatest, useRequest, useUnmount, useUpdateEffect } from "ahooks";
 import react, { createContext, forwardRef, useCallback, useContext, useEffect, useRef, useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import css_tools from "@adobe/css-tools";
@@ -7,6 +7,9 @@ import showdown from "showdown";
 import { v4 } from "uuid";
 import postmate from "postmate";
 import { Virtualizer } from "virtua";
+import { get } from "lodash-es";
+import { produce } from "immer";
+import { z } from "zod";
 const adjustIframeHeight = (iframeId)=>`
 (function () {
   let scheduled = false;
@@ -404,7 +407,14 @@ function messageFormatting(mes, sanitizerOverrides = {}) {
     });
     return mes;
 }
-const MdRendererBase = ({ content, unsafe = false, extra = {} })=>{
+const loadingTranslates = {
+    'zh-hans': '加载中...',
+    'zh-hant': '載入中...',
+    en: 'Loading...',
+    ja: '読み込み中...',
+    th: 'กำลังโหลด...'
+};
+const MdRendererBase = ({ content, unsafe = false, extra = {}, lang })=>{
     const containerRef = useRef(null);
     const [iframeIdList, setIframeIdList] = useState([]);
     useEffect(()=>{
@@ -421,16 +431,12 @@ const MdRendererBase = ({ content, unsafe = false, extra = {} })=>{
                     id
                 ]);
             const escapedSrcdoc = escapeHtmlAttribute(srcdoc);
+            const loadingText = loadingTranslates[lang ?? 'zh-hans'] || loadingTranslates['zh-hans'];
             return `
 <div class="MJ-iframe-container" id="${containerId}" style="display:flex;width:100%;height:100%;position:relative;">
   <div class="spin-overlay" id="MJ-spin-${id}" style="width:100%;height:100%;position:absolute;top:0;left:0;z-index:1000;background-color:rgba(0,0,0,0.5);display:flex;justify-content:center;align-items:center;">
     <div class="spin-inner wave-text" style="font-weight:500;font-size:16px;color:white;display:flex;justify-content:center;align-items:center;">
-        <span>加</span>
-        <span>载</span>
-        <span>中</span>
-        <span>.</span>
-        <span>.</span>
-        <span>.</span>
+      ${loadingText.split('').map((t)=>`<span>${t}</span>`).join('')}
     </div>
   </div>
   <iframe id="${iframeId}" class="w-full" sandbox="${unsafe ? "allow-scripts" : "allow-scripts allow-same-origin"}" loading="lazy" 
@@ -509,6 +515,11 @@ var events_EVENT = /*#__PURE__*/ function(EVENT) {
     EVENT["MUJIAN_AI_CHAT_MESSAGE_GET_ALL"] = "mujian:ai:chat:message:getAll";
     EVENT["MUJIAN_AI_CHAT_MESSAGE_GET_PAGE"] = "mujian:ai:chat:message:getPage";
     EVENT["MUJIAN_AI_CHAT_PROJECT_GET_INFO"] = "mujian:ai:chat:project:getInfo";
+    EVENT["MUJIAN_AI_CHAT_V2_COMPLETE"] = "mujian:ai:chat_v2:complete";
+    EVENT["MUJIAN_AI_CHAT_V2_RECOVER"] = "mujian:ai:chat_v2:recover";
+    EVENT["MUJIAN_AI_CHAT_V2_STOP"] = "mujian:ai:chat_v2:stop";
+    EVENT["MUJIAN_AI_CHAT_V2_MESSAGE_GET_PAGE"] = "mujian:ai:chat_v2:message:getPage";
+    EVENT["MUJIAN_AI_CHAT_V2_RENDER_MESSAGE"] = "mujian:ai:chat_v2:renderMessage";
     EVENT["MUJIAN_AI_SETTINGS_PERSONA_GET_ACTIVE"] = "mujian:ai:settings:persona:getActive";
     EVENT["MUJIAN_AI_SETTINGS_PERSONA_SET_ACTIVE"] = "mujian:ai:settings:persona:setActive";
     EVENT["MUJIAN_AI_SETTINGS_MODEL_GET_ALL"] = "mujian:ai:settings:model:getAll";
@@ -517,87 +528,51 @@ var events_EVENT = /*#__PURE__*/ function(EVENT) {
     EVENT["MUJIAN_AI_CHAT_MESSAGE_DELETE_ONE"] = "mujian:ai:chat:message:deleteOne";
     EVENT["MUJIAN_AI_CHAT_MESSAGE_EDIT_ONE"] = "mujian:ai:chat:message:editOne";
     EVENT["MUJIAN_AI_CHAT_MESSAGE_SWIPE"] = "mujian:ai:chat:message:swipe";
-    EVENT["MUJIAN_AI_CHAT_MESSAGE_GET_PROMPT"] = "mujian:ai:chat:message:getPrompt";
     EVENT["MUJIAN_AI_OPENAI_IMAGES_GENERATE"] = "mujian:ai:openai:images:generate";
     EVENT["MUJIAN_UTILS_CLIPBOARD_WRITE_TEXT"] = "mujian:utils:clipboard:writeText";
+    EVENT["MUJIAN_GET_CONFIG"] = "mujian:getConfig";
     return EVENT;
 }({});
-function wrapOnData(onData) {
-    let fullContent = '';
-    let buffer = '';
-    let questionId;
-    let replyId;
-    return function(data) {
-        buffer += data;
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines)if (line.startsWith('data: ')) try {
-            const parsedData = JSON.parse(line.slice(6));
-            if (parsedData.question_id) questionId = parsedData.question_id;
-            if (parsedData.reply_id) replyId = parsedData.reply_id;
-            if (parsedData.isFinished) return void onData({
-                isFinished: true,
-                deltaContent: '',
-                fullContent,
-                questionId,
-                replyId
-            });
-            const deltaContent = parsedData?.choices?.[0]?.delta?.content;
-            if (deltaContent?.length > 0) {
-                fullContent += deltaContent;
-                onData({
-                    isFinished: false,
-                    deltaContent: deltaContent,
-                    fullContent,
-                    questionId,
-                    replyId
-                });
-            }
-        } catch (e) {
-            onData({
-                isFinished: true,
-                error: e,
-                deltaContent: '',
-                fullContent,
-                questionId,
-                replyId
-            });
-            return;
-        }
-    };
-}
-const chat_complete = async function(message, onData, signal, option = {}) {
-    await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
-        content: message
+const chat_complete = async function(message, conversationVersion, onData) {
+    await this.call(events_EVENT.MUJIAN_AI_CHAT_V2_COMPLETE, {
+        content: message,
+        conversationVersion
     }, {
-        onData: option.parseContent ? wrapOnData(onData) : onData,
-        signal
+        onData
     });
 };
-const applyRegex = async function(props) {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_APPLY_REGEX, props);
-};
 const renderMessage = async function(props) {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_RENDER_MESSAGE, props);
+    return await this.call(events_EVENT.MUJIAN_AI_CHAT_V2_RENDER_MESSAGE, props);
 };
-const continueComplete = async function(onData, signal) {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
-        isContinue: true
+const continueComplete = async function(conversationVersion, onData) {
+    return await this.call(events_EVENT.MUJIAN_AI_CHAT_V2_COMPLETE, {
+        isContinue: true,
+        conversationVersion
     }, {
-        onData,
-        signal
+        onData
     });
 };
-const chat_regenerate = async function(onData, signal) {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
-        isRegenerate: true
+const chat_regenerate = async function(conversationVersion, onData) {
+    return await this.call(events_EVENT.MUJIAN_AI_CHAT_V2_COMPLETE, {
+        isRegenerate: true,
+        conversationVersion
     }, {
-        onData,
-        signal
+        onData
+    });
+};
+const chat_stop = async function(conversationVersion, assisMsgId) {
+    return await this.call(events_EVENT.MUJIAN_AI_CHAT_V2_STOP, {
+        conversationVersion,
+        assisMsgId
     });
 };
-const getAll = async function() {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_GET_ALL);
+const recover = async function(conversationVersion, assisMsgId, onData) {
+    return await this.call(events_EVENT.MUJIAN_AI_CHAT_V2_RECOVER, {
+        conversationVersion,
+        assisMsgId
+    }, {
+        onData
+    });
 };
 const messageDeleteOne = async function(messageId) {
     return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_DELETE_ONE, {
@@ -616,13 +591,8 @@ const messageSwipe = async function(messageId, swipeId) {
         swipeId
     });
 };
-const getPrompt = async function(messageId) {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_GET_PROMPT, {
-        messageId
-    });
-};
 async function getPage(fromCursor, pageSize) {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_GET_PAGE, {
+    return await this.call(events_EVENT.MUJIAN_AI_CHAT_V2_MESSAGE_GET_PAGE, {
         fromCursor,
         pageSize
     });
@@ -633,22 +603,6 @@ const getInfo = async function() {
 const getActive = async function() {
     return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_PERSONA_GET_ACTIVE);
 };
-const setActive = async function(personaId) {
-    return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_PERSONA_SET_ACTIVE, {
-        personaId
-    });
-};
-const model_getActive = async function() {
-    return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_MODEL_GET_ACTIVE);
-};
-const model_setActive = async function(modelId) {
-    return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_MODEL_SET_ACTIVE, {
-        modelId
-    });
-};
-const model_getAll = async function() {
-    return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_MODEL_GET_ALL);
-};
 const generate = async function(content) {
     return await this.call(MujianSdk.EVENT.MUJIAN_AI_TEXT_GENERATE, {
         content
@@ -700,6 +654,9 @@ const images_images = {
         });
     }
 };
+async function getConfig() {
+    return await this.call(events_EVENT.MUJIAN_GET_CONFIG);
+}
 const saveGame = async function() {};
 const loadGame = async function() {};
 async function writeText(text) {
@@ -718,48 +675,59 @@ class MujianSdk {
         return this.ready;
     }
     pendingRequests = new Map();
+    _config;
+    get openapi() {
+        return this._config?.openapi;
+    }
+    initPromise = null;
     async init() {
-        const handshake = new postmate.Model({
-            reply: ({ id, complete, data, error })=>{
-                const call = this.pendingRequests.get(id);
-                if (!call) return;
-                if (error) {
-                    call.reject(error);
-                    this.pendingRequests.delete(id);
-                    return;
+        if (this.initPromise) return this.initPromise;
+        this.initPromise = (async ()=>{
+            const handshake = new postmate.Model({
+                reply: ({ id, complete, data, error })=>{
+                    const call = this.pendingRequests.get(id);
+                    if (!call) return;
+                    if (error) {
+                        call.reject(error);
+                        this.pendingRequests.delete(id);
+                        return;
+                    }
+                    call.onData?.(data);
+                    if (complete) {
+                        call.onComplete?.();
+                        call.resolve(data);
+                        this.pendingRequests.delete(id);
+                    }
                 }
-                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;
+                Log.i('mujian sdk client init');
+                await this.call(events_EVENT.MUJIAN_INIT);
+                const projectInfo = await this.ai.chat.project.getInfo();
+                if (projectInfo.config?.customCss) {
+                    const style = document.createElement('style');
+                    style.setAttribute('type', 'text/css');
+                    style.setAttribute('id', 'mujian-custom-css');
+                    style.textContent = projectInfo.config.customCss;
+                    document.head.appendChild(style);
                 }
+                if (projectInfo.config?.customJs) {
+                    const script = document.createElement("script");
+                    script.setAttribute('type', "text/javascript");
+                    script.setAttribute('id', 'mujian-custom-js');
+                    script.textContent = projectInfo.config.customJs;
+                    document.head.appendChild(script);
+                }
+                const config = await getConfig.call(this);
+                if (config) this._config = config;
+            } catch (error) {
+                Log.e('init error', error);
             }
-        });
-        try {
-            const parent = await handshake;
-            this.ready = true;
-            this.parent = parent;
-            Log.i('mujian sdk client init');
-            await this.call(events_EVENT.MUJIAN_INIT);
-            const projectInfo = await this.ai.chat.project.getInfo();
-            if (projectInfo.config?.customCss) {
-                const style = document.createElement('style');
-                style.setAttribute('type', 'text/css');
-                style.setAttribute('id', 'mujian-custom-css');
-                style.textContent = projectInfo.config.customCss;
-                document.head.appendChild(style);
-            }
-            if (projectInfo.config?.customJs) {
-                const script = document.createElement("script");
-                script.setAttribute('type', "text/javascript");
-                script.setAttribute('id', 'mujian-custom-js');
-                script.textContent = projectInfo.config.customJs;
-                document.head.appendChild(script);
-            }
-        } catch (error) {
-            Log.e('init error', error);
-        }
+        })();
+        return this.initPromise;
     }
     emit(event, data) {
         if (!this.ready) throw new Error('Mujian is not initialized');
@@ -797,27 +765,20 @@ class MujianSdk {
                 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)
+                    getActive: getActive.bind(this)
                 }
             },
             complete: chat_complete.bind(this),
-            applyRegex: applyRegex.bind(this),
             renderMessage: renderMessage.bind(this),
             continue: continueComplete.bind(this),
             regenerate: chat_regenerate.bind(this),
+            stop: chat_stop.bind(this),
+            recover: recover.bind(this),
             message: {
-                getAll: getAll.bind(this),
                 deleteOne: messageDeleteOne.bind(this),
                 editOne: messageEditOne.bind(this),
                 swipe: messageSwipe.bind(this),
-                getPrompt: getPrompt.bind(this),
                 getPage: getPage.bind(this)
             }
         },
@@ -900,8 +861,10 @@ const MujianSpinner = ({ className, style })=>/*#__PURE__*/ jsxs(Fragment, {
         ]
     });
 const MujianContext = /*#__PURE__*/ createContext(null);
+const ChatContext = /*#__PURE__*/ createContext(null);
 const MujianProvider = ({ children, loadingComponent })=>{
     const [mujian, setMujian] = useState(null);
+    const [messageTypeWritingCount, setMessageTypeWritingCount] = useState(0);
     useEffect(()=>{
         (async ()=>{
             const mujian = MujianSdk.getInstance();
@@ -911,18 +874,26 @@ const MujianProvider = ({ children, loadingComponent })=>{
     }, []);
     return /*#__PURE__*/ jsx(MujianContext.Provider, {
         value: mujian,
-        children: mujian ? children : loadingComponent ?? /*#__PURE__*/ jsx("div", {
-            style: {
-                height: '100%',
-                width: '100%',
-                display: 'flex',
-                justifyContent: 'center',
-                alignItems: 'center'
+        children: /*#__PURE__*/ jsx(ChatContext.Provider, {
+            value: {
+                messageTypeWritingCount,
+                updateMessageTypeWritingCount (dir) {
+                    setMessageTypeWritingCount((p)=>Math.max(p + ('add' === dir ? 1 : -1), 0));
+                }
             },
-            children: /*#__PURE__*/ jsx(MujianSpinner, {
+            children: mujian ? children : loadingComponent ?? /*#__PURE__*/ jsx("div", {
                 style: {
-                    color: '#EC4342'
-                }
+                    height: '100%',
+                    width: '100%',
+                    display: 'flex',
+                    justifyContent: 'center',
+                    alignItems: 'center'
+                },
+                children: /*#__PURE__*/ jsx(MujianSpinner, {
+                    style: {
+                        color: '#EC4342'
+                    }
+                })
             })
         })
     });
@@ -936,12 +907,86 @@ const useMujian = ()=>{
     }
     return mujian;
 };
+const useChatContext = ()=>{
+    const mujian = useContext(ChatContext);
+    if (!mujian) {
+        const message = 'Context is not initialized. Please check that useChatContext is called inside MujianProvider';
+        console.error(message);
+        throw new Error(message);
+    }
+    return mujian;
+};
 const MessageItem = (props)=>{
-    const { message, children, depth, index } = props;
+    const { message, children, depth, index, typingOpts = {
+        chunkSize: 2,
+        delay: 40
+    } } = props;
     const mujian = useMujian();
+    const { updateMessageTypeWritingCount } = useChatContext();
+    const lastMessage = useLatest(message);
+    const [typeWritingPos, setTypeWritingPos] = useState(null);
+    const typeWritingIntervalId = useRef(null);
+    function stopTypeWriting() {
+        if (typeWritingIntervalId.current) {
+            clearTimeout(typeWritingIntervalId.current);
+            typeWritingIntervalId.current = null;
+            setTimeout(()=>{
+                updateMessageTypeWritingCount('sub');
+            });
+        }
+    }
+    function startTypeWriting() {
+        updateMessageTypeWritingCount('add');
+        stopTypeWriting();
+        let lastTimestamp = Date.now();
+        typeWritingIntervalId.current = setInterval(()=>{
+            function calcTimeFrames() {
+                const now = Date.now();
+                const deltaTime = now - lastTimestamp;
+                lastTimestamp = now;
+                return Math.round(deltaTime / typingOpts.delay);
+            }
+            setTypeWritingPos((p)=>{
+                const frames = calcTimeFrames();
+                const posIncrement = frames * typingOpts.chunkSize;
+                const message = lastMessage.current;
+                const content = message.swipes[message.activeSwipeId].content;
+                const maxPos = content.length;
+                const nextPos = Math.min((p || 0) + posIncrement, maxPos);
+                if (!message.isGenerating && maxPos === nextPos) {
+                    stopTypeWriting();
+                    return null;
+                }
+                return nextPos;
+            });
+        }, typingOpts.delay);
+    }
+    useUnmount(()=>{
+        stopTypeWriting();
+    });
+    useEffect(()=>{
+        if (message.isGenerating) {
+            const content = message.swipes[message.activeSwipeId].content;
+            setTypeWritingPos(content.length);
+            startTypeWriting();
+        }
+    }, [
+        message.isGenerating
+    ]);
     const { data: renderedMessage } = useRequest(async ()=>{
-        const { isStreaming } = message;
-        if (isStreaming) return message;
+        if (null !== typeWritingPos) {
+            const pos = typeWritingPos;
+            return {
+                ...message,
+                swipes: message.swipes.map((s, i)=>{
+                    if (i !== message.activeSwipeId) return s;
+                    return {
+                        ...s,
+                        content: s.content.slice(0, pos)
+                    };
+                })
+            };
+        }
         return await mujian.ai.chat.renderMessage({
             message,
             depth,
@@ -949,7 +994,8 @@ const MessageItem = (props)=>{
         });
     }, {
         refreshDeps: [
-            message
+            message,
+            typeWritingPos
         ]
     });
     return children(renderedMessage || message, message);
@@ -971,28 +1017,116 @@ const Thread = {
     MessageItem: MessageItem,
     MessageList: MessageList
 };
-class SendMessageError extends Error {
-    constructor(message, cause){
-        super(message);
-        this.name = this.constructor.name;
-        this.cause = cause;
+let $mj_ai_chat_complete;
+let $mj_ai_chat_project;
+let $mj_ai_chat_settings_persona;
+let $mj_ai_chat_setFirstMesIndex;
+let $mj_ai_chat_mjv_get;
+let $mj_ai_chat_mjv_getAll;
+const $mj_engine = {
+    ai: {
+        chat: {
+            get complete () {
+                return $mj_ai_chat_complete;
+            },
+            get project () {
+                return $mj_ai_chat_project;
+            },
+            settings: {
+                get persona () {
+                    return $mj_ai_chat_settings_persona;
+                }
+            },
+            get setFirstMesIndex () {
+                return $mj_ai_chat_setFirstMesIndex;
+            }
+        }
     }
-}
-class InvalidDeltaContentError extends Error {
-    constructor(message, cause){
-        super(message);
-        this.name = this.constructor.name;
-        this.cause = cause;
+};
+window.$mj_engine = {
+    ...$mj_engine,
+    bind ({ messageId, swipeId }) {
+        return {
+            ai: {
+                chat: {
+                    mjv: {
+                        get (path) {
+                            return $mj_ai_chat_mjv_get?.(messageId, swipeId, path);
+                        },
+                        getAll () {
+                            return $mj_ai_chat_mjv_getAll?.(messageId, swipeId) ?? {};
+                        }
+                    },
+                    get complete () {
+                        return $mj_ai_chat_complete;
+                    },
+                    get project () {
+                        return $mj_ai_chat_project;
+                    },
+                    settings: {
+                        get persona () {
+                            return $mj_ai_chat_settings_persona;
+                        }
+                    },
+                    get setFirstMesIndex () {
+                        return $mj_ai_chat_setFirstMesIndex;
+                    }
+                }
+            }
+        };
     }
+};
+function useMjEngine({ projectInfo, activePersona, onSend, messages, setSwipe }) {
+    useEffect(()=>{
+        $mj_ai_chat_project = projectInfo ?? void 0;
+        $mj_ai_chat_settings_persona = activePersona ?? void 0;
+    }, [
+        projectInfo,
+        activePersona
+    ]);
+    useEffect(()=>{
+        $mj_ai_chat_complete = async (message)=>{
+            await onSend(message);
+        };
+        $mj_ai_chat_setFirstMesIndex = async (oneBasedIndex)=>{
+            if (messages.length > 1) throw new Error('已有新消息，不允许切换开场白');
+            if (0 === messages.length) throw new Error('断言失败：没有开场消息，无法切换开场白');
+            const zeroBasedIndex = Math.floor(oneBasedIndex) - 1;
+            const swipeLength = messages[0].swipes.length;
+            if (zeroBasedIndex < 0 || zeroBasedIndex >= swipeLength) return;
+            setSwipe(messages[0].id, zeroBasedIndex);
+        };
+        $mj_ai_chat_mjv_getAll = (messageId, swipeId)=>messages.find((m)=>m.id === messageId)?.swipes[swipeId]?.mjv?.value;
+        $mj_ai_chat_mjv_get = (messageId, swipeId, path)=>{
+            const mjv = $mj_ai_chat_mjv_getAll?.(messageId, swipeId);
+            if (!mjv) return;
+            return get(mjv, path);
+        };
+    }, [
+        onSend,
+        messages,
+        setSwipe
+    ]);
+}
+const errorMessages = [
+    'network error',
+    'NetworkError when attempting to fetch resource.',
+    'The Internet connection appears to be offline.',
+    'Network request failed',
+    'Load failed',
+    'Failed to fetch'
+];
+function isNetworkError(message) {
+    return errorMessages.some((m)=>message.includes(m));
 }
-class UnexpectedSseEndingError extends Error {
+class SendMessageError extends Error {
     constructor(message, cause){
         super(message);
         this.name = this.constructor.name;
         this.cause = cause;
     }
 }
-async function* callSdk(mujian, content, type = 'generate', signal) {
+async function* callSdk(mujian, content, type = 'generate', conversationVersion, assisMsgId) {
     const queue = [];
     let resolveWait = null;
     let done = false;
@@ -1000,7 +1134,6 @@ async function* callSdk(mujian, content, type = 'generate', signal) {
     try {
         const onData = (data)=>{
             if (error) return;
-            if ('string' != typeof data) return;
             queue.push(data);
             if (resolveWait) {
                 resolveWait();
@@ -1021,9 +1154,13 @@ async function* callSdk(mujian, content, type = 'generate', signal) {
                 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);
+        if ('generate' === type) mujian.ai.chat.complete(content, conversationVersion, onData).then(then).catch(catcher);
+        else if ('regenerate' === type) mujian.ai.chat.regenerate(conversationVersion, onData).then(then).catch(catcher);
+        else if ('continue' === type) mujian.ai.chat.continue(conversationVersion, onData).then(then).catch(catcher);
+        else {
+            if (!assisMsgId) throw new Error('call recover without assisMsgId');
+            mujian.ai.chat.recover(conversationVersion, assisMsgId, onData).then(then).catch(catcher);
+        }
     } catch (err) {
         error = err;
         done = true;
@@ -1036,56 +1173,44 @@ async function* callSdk(mujian, content, type = 'generate', signal) {
     });
 }
 const NOT_SAVED_MSG_ID_PREFIX = 'not_saved';
-const FALLBACK_MESSAGE = `<!-- 此条HTML消息为系统提示，请勿复读 -->
-哎呀，AI线路好像抽风了，重说一下试试吧~`;
-const useChatStreaming = ({ common, setError, setMessages, mujian })=>{
+const useChatStreaming = ({ common, setError, setMessages, getMessages, setInput, mujian, conversationVersion: conversationVersionRef })=>{
     const { body } = common;
     const [isStreaming, setIsStreaming] = useState(false);
-    const chatStreaming = useCallback(async ({ query, regenerate, is_continue, signal })=>{
+    const chatStreaming = useCallback(async ({ query, regenerate, is_continue, conversationVersion })=>{
         try {
             setError(void 0);
             setIsStreaming(true);
+            const backupMessages = getMessages();
             const userMessage = {
                 id: `${NOT_SAVED_MSG_ID_PREFIX}_user_${Date.now()}`,
-                content: query || '',
-                role: 'user',
-                swipes: [],
+                isUser: true,
+                swipes: [
+                    {
+                        content: query ?? ''
+                    }
+                ],
                 activeSwipeId: 0,
-                isStreaming: false,
-                sendAt: new Date(),
-                swipeInfo: []
+                isGenerating: false
             };
             const aiMessage = {
                 id: `${NOT_SAVED_MSG_ID_PREFIX}_assistant_${Date.now()}`,
-                content: '',
-                role: 'assistant',
+                isUser: false,
                 swipes: [
-                    ''
+                    {
+                        content: ''
+                    }
                 ],
                 activeSwipeId: 0,
-                isStreaming: true,
-                sendAt: new Date(),
-                swipeInfo: [
-                    {}
-                ]
+                isGenerating: true
             };
-            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;
-            });
+            if (regenerate) setMessages(produce((draft)=>{
+                const lastMessage = draft[draft.length - 1];
+                lastMessage.activeSwipeId = lastMessage.swipes.length;
+                lastMessage.swipes.push({
+                    content: ''
+                });
+                lastMessage.isGenerating = true;
+            }));
             else is_continue ? setMessages((prev)=>[
                     ...prev,
                     aiMessage
@@ -1094,111 +1219,45 @@ const useChatStreaming = ({ common, setError, setMessages, mujian })=>{
                     userMessage,
                     aiMessage
                 ]);
-            const stream = callSdk(mujian, query || '', is_continue ? 'continue' : regenerate ? 'regenerate' : 'generate', signal);
-            let buffer = '';
-            let content = '';
+            const stream = callSdk(mujian, query || '', is_continue ? 'continue' : regenerate ? 'regenerate' : 'generate', conversationVersion);
             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 || 'meta' !== parsedData.type) {
-                                if ('stream' === parsedData.type) {
-                                    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));
-                                    }
-                                } else if ('mjv' === parsedData.type) {
-                                    const { value, delta, schema } = parsedData;
-                                    setMessages((prev)=>{
-                                        const newMessages = [
-                                            ...prev
-                                        ];
-                                        const lastMessage = newMessages[newMessages.length - 1];
-                                        const mjv = {
-                                            value,
-                                            delta,
-                                            schema
-                                        };
-                                        const newSwipeInfo = lastMessage.swipeInfo;
-                                        if (newSwipeInfo[lastMessage.activeSwipeId]) newSwipeInfo[lastMessage.activeSwipeId].mjv = mjv;
-                                        else newSwipeInfo[lastMessage.activeSwipeId] = {
-                                            mjv
-                                        };
-                                        newMessages[newMessages.length - 1] = {
-                                            ...lastMessage,
-                                            swipeInfo: newSwipeInfo,
-                                            mjv
-                                        };
-                                        return newMessages;
-                                    });
-                                }
-                            } else {
-                                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 (!chunk) return;
+                    if ('meta' === chunk.type) {
+                        if (!regenerate) setMessages(produce((draft)=>{
+                            if (!is_continue) {
+                                const userMsg = draft[draft.length - 2];
+                                userMsg.id = chunk.userMsgId;
                             }
-                        } catch  {
-                            if ('[DONE]' !== data) {
-                                console.error('Received plain SSE message:', data);
-                                setError(new UnexpectedSseEndingError(data));
-                            }
-                        }
+                            const lastMessage = draft[draft.length - 1];
+                            lastMessage.id = chunk.assisMsgId;
+                        }));
+                        conversationVersionRef.current = chunk.newConversationVersion;
+                    } else if ('data' === chunk.type) {
+                        setMessages(produce((draft)=>{
+                            const lastMessage = draft[draft.length - 1];
+                            lastMessage.swipes[lastMessage.activeSwipeId] = {
+                                content: chunk.content,
+                                mjv: chunk.mjv
+                            };
+                            if (chunk.finishReason) lastMessage.finishReason = chunk.finishReason;
+                            if (chunk.error) lastMessage.error = chunk.error;
+                        }));
+                        await new Promise((resolve)=>setTimeout(resolve, 10));
                     }
                 }
             } catch (error) {
                 Log.e('Stream error', error);
-                'object' == typeof error && error && 'message' in error && 'string' == typeof error.message ? setError(new SendMessageError(error.message)) : setError(error);
+                if ('object' == typeof error && error && 'message' in error && 'string' == typeof error.message) if ('code' in error && 2011030001 === error.code) {
+                    setMessages(backupMessages);
+                    if (!regenerate && !is_continue && query) setInput(query);
+                } else isNetworkError(error.message) ? setError(new SendMessageError('E_NETWORK_ERROR')) : setError(new SendMessageError(error.message));
+                else setError(error);
             } finally{
-                Log.i('stream end finally');
-                setMessages((prev)=>{
-                    const newMessages = [
-                        ...prev
-                    ];
-                    const lastMessage = {
-                        ...newMessages[newMessages.length - 1],
-                        isStreaming: false
-                    };
-                    if (!lastMessage.swipes[lastMessage.activeSwipeId]) {
-                        lastMessage.swipes[lastMessage.activeSwipeId] = FALLBACK_MESSAGE;
-                        lastMessage.content = FALLBACK_MESSAGE;
-                    }
-                    newMessages[newMessages.length - 1] = lastMessage;
-                    return newMessages;
-                });
+                setMessages(produce((draft)=>{
+                    const lastMessage = draft[draft.length - 1];
+                    lastMessage.isGenerating = false;
+                }));
             }
         } catch (error) {
             console.error('Error:', error);
@@ -1211,15 +1270,46 @@ const useChatStreaming = ({ common, setError, setMessages, mujian })=>{
         body,
         mujian
     ]);
+    const recoverStreaming = useCallback(async (messageId, conversationVersion)=>{
+        const stream = callSdk(mujian, '', 'recover', conversationVersion, messageId);
+        try {
+            for await (const chunk of stream){
+                if (!chunk) return;
+                if ('data' === chunk.type) setMessages(produce((draft)=>{
+                    const msg = draft.find((m)=>m.id === messageId);
+                    if (!msg) return;
+                    msg.swipes[msg.activeSwipeId] = {
+                        content: chunk.content,
+                        mjv: chunk.mjv
+                    };
+                    if (chunk.finishReason) msg.finishReason = chunk.finishReason;
+                    if (chunk.error) msg.error = chunk.error;
+                }));
+            }
+        } catch (error) {
+            Log.e('Stream error', error);
+            if ('object' == typeof error && error && 'message' in error && 'string' == typeof error.message) isNetworkError(error.message) ? setError(new SendMessageError('E_NETWORK_ERROR')) : setError(new SendMessageError(error.message));
+            else setError(error);
+        } finally{
+            setMessages(produce((draft)=>{
+                const msg = draft.find((m)=>m.id === messageId);
+                if (!msg) return;
+                msg.isGenerating = false;
+            }));
+        }
+    }, [
+        mujian
+    ]);
     return {
         chatStreaming,
-        isStreaming
+        isStreaming,
+        recoverStreaming
     };
 };
-const useChat = ({ body, onError, onFinish, pageSize })=>{
+const useChat = ({ body, onError, onFinish, pageSize = 10 })=>{
     const [error, _setError] = useState();
     const [input, setInput] = useState('');
-    const [abortController, setAbortController] = useState();
+    const conversationVersion = useRef(0);
     const mujian = useMujian();
     const setError = (error)=>{
         _setError(error);
@@ -1234,12 +1324,12 @@ const useChat = ({ body, onError, onFinish, pageSize })=>{
         };
         try {
             const resp = await mujian.ai.chat.message.getPage(current?.cursor, pageSize);
+            conversationVersion.current = resp.conversationVersion;
+            const lastMessage = resp.messages.at(-1);
+            if (lastMessage?.isGenerating) recoverStreaming(lastMessage.id, conversationVersion.current);
             return {
                 cursor: resp.nextCursor,
-                list: resp.messages.map((m)=>({
-                        ...m,
-                        mjv: m.swipeInfo[m.activeSwipeId]?.mjv
-                    })),
+                list: resp.messages,
                 noMore: !resp.nextCursor
             };
         } finally{
@@ -1270,13 +1360,19 @@ const useChat = ({ body, onError, onFinish, pageSize })=>{
             list: newList
         });
     };
-    const { chatStreaming, isStreaming } = useChatStreaming({
+    const getMessages = useCallback(()=>latestListRef.current, [
+        latestListRef
+    ]);
+    const { chatStreaming, isStreaming, recoverStreaming } = useChatStreaming({
         common: {
             body
         },
         setError,
         setMessages,
-        mujian
+        getMessages,
+        setInput,
+        mujian,
+        conversationVersion
     });
     useUpdateEffect(()=>{
         if (!isStreaming) {
@@ -1288,18 +1384,14 @@ const useChat = ({ body, onError, onFinish, pageSize })=>{
     ]);
     const append = useCallback(async (query)=>{
         if (isStreaming) throw new Error('useChat is streaming already.');
-        const controller = new AbortController();
-        setAbortController(controller);
         try {
             await chatStreaming({
                 query,
-                signal: controller.signal
+                conversationVersion: conversationVersion.current
             });
         } catch (e) {
             setError(e);
             throw e;
-        } finally{
-            setAbortController(void 0);
         }
     }, [
         isStreaming,
@@ -1307,20 +1399,17 @@ const useChat = ({ body, onError, onFinish, pageSize })=>{
     ]);
     const regenerate = useCallback(async ()=>{
         if (isStreaming) throw new Error('useChat is streaming already.');
-        const controller = new AbortController();
-        setAbortController(controller);
-        const lastMessage = messages.findLast((message)=>'user' === message.role);
+        const lastMessage = messages.findLast((message)=>message.isUser);
         try {
+            const query = lastMessage ? lastMessage.swipes[lastMessage.activeSwipeId].content : '';
             await chatStreaming({
-                query: lastMessage?.content || '',
+                query,
                 regenerate: true,
-                signal: controller.signal
+                conversationVersion: conversationVersion.current
             });
         } catch (e) {
             setError(e);
             throw e;
-        } finally{
-            setAbortController(void 0);
         }
     }, [
         isStreaming,
@@ -1329,49 +1418,55 @@ const useChat = ({ body, onError, onFinish, pageSize })=>{
     ]);
     const continueGenerate = useCallback(async ()=>{
         if (isStreaming) throw new Error('useChat is streaming already.');
-        const controller = new AbortController();
-        setAbortController(controller);
         try {
             await chatStreaming({
                 query: '',
                 is_continue: true,
-                signal: controller.signal
+                conversationVersion: conversationVersion.current
             });
         } catch (e) {
             setError(e);
             throw e;
-        } finally{
-            setAbortController(void 0);
         }
     }, [
         isStreaming,
         chatStreaming
     ]);
     const stop = ()=>{
-        abortController?.abort();
+        const assisMsgId = messages.at(-1)?.id;
+        if (!assisMsgId) return;
+        mujian.ai.chat.stop(conversationVersion.current, assisMsgId);
     };
     const setSwipe = async (messageId, swipeId)=>{
         if (swipeId < 0) return;
         setMessages((prev)=>prev.map((msg)=>msg.id === messageId && swipeId < msg.swipes.length ? {
                     ...msg,
-                    activeSwipeId: swipeId,
-                    content: msg.swipes[swipeId],
-                    mjv: msg.swipeInfo[swipeId]?.mjv
+                    activeSwipeId: swipeId
                 } : msg));
-        await mujian.ai.chat.message.swipe(messageId, swipeId);
+        const resp = await mujian.ai.chat.message.swipe(messageId, swipeId);
+        const schema = z.object({
+            newConversationVersion: z.number()
+        });
+        const { data, success } = schema.safeParse(resp);
+        if (success && data.newConversationVersion) conversationVersion.current = data.newConversationVersion;
     };
     const editMessage = async (messageId, content)=>{
-        await mujian.ai.chat.message.editOne(messageId, content);
+        const resp = await mujian.ai.chat.message.editOne(messageId, content);
+        const schema = z.object({
+            newConversationVersion: z.number()
+        });
+        const { data, success } = schema.safeParse(resp);
+        if (success && data.newConversationVersion) conversationVersion.current = data.newConversationVersion;
         const patchMessage = (msg)=>{
             const newMsg = {
                 ...msg,
                 content
             };
-            if ('assistant' === newMsg.role) {
+            if (!newMsg.isUser) {
                 newMsg.swipes = [
                     ...newMsg.swipes
                 ];
-                newMsg.swipes[newMsg.activeSwipeId] = content;
+                newMsg.swipes[newMsg.activeSwipeId].content = content;
             }
             return newMsg;
         };
@@ -1379,7 +1474,12 @@ const useChat = ({ body, onError, onFinish, pageSize })=>{
     };
     const deleteMessage = async (messageId)=>{
         if (!messageId.startsWith(NOT_SAVED_MSG_ID_PREFIX)) try {
-            await mujian.ai.chat.message.deleteOne(messageId);
+            const resp = await mujian.ai.chat.message.deleteOne(messageId);
+            const schema = z.object({
+                newConversationVersion: z.number()
+            });
+            const { data, success } = schema.safeParse(resp);
+            if (success && data.newConversationVersion) conversationVersion.current = data.newConversationVersion;
         } catch (e) {
             if (e?.code !== 2011030004) throw e;
         }
@@ -1410,4 +1510,4 @@ const useChat = ({ body, onError, onFinish, pageSize })=>{
         messagesStatus: messageLoadError ? 'error' : loadingMore || loading ? 'loading' : data?.noMore ? 'all-loaded' : 'has-more'
     };
 };
-export { MdRenderer, MujianProvider, MujianSpinner, Thread, useChat, useMujian };
+export { MdRenderer, MujianProvider, MujianSpinner, Thread, useChat, useChatContext, useMjEngine, useMujian };