@aidejs/core 0.1.0-alpha.1 → 0.1.0-alpha.3

package/README.md

@@ -13,6 +13,12 @@
     <a href="https://github.com/NN-Studio/Aidejs">
         <img src="https://img.shields.io/github/forks/NN-Studio/Aidejs" alt="forks">
     </a>
+    <a href="https://gitee.com/NN-Studio/Aidejs" target='_blank'>
+        <img alt="Gitee repo stars" src="https://gitee.com/NN-Studio/Aidejs/badge/star.svg">
+    </a>
+    <a href="https://gitee.com/NN-Studio/Aidejs">
+        <img src="https://gitee.com/NN-Studio/Aidejs/badge/fork.svg" alt="forks">
+    </a>
 </p>
 
 ## 功能列表
@@ -26,7 +32,8 @@
         <tr>
             <td>名称</td>
             <td>简介</td>
-            <td>地址</td>
+            <td>下周统计</td>
+            <td>最新版本</td>
         </tr>
     </thead>
     <tbody>
@@ -34,14 +41,28 @@
             <td>@aidejs/core</td>
             <td>必选项，基础库，提供了最核心的LLM交互功能和插件系统</td>
             <td>
-                <a href="https://www.npmjs.com/package/@aidejs/core" target="_blank">访问</a>
+                <a href="https://zxl20070701.github.io/toolbox/#/npm-download?packages=@aidejs/core&interval=7">
+                    <img src="https://img.shields.io/npm/dm/@aidejs/core.svg" alt="downloads">
+                </a>
+            </td>
+            <td>
+                <a href="https://www.npmjs.com/package/@aidejs/core">
+                    <img src="https://img.shields.io/npm/v/@aidejs/core.svg" alt="npm">
+                </a>
             </td>
         </tr>
         <tr>
             <td>@aidejs/tools</td>
             <td>非必选，工具库，提供了各种实用的工具函数</td>
             <td>
-                <a href="https://www.npmjs.com/package/@aidejs/tools" target="_blank">访问</a>
+                <a href="https://zxl20070701.github.io/toolbox/#/npm-download?packages=@aidejs/tools&interval=7">
+                    <img src="https://img.shields.io/npm/dm/@aidejs/tools.svg" alt="downloads">
+                </a>
+            </td>
+            <td>
+                <a href="https://www.npmjs.com/package/@aidejs/tools">
+                    <img src="https://img.shields.io/npm/v/@aidejs/tools.svg" alt="npm">
+                </a>
             </td>
         </tr>
     </tbody>

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@aidejs/core",
-    "version": "0.1.0-alpha.1",
+    "version": "0.1.0-alpha.3",
     "description": "@aidejs/core",
     "main": "./src/index.js",
     "typings": "./types/index.d.ts",

package/src/Tool.js

@@ -1,3 +1,5 @@
+const debug = require("./utils/debug");
+
 module.exports = class Tool {
 
     constructor() {
@@ -22,11 +24,17 @@ module.exports = class Tool {
     }
 
     // 工具调用
-    invoke(name, args) {
+    invoke(aidejs, name, args) {
         if (!this.tools[name]) {
             throw new Error(`工具${name}不存在`);
         }
-        return this.tools[name].valueOf(args);
+        let value = this.tools[name].valueOf.call(aidejs, args);
+        if (aidejs.options.debug) {
+            debug("工具调用", {
+                name, args, value
+            });
+        }
+        return value;
     }
 
 };

package/src/index.js

@@ -1,6 +1,7 @@
 const { initOption } = require("oipage/nodejs/option/index");
 const OpenAI = require("./utils/OpenAI");
-const Tool = require("./Tool.js");
+const Tool = require("./Tool");
+const debug = require("./utils/debug");
 
 module.exports = class Aidejs {
 
@@ -9,9 +10,11 @@ module.exports = class Aidejs {
 
     constructor(options = {}) {
         this.options = initOption(options, {
+            debug: false,
             model: "",
             url: "http://localhost:11434/v1",
-            apiKey: ""
+            apiKey: "",
+            messages: []
         });
 
         if (!this.options.model) {
@@ -25,15 +28,17 @@ module.exports = class Aidejs {
         return Aidejs;
     }
 
-    // 安装插件，比如可用工具tool或技能skill等
-    static use(plugin) {
-        plugin.install(Aidejs);
+    // 安装插件
+    static use(plugin, options = {}) {
+        plugin.install(Aidejs, options);
         return Aidejs;
     }
 
     // 执行任务
-    task(message, logback, inputback) {
-        let messages = [], lastIndex = -1, toolCalls = false;
+    task(message, logback, inputback, thinkback) {
+        let _this = this;
+
+        let messages = [..._this.options.messages], lastIndex = -1, toolCalls = false;
 
         let resetLastIndex = () => {
             messages.push({
@@ -60,79 +65,152 @@ module.exports = class Aidejs {
         };
 
         let runChat = () => {
+            let tools = Aidejs.tool.valueOf();
+
+            if (this.options.debug) {
+                debug("OpenAI messages", messages);
+                debug("OpenAI tools", tools.map(function (funItem) {
+                    return funItem.function.name + " " + funItem.function.description;
+                }));
+            }
+
             OpenAI(this.options.url + "/chat/completions", {
                 header: {
                     Authorization: `Bearer ${this.options.apiKey}`
                 },
                 params: {
+
+                    // 必需，模型ID，也就是你选择的具体哪个模型
                     model: this.options.model,
+
+                    // 必需，提供的array类型的消息列表，包含从头到尾的对话历史
+                    // 比如值是一个数组，每个条目可以是下列类型之一：
+                    // （所有的类型其实都应该是一个json对象，下面列出的都是其包含的字段）
+                    // 1、System message
+                    // content：必须提供的string类型，表示system的消息内容
+                    // role：必须提供的string类型，表示消息作者的角色，对于system message应该是"system"
+                    // name：可选的string类型，表示对话参与者的名称
+                    // 2、User message
+                    // content：必须提供的string或array类型，二选一，表示user的消息内容
+                    //      为string类型时，表示消息的文本内容
+                    //      为array类型时，用来包含多个内容部分的数组，而此数组的每个条目都是一个json对象，可以分别是如下类型之一 
+                    //          1）文本
+                    //              type：必须提供的string类型，表示内容部分的类型，一般是“text”
+                    //              text：必须提供的string类型，文字内容
+                    //          2）图片
+                    //              type：必须提供的string类型，表示内容部分的类型，一般是"image_url"
+                    //              image_url：必须提供的string类型，图像的 URL 或 Base64 编码的图像数据   
+                    // role：必须提供的string类型，表示消息作者的角色，对于user message应该是"user"
+                    // name：可选的string类型，表示对话参与者的名称
+                    // 3、Assistant message（实际代码就是下面的choice.delta的值）
+                    // content：必须提供(指定 tool_calls 时除外)的string类型，表示助手消息的内容
+                    // role：必须提供的string类型，表示消息作者的角色，对于assistant message应该是"assistant"
+                    // name：可选的string类型，表示对话参与者的名称
+                    // tool_calls：可选的array类型，大模型生成的工具调用，例如函数调用，用这里代码打印的例子：
+                    // [
+                    //   {
+                    //     id: 'call_graj8v5e', // 必须提供，表示函数调用的id
+                    //     index: 0,
+                    //     type: 'function', // 必须提供，表示工具调用的类型（目前仅支持“function”类型）。
+                    //     function: {
+                    //       name: 'aidejs_disk_readPlain', // 必须提供，要调用的函数的名称
+                    //       arguments: '{"filepath":"./.mailmap"}' // 必须提供，表示调用函数所用的参数
+                    //     }
+                    //   }
+                    // ]
+                    // 4、Tool message
+                    // 一个json对象，在用户根据assistant的tool_calls内容调用了某个函数后，
+                    // 用户可能还需要再把函数调用结果反馈给大模型，让大模型根据函数调用结果给出最终的总结性的答复
+                    // content：必须提供的string类型，表示工具消息的内容，一般是把函数调用的结果描述在这里
+                    // role：必须提供的string类型，表示消息作者的角色，对于tool message应该是"tool"
+                    // tool_call_id：必须提供的string类型，表示本次消息是对哪个函数调用的结果反馈
                     messages,
-                    tools: Aidejs.tool.valueOf(),
-                    stream: true
+
+                    // 用户可选的一个字段，是array类型，表示可供模型选择的一个工具列表
+                    // 列表中最多支持 128 个tool
+                    // 具体说明可以查看 /packages/tools/src/disk/readPlain.js
+                    tools,
+
+                    // 可选的bool值，如果设置了true，将会流式的返回消息
+                    stream: true,
+
+                    // softmax 函数中的除数，温度越低，生成的结果越确定，温度越高，生成的结果越随机
+                    // temperature: 0.7,
+
+                    // 类似的有这些策略：TopP、TopK、MinP，分别表示前若干个累积积累和、前K名、最低概率
+                    // top_p: 0.8,
                 }
             }, function (chunk) {
                 try {
 
                     // 执行一次回复
                     let runChoice = (choiceIndex) => {
-                        if (choiceIndex >= chunk.choices.length) return;
+                        if (choiceIndex >= chunk.choices.length) { return; }
 
                         let choice = chunk.choices[choiceIndex];
 
-                        if (choice.finish_reason) {
-                            if (toolCalls) {
-                                toolCalls = false;
-                                runChat();
-                            } else {
-                                runInputback();
-                            }
-                        } else {
-                            logback(choice.delta.content || "");
-
-                            if (choice.delta.tool_calls) {
+                        if (choice.delta.content) {
+                            if (logback) logback(choice.delta.content);
+                        } else if (choice.delta.reasoning) {
+                            if (thinkback) thinkback(choice.delta.reasoning);
+                        }
 
-                                // 执行一次工具
-                                let runTool = (toolIndex) => {
-                                    if (toolIndex >= choice.delta.tool_calls.length) {
-                                        toolCalls = true;
-                                        runChoice(choiceIndex + 1);
+                        if (choice.delta.tool_calls) {
+                            if (_this.options.debug) debug("tool_calls", choice.delta.tool_calls);
+
+                            // 执行一次工具
+                            let runTool = (toolIndex) => {
+                                if (toolIndex >= choice.delta.tool_calls.length) {
+                                    toolCalls = true;
+                                    runChoice(choiceIndex + 1);
+                                } else {
+                                    let tool_call = choice.delta.tool_calls[toolIndex];
+                                    let result = Aidejs.tool.invoke(_this, tool_call.function.name, JSON.parse(tool_call.function.arguments));
+
+                                    let toolback = function (value) {
+                                        messages.push({
+                                            role: "tool",
+                                            tool_call_id: tool_call.id,
+                                            tool_name: tool_call.function.name,
+                                            content: typeof value === "string" ? value : (JSON.stringify(value) + "")
+                                        });
+                                        runTool(toolIndex + 1);
+                                    };
+
+                                    if (typeof result === "object" && result.constructor === Promise) {
+                                        result.then(function (value) {
+                                            toolback(value);
+                                        }).catch(function (error) {
+                                            toolback(error + "");
+                                        });
                                     } else {
-                                        let tool_call = choice.delta.tool_calls[toolIndex];
-                                        let result = Aidejs.tool.invoke(tool_call.function.name, JSON.parse(tool_call.function.arguments));
-
-                                        let toolback = function (value) {
-                                            messages.push({
-                                                role: "tool",
-                                                tool_name: tool_call.function.name,
-                                                content: typeof value === "string" ? value : (JSON.stringify(value) + "")
-                                            });
-                                            runTool(toolIndex + 1);
-                                        };
-
-                                        if (typeof result === "object" && result.constructor === Promise) {
-                                            result.then(function (value) {
-                                                toolback(value);
-                                            }).catch(function (error) {
-                                                toolback(error + "");
-                                            });
-                                        } else {
-                                            toolback(result);
-                                        }
+                                        toolback(result);
                                     }
-                                };
-                                runTool(0);
-                            } else {
-                                if (messages[lastIndex].role !== "assistant") resetLastIndex();
-                                messages[lastIndex].content += choice.delta.content || "";
-                                runChoice(choiceIndex + 1);
-                            }
+                                }
+                            };
+                            runTool(0);
+                        } else {
+                            if (messages[lastIndex].role !== "assistant") resetLastIndex();
+                            messages[lastIndex].content += choice.delta.content || "";
+                            runChoice(choiceIndex + 1);
                         }
 
                     };
                     runChoice(0);
                 } catch (e) {
-                    console.error("处理智能体响应时发生错误：", e);
+                    debug("处理智能体响应时发生错误", e);
+                }
+            }, function () {
+                if (toolCalls) {
+                    toolCalls = false;
+                    runChat();
+                } else {
+                    runInputback();
                 }
+            }, function (e) {
+                debug("对接LLM解答问题时发生错误", e);
+                toolCalls = false;
+                runInputback();
             });
 
             resetLastIndex();

package/src/utils/OpenAI.js

@@ -16,19 +16,13 @@ module.exports = function (url, options = {}, databack, callback, errorback) {
         method: "POST",
         headers: options.header || {}
     }, (res) => {
-
-        let data = "";
         res.on('data', (chunk) => {
-            chunk = chunk.toString().replace(/^data: /, "");
-
-            // 没有callback的情况下，data不累积，直接把chunk传给databack，适合流式处理
-            // 有callback的情况下，data累积chunk，等end事件触发时一次性调用callback，适合非流式处理
-            if (callback) data += chunk;
-
-            if (databack) databack(toJSON(chunk));
+            // 这里data不累积，直接把chunk传给databack，流式处理
+            // 如何后续希望callback中返回数据，那么data累积chunk，等end事件触发时一次性调用callback，非流式处理
+            if (databack) databack(toJSON(chunk.toString().replace(/^data: /, "")));
         });
         res.on('end', () => {
-            if (callback) callback(toJSON(data));
+            if (callback) callback();
         });
     });
 

package/src/utils/debug.js

@@ -0,0 +1,5 @@
+module.exports = function (name, content) {
+    console.log("\n\x1b[33m【" + name + "】 " + new Date().toString() + "\x1b[0m");
+    console.log(content);
+    console.log("\x1b[33m---------------------------------------------------------------------\x1b[0m\n");
+}

package/types/index.d.ts

@@ -4,9 +4,11 @@
 export default class Aidejs {
 
     constructor(options: {
-        model: string,
-        url?: string,
+        debug?: boolean
+        model: string
+        url?: string
         apiKey?: string
+        messages?: Array<any>
     })
 
     /**
@@ -20,12 +22,12 @@ export default class Aidejs {
      * 安装插件
      * @param plugin 
      */
-    static use(plugin: any): Aidejs
+    static use(plugin: any, options?: any): Aidejs
 
     /**
      * 执行任务
      * @param message 
      */
-    task(message: string, logback: (message: string) => void, inputback: () => Promise<string>): this
+    task(message?: string, logback?: (message: string) => void, inputback?: () => Promise<string>, thinkback?: (think: string) => void): this
 
 }