@mujian/js-sdk 0.0.6-beta.6 → 0.0.6-beta.61

package/dist/events/index.d.ts

@@ -21,13 +21,29 @@ export declare enum EVENT {
      */
     MUJIAN_AI_CHAT_APPLY_REGEX = "mujian:ai:chat:applyRegex",
     /**
-     * 生成文本
+     * 文本补全
      */
     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 +83,13 @@ 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"
 }

package/dist/index.d.ts

@@ -14,7 +14,13 @@ declare global {
     }
 }
 declare class MujianSdk {
+    /** @hidden */
     private constructor();
+    /**
+     * 事件
+     * @enum {string}
+     */
+    static EVENT: typeof EVENT;
     /** @hidden */
     static getInstance(): MujianSdk;
     /** @hidden */
@@ -40,47 +46,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

@@ -5,7 +5,11 @@ var events_EVENT = /*#__PURE__*/ function(EVENT) {
     EVENT["MUJIAN_AI_CHAT_COMPLETE"] = "mujian:ai:chat:complete";
     EVENT["MUJIAN_AI_CHAT_APPLY_REGEX"] = "mujian:ai:chat:applyRegex";
     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,13 +20,59 @@ 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";
     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
     });
 };
@@ -70,6 +120,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 +148,22 @@ 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'
-    });
-};
 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;
@@ -113,9 +176,14 @@ class MujianSdk {
     pendingRequests = new Map();
     async init() {
         const handshake = new postmate.Model({
-            reply: ({ id, complete, data })=>{
+            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?.();
@@ -128,10 +196,18 @@ class MujianSdk {
             const parent = await handshake;
             this.ready = true;
             this.parent = parent;
-            console.log('mujian sdk client init');
+            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);
+            }
         } catch (error) {
-            console.log('init error', error);
+            Log.e('init error', error);
         }
     }
     emit(event, data) {
@@ -189,17 +265,234 @@ 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 = {};
+    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();
+    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;
+                }
+                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);
+            }
+        } catch (error) {
+            Log.e('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(events_EVENT.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: 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 = {};
-    util = {
-        cn: ()=>{
-            console.log('cn');
+    utils = {
+        clipboard: {
+            writeText: writeText.bind(this)
         }
     };
     hybrid = {};
@@ -217,4 +510,4 @@ class MujianSdk {
         }
     };
 }
-export { events_EVENT as EVENT, MujianSdk };
+export { events_EVENT as EVENT, src_MujianSdk as MujianSdk };

package/dist/modules/ai/chat/chat.d.ts

@@ -1,15 +1,52 @@
 import type { MujianSdk } from '../../../index.ts';
 import { Message } from '../../../react';
+/**
+ * LLM生成返回的数据
+ */
+export type ParsedData = {
+    /** 是否已完成生成，最后一块数据时为true */
+    isFinished: boolean;
+    /** LLM生成的delta content */
+    deltaContent: string;
+    /** LLM生成的累积内容 */
+    fullContent: string;
+    /** 出错时非空 */
+    error?: unknown;
+    /** 用户发送消息的ID */
+    questionId?: string;
+    /** AI返回消息的ID */
+    replyId?: string;
+};
+/**
+ * 对话补全配置
+ */
+export type CompleteOption = {
+    /** 给onData传递的数据是否是解析后的，推荐true */
+    parseContent?: boolean;
+};
 /**
  * 对话补全
- * @param {string} message 消息
- * @param {Function} onData 数据
- * @param {AbortSignal} signal 信号
  * @returns {Promise<string>} 返回值
  */
 export declare const complete: (
 /** @hidden */
-this: MujianSdk, message: string, onData: (data: string) => void, signal?: AbortSignal) => Promise<string>;
+this: MujianSdk, 
+/**
+ * 消息
+ */
+message: string, 
+/**
+ * 数据生成时的回调
+ */
+onData: (data: string | ParsedData) => void, 
+/**
+ * 停止生成的信号
+ */
+signal?: AbortSignal | undefined, 
+/**
+ * 对话补全配置
+ */
+option?: CompleteOption | undefined) => Promise<void>;
 export declare const applyRegex: (this: MujianSdk, props: {
     message: Message;
     index: number;

package/dist/modules/ai/chat/index.d.ts

@@ -1,4 +1,4 @@
-export { applyRegex, complete, continueComplete, regenerate } from './chat';
+export { applyRegex, type CompleteOption, complete, continueComplete, type ParsedData, regenerate, } from './chat';
 export * as message from './message';
 export * as project from './project';
 export * as settings from './settings';

package/dist/modules/ai/chat/message/index.d.ts

@@ -1,5 +1,6 @@
 import type { MujianSdk } from '../../../../index.ts';
 import type { Message } from '../../../../react/chat/useChat/message';
+import { Cursor } from '../../../../types';
 /**
  * 获取消息列表
  * @returns 消息当前列表
@@ -41,3 +42,6 @@ this: MujianSdk, messageId: string, swipeId: number) => Promise<unknown>;
 export declare const getPrompt: (
 /** @hidden */
 this: MujianSdk, messageId: string) => Promise<unknown>;
+export declare function getPage(
+/** @hidden */
+this: MujianSdk, fromCursor: Cursor, pageSize: number): Promise<unknown>;

package/dist/modules/ai/index.d.ts

@@ -1,5 +1,6 @@
 /**
  * @module ai
  */
-export * as chat from './chat';
-export * as text from './text';
+export * as chat from "./chat";
+export * as text from "./text";
+export * as openai from "./openai";

package/dist/modules/ai/openai/chat.d.ts

@@ -0,0 +1,25 @@
+import { MujianSdk } from '../../../index';
+import type OpenAI from 'openai';
+/**
+ * @namespace openai.chat
+ * @description OpenAI 聊天补全
+ */
+export declare const chat: {
+    /**
+     * @namespace openai.chat.completions
+     * @description OpenAI 聊天补全
+     */
+    completions: {
+        /**
+         * OpenAI 聊天补全
+         * @function openai.chat.completions.create
+         * @async
+         * @param {OpenAI.ChatCompletionCreateParams} params - 聊天补全参数
+         * @param {OpenAI.RequestOptions} options - 聊天补全选项
+         * @param {Function} onData - 数据生成时的回调
+         * @param {AbortSignal} signal - 停止生成的信号
+         * @returns {Promise<void>} 聊天补全结果
+         */
+        create: (this: MujianSdk, params: OpenAI.ChatCompletionCreateParams, options?: OpenAI.RequestOptions, onData?: (data: unknown) => void, signal?: AbortSignal | undefined) => Promise<OpenAI.ChatCompletion>;
+    };
+};

package/dist/modules/ai/openai/completions.d.ts

@@ -0,0 +1,19 @@
+import { MujianSdk } from '../../../index';
+import type OpenAI from 'openai';
+/**
+ * @namespace openai.completions
+ * @description OpenAI 文本补全
+ */
+export declare const completions: {
+    /**
+     * OpenAI 文本补全
+     * @function openai.completions.create
+     * @async
+     * @param {OpenAI.CompletionCreateParams} params - 文本补全参数
+     * @param {OpenAI.RequestOptions} options - 文本补全选项
+     * @param {Function} onData - 数据生成时的回调
+     * @param {AbortSignal} signal - 停止生成的信号
+     * @returns {Promise<void>} 文本补全结果
+     */
+    create: (this: MujianSdk, params: OpenAI.CompletionCreateParams, options?: OpenAI.RequestOptions, onData?: (data: unknown) => void, signal?: AbortSignal | undefined) => Promise<OpenAI.Completion>;
+};

package/dist/modules/ai/openai/images.d.ts

@@ -0,0 +1,19 @@
+import { MujianSdk } from '../../../index';
+import type OpenAI from 'openai';
+/**
+ * @namespace openai.images
+ * @description OpenAI 图像生成
+ */
+export declare const images: {
+    /**
+      * OpenAI 图像生成
+     * @function openai.images.generate
+     * @async
+     * @param {OpenAI.ImageGenerateParams} params - 图像生成参数
+     * @param {OpenAI.RequestOptions} options - 图像生成选项
+     * @param {Function} onData - 数据生成时的回调
+     * @param {AbortSignal} signal - 停止生成的信号
+     * @returns {Promise<OpenAI.ImagesResponse>} 图像生成结果
+     */
+    generate: (this: MujianSdk, params: OpenAI.ImageGenerateParams, options?: OpenAI.RequestOptions, onData?: (data: unknown) => void, signal?: AbortSignal | undefined) => Promise<OpenAI.ImagesResponse>;
+};

package/dist/modules/ai/openai/index.d.ts

@@ -0,0 +1,4 @@
+export * from './chat';
+export * from './completions';
+export * from './responses';
+export * from './images';

package/dist/modules/ai/openai/responses.d.ts

@@ -0,0 +1,20 @@
+import { MujianSdk } from '../../../index';
+import type OpenAI from 'openai';
+import type { ResponseCreateParams } from 'openai/resources/responses/responses.mjs';
+/**
+ * @namespace openai.responses
+ * @description OpenAI 响应创建
+ */
+export declare const responses: {
+    /**
+     * OpenAI 响应创建
+     * @function openai.responses.create
+     * @async
+     * @param {ResponseCreateParams} params - 响应创建参数
+     * @param {OpenAI.RequestOptions} options - 响应创建选项
+     * @param {Function} onData - 数据生成时的回调
+     * @param {AbortSignal} signal - 停止生成的信号
+     * @returns {Promise<void>} 响应创建结果
+     */
+    create: (this: MujianSdk, params: ResponseCreateParams, options?: OpenAI.RequestOptions, onData?: (data: unknown) => void, signal?: AbortSignal | undefined) => Promise<OpenAI.Responses>;
+};