@mujian/js-sdk 0.0.6-beta.8 → 0.0.6-beta.81

package/dist/events/index.d.ts

@@ -21,13 +21,33 @@ export declare enum EVENT {
      */
     MUJIAN_AI_CHAT_APPLY_REGEX = "mujian:ai:chat:applyRegex",
     /**
-     * 生成文本
+     * 对消息应用正则表达式并渲染模板
+     */
+    MUJIAN_AI_CHAT_RENDER_MESSAGE = "mujian:ai:chat:renderMessage",
+    /**
+     * 文本补全
      */
     MUJIAN_AI_TEXT_GENERATE = "mujian:ai:text:generate",
+    /**
+     * OpenAI 文本补全
+     */
+    MUJIAN_AI_OPENAI_COMPLETIONS_CREATE = "mujian:ai:openai:completions:create",
+    /**
+     * OpenAI 聊天补全
+     */
+    MUJIAN_AI_OPENAI_CHAT_COMPLETIONS_CREATE = "mujian:ai:openai:chat:completions:create",
+    /**
+     * OpenAI 响应创建
+     */
+    MUJIAN_AI_OPENAI_RESPONSES_CREATE = "mujian:ai:openai:responses:create",
     /**
      * 获取对话
      */
     MUJIAN_AI_CHAT_MESSAGE_GET_ALL = "mujian:ai:chat:message:getAll",
+    /**
+     * 获取对话分页
+     */
+    MUJIAN_AI_CHAT_MESSAGE_GET_PAGE = "mujian:ai:chat:message:getPage",
     /**
      * 获取项目信息
      */
@@ -67,5 +87,17 @@ export declare enum EVENT {
     /**
      * 获取消息提示词
      */
-    MUJIAN_AI_CHAT_MESSAGE_GET_PROMPT = "mujian:ai:chat:message:getPrompt"
+    MUJIAN_AI_CHAT_MESSAGE_GET_PROMPT = "mujian:ai:chat:message:getPrompt",
+    /**
+     * 生成图像
+     */
+    MUJIAN_AI_OPENAI_IMAGES_GENERATE = "mujian:ai:openai:images:generate",
+    /**
+     * 写入剪贴版
+     */
+    MUJIAN_UTILS_CLIPBOARD_WRITE_TEXT = "mujian:utils:clipboard:writeText",
+    /**
+     * 获取配置
+     */
+    MUJIAN_GET_CONFIG = "mujian:getConfig"
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { EVENT } from './events';
+import { Config } from './modules/config';
 /** @hidden */
 export { EVENT } from './events';
 type Call<T> = {
@@ -14,7 +15,13 @@ declare global {
     }
 }
 declare class MujianSdk {
+    /** @hidden */
     private constructor();
+    /**
+     * 事件
+     * @enum {string}
+     */
+    static EVENT: typeof EVENT;
     /** @hidden */
     static getInstance(): MujianSdk;
     /** @hidden */
@@ -27,6 +34,9 @@ declare class MujianSdk {
     get isReady(): boolean;
     /** @hidden */
     private pendingRequests;
+    private _config?;
+    get openapi(): Config['openapi'] | undefined;
+    private initPromise;
     /**
      * 初始化
      */
@@ -40,47 +50,15 @@ declare class MujianSdk {
     /** @hidden */
     call<Req, Resp>(event: EVENT, data?: Req, controller?: Pick<Call<Resp>, 'onData' | 'onComplete' | 'signal'>): Promise<Resp>;
     /**
-     * AI
+     * @namespace ai
+     * @description AI
      */
-    ai: {
-        chat: {
-            project: {
-                getInfo: () => Promise<import("./types").ProjectInfo>;
-            };
-            settings: {
-                model: {
-                    getAll: () => Promise<import("./types").ModelInfo[]>;
-                    getActive: () => Promise<string>;
-                    setActive: (modelId: string) => Promise<string>;
-                };
-                persona: {
-                    getActive: () => Promise<import("./types").PersonaInfo>;
-                    setActive: (personaId: string) => Promise<void>;
-                };
-            };
-            complete: (message: string, onData: (data: string) => void, signal?: AbortSignal | undefined) => Promise<string>;
-            applyRegex: (props: {
-                message: import("./react").Message;
-                index: number;
-                depth: number;
-            }) => Promise<import("./react").Message>;
-            continue: (onData: (data: string) => void, signal?: AbortSignal | undefined) => Promise<string>;
-            regenerate: (onData: (data: string) => void, signal?: AbortSignal | undefined) => Promise<string>;
-            message: {
-                getAll: () => Promise<import("./react").Message[]>;
-                deleteOne: (messageId: string) => Promise<unknown>;
-                editOne: (messageId: string, content: string) => Promise<unknown>;
-                swipe: (messageId: string, swipeId: number) => Promise<unknown>;
-                getPrompt: (messageId: string) => Promise<unknown>;
-            };
-        };
-        text: {
-            complete: () => Promise<void>;
-        };
-    };
+    ai: any;
     ui: {};
-    util: {
-        cn: () => void;
+    utils: {
+        clipboard: {
+            writeText: (text: string) => Promise<unknown>;
+        };
     };
     hybrid: {};
     player: {};

package/dist/index.js

@@ -4,8 +4,13 @@ var events_EVENT = /*#__PURE__*/ function(EVENT) {
     EVENT["MUJIAN_AI_CHAT_STOP"] = "mujian:ai:chat:stop";
     EVENT["MUJIAN_AI_CHAT_COMPLETE"] = "mujian:ai:chat:complete";
     EVENT["MUJIAN_AI_CHAT_APPLY_REGEX"] = "mujian:ai:chat:applyRegex";
+    EVENT["MUJIAN_AI_CHAT_RENDER_MESSAGE"] = "mujian:ai:chat:renderMessage";
     EVENT["MUJIAN_AI_TEXT_GENERATE"] = "mujian:ai:text:generate";
+    EVENT["MUJIAN_AI_OPENAI_COMPLETIONS_CREATE"] = "mujian:ai:openai:completions:create";
+    EVENT["MUJIAN_AI_OPENAI_CHAT_COMPLETIONS_CREATE"] = "mujian:ai:openai:chat:completions:create";
+    EVENT["MUJIAN_AI_OPENAI_RESPONSES_CREATE"] = "mujian:ai:openai:responses:create";
     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_SETTINGS_PERSONA_GET_ACTIVE"] = "mujian:ai:settings:persona:getActive";
     EVENT["MUJIAN_AI_SETTINGS_PERSONA_SET_ACTIVE"] = "mujian:ai:settings:persona:setActive";
@@ -16,19 +21,69 @@ var events_EVENT = /*#__PURE__*/ function(EVENT) {
     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;
 }({});
-const chat_complete = async function(message, onData, signal) {
-    return await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
+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
     }, {
-        onData,
+        onData: option.parseContent ? wrapOnData(onData) : onData,
         signal
     });
 };
 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);
+};
 const continueComplete = async function(onData, signal) {
     return await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
         isContinue: true
@@ -70,6 +125,12 @@ const getPrompt = async function(messageId) {
         messageId
     });
 };
+async function getPage(fromCursor, pageSize) {
+    return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_GET_PAGE, {
+        fromCursor,
+        pageSize
+    });
+}
 const getInfo = async function() {
     return await this.call(events_EVENT.MUJIAN_AI_CHAT_PROJECT_GET_INFO);
 };
@@ -92,15 +153,25 @@ const model_setActive = async function(modelId) {
 const model_getAll = async function() {
     return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_MODEL_GET_ALL);
 };
-const generate = async function() {
-    return await this.call(events_EVENT.MUJIAN_AI_TEXT_GENERATE, {
-        content: 'q'
-    });
-};
+async function getConfig() {
+    return await this.call(events_EVENT.MUJIAN_GET_CONFIG);
+}
 const saveGame = async function() {};
 const loadGame = async function() {};
+async function writeText(text) {
+    return await this.call(events_EVENT.MUJIAN_UTILS_CLIPBOARD_WRITE_TEXT, text);
+}
+const Log = {
+    i (...msg) {
+        console.log('[MujianSDK] ', ...msg);
+    },
+    e (...msg) {
+        console.error('[MujianSDK] ', ...msg);
+    }
+};
 class MujianSdk {
     constructor(){}
+    static EVENT = events_EVENT;
     static getInstance() {
         if (!window.$mujian) window.$mujian = new MujianSdk();
         return window.$mujian;
@@ -111,29 +182,279 @@ 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 })=>{
-                const call = this.pendingRequests.get(id);
-                if (!call) return;
-                call.onData?.(data);
-                if (complete) {
-                    call.onComplete?.();
-                    call.resolve(data);
-                    this.pendingRequests.delete(id);
+        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);
+                    }
                 }
+            });
+            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);
             }
+        })();
+        return this.initPromise;
+    }
+    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(events_EVENT.MUJIAN_AI_CHAT_STOP, {
+                    id: callId
+                });
+            });
         });
-        try {
-            const parent = await handshake;
-            this.ready = true;
-            this.parent = parent;
-            console.log('mujian sdk client init');
-            await this.call(events_EVENT.MUJIAN_INIT);
-        } catch (error) {
-            console.log('init error', error);
+    }
+    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),
+            renderMessage: renderMessage.bind(this),
+            continue: continueComplete.bind(this),
+            regenerate: regenerate.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)
+            }
+        },
+        text: {
+            complete: generate.bind(this)
+        },
+        openai: {
+            completions: {
+                create: completions.create.bind(this)
+            },
+            chat: {
+                completions: {
+                    create: chat.completions.create.bind(this)
+                }
+            },
+            responses: {
+                create: responses.create.bind(this)
+            },
+            images: {
+                generate: images_images.generate.bind(this)
+            }
+        }
+    };
+    ui = {};
+    utils = {
+        clipboard: {
+            writeText: writeText.bind(this)
+        }
+    };
+    hybrid = {};
+    player = {};
+    game = {
+        assets: ()=>{
+            console.log('assets');
+        },
+        saves: {
+            saveGame: saveGame.bind(this),
+            loadGame: loadGame.bind(this)
+        },
+        ranking: ()=>{
+            console.log('ranking');
+        }
+    };
+}
+const generate = async function(content) {
+    return await this.call(MujianSdk.EVENT.MUJIAN_AI_TEXT_GENERATE, {
+        content
+    });
+};
+const chat = {
+    completions: {
+        create: async function(params, options, onData, signal) {
+            return await this.call(MujianSdk.EVENT.MUJIAN_AI_OPENAI_CHAT_COMPLETIONS_CREATE, {
+                params,
+                options
+            }, {
+                onData,
+                signal
+            });
         }
     }
+};
+const completions = {
+    create: async function(params, options, onData, signal) {
+        return await this.call(MujianSdk.EVENT.MUJIAN_AI_OPENAI_COMPLETIONS_CREATE, {
+            params,
+            options
+        }, {
+            onData,
+            signal
+        });
+    }
+};
+const responses = {
+    create: async function(params, options, onData, signal) {
+        return await this.call(MujianSdk.EVENT.MUJIAN_AI_OPENAI_RESPONSES_CREATE, {
+            params,
+            options
+        }, {
+            onData,
+            signal
+        });
+    }
+};
+const images_images = {
+    generate: async function(params, options, onData, signal) {
+        return await this.call(MujianSdk.EVENT.MUJIAN_AI_OPENAI_IMAGES_GENERATE, {
+            params,
+            options
+        }, {
+            onData,
+            signal
+        });
+    }
+};
+class src_MujianSdk {
+    constructor(){}
+    static EVENT = events_EVENT;
+    static getInstance() {
+        if (!window.$mujian) window.$mujian = new src_MujianSdk();
+        return window.$mujian;
+    }
+    parent = null;
+    ready = false;
+    get isReady() {
+        return this.ready;
+    }
+    pendingRequests = new Map();
+    _config;
+    get openapi() {
+        return this._config?.openapi;
+    }
+    initPromise = null;
+    async init() {
+        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);
+                    }
+                }
+            });
+            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);
+            }
+        })();
+        return this.initPromise;
+    }
     emit(event, data) {
         if (!this.ready) throw new Error('Mujian is not initialized');
         this.parent?.emit(event, data);
@@ -182,6 +503,7 @@ class MujianSdk {
             },
             complete: chat_complete.bind(this),
             applyRegex: applyRegex.bind(this),
+            renderMessage: renderMessage.bind(this),
             continue: continueComplete.bind(this),
             regenerate: regenerate.bind(this),
             message: {
@@ -189,17 +511,34 @@ class MujianSdk {
                 deleteOne: messageDeleteOne.bind(this),
                 editOne: messageEditOne.bind(this),
                 swipe: messageSwipe.bind(this),
-                getPrompt: getPrompt.bind(this)
+                getPrompt: getPrompt.bind(this),
+                getPage: getPage.bind(this)
             }
         },
         text: {
             complete: generate.bind(this)
+        },
+        openai: {
+            completions: {
+                create: completions.create.bind(this)
+            },
+            chat: {
+                completions: {
+                    create: chat.completions.create.bind(this)
+                }
+            },
+            responses: {
+                create: responses.create.bind(this)
+            },
+            images: {
+                generate: images_images.generate.bind(this)
+            }
         }
     };
     ui = {};
-    util = {
-        cn: ()=>{
-            console.log('cn');
+    utils = {
+        clipboard: {
+            writeText: writeText.bind(this)
         }
     };
     hybrid = {};
@@ -217,4 +556,4 @@ class MujianSdk {
         }
     };
 }
-export { events_EVENT as EVENT, MujianSdk };
+export { events_EVENT as EVENT, src_MujianSdk as MujianSdk };

package/dist/lite.d.ts

@@ -0,0 +1,74 @@
+import { EVENT } from './events';
+import { Config } from './modules/config';
+/** @hidden */
+export { EVENT } from './events';
+type Call<T> = {
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
+    onData?: (data: T) => void;
+    onComplete?: () => void;
+    signal?: AbortSignal;
+};
+declare global {
+    interface Window {
+        $mujian_lite: MujianSdkLite;
+    }
+}
+/**
+ * @class MujianSdkLite
+ * @description 幕间 SDK 的轻量级客户端，用于在浏览器中获取 API 配置。
+ * @example
+ * ```typescript
+ * (window as any).$mujian_lite.init().then(() => {
+ *    console.log((window as any).$mujian_lite.openapi.baseURL); // API 的 URL
+ *    console.log((window as any).$mujian_lite.openapi.apiKey); // API 的 KEY （当前用户唯一）
+ *  });
+ * ```
+ */
+declare class MujianSdkLite {
+    /** @hidden */
+    private constructor();
+    /**
+     * 事件
+     * @enum {string}
+     */
+    /** @hidden */
+    static EVENT: typeof EVENT;
+    /** @hidden */
+    static getInstance(): MujianSdkLite;
+    /** @hidden */
+    private parent;
+    /** @hidden */
+    private ready;
+    /**
+     * 是否初始化
+     */
+    /** @hidden */
+    get isReady(): boolean;
+    /** @hidden */
+    private pendingRequests;
+    /** @hidden */
+    private _config?;
+    /**
+     * 获取 API 配置
+     * @returns {{ baseURL: string, apiKey: string }} { baseURL: API 的 URL, apiKey: API 的 KEY }
+     */
+    get openapi(): Config['openapi'] | undefined;
+    /** @hidden */
+    private initPromise;
+    /**
+     * 初始化
+     */
+    init(): Promise<void>;
+    /** @hidden */
+    private ensureReady;
+    /** @hidden */
+    emit<T>(event: EVENT, data?: T): void;
+    /** @hidden */
+    private nextCallId;
+    /** @hidden */
+    private getCallId;
+    /** @hidden */
+    call<Req, Resp>(event: EVENT, data?: Req, controller?: Pick<Call<Resp>, 'onData' | 'onComplete' | 'signal'>): Promise<Resp>;
+}
+export default MujianSdkLite;