@aidejs/core 0.1.0-alpha.2 → 0.1.0-beta.0

package/README.md

@@ -1,14 +1,8 @@
-<img src="./docs/images/logo.png" />
+<img src="https://NN-Studio.github.io/Aidejs/images/logo.png" />
 
 # [Aidejs](https://github.com/NN-Studio/Aidejs)
 一个用于构建人工智能代理的JavaScript框架，它提供了一组工具和库，使创建智能应用程序变得轻松和高效
 
-## 功能列表
-
-通过类似拼积木的方式，你可以轻松地组合各个模块完成个性化的 AI 应用开发。
-
-下面是可用模块：
-
 <p>
     <a href="https://github.com/NN-Studio/Aidejs/issues">
         <img src="https://img.shields.io/github/issues/NN-Studio/Aidejs" alt="issue">
@@ -19,29 +13,56 @@
     <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>
 
+## 功能列表
+
+通过类似拼积木的方式，你可以轻松地组合各个模块完成个性化的 AI 应用开发。
+
+下面是可用模块：
+
 <table>
     <thead>
         <tr>
             <td>名称</td>
             <td>简介</td>
-            <td>地址</td>
+            <td>下周统计</td>
+            <td>最新版本</td>
         </tr>
     </thead>
     <tbody>
         <tr>
             <td>@aidejs/core</td>
-            <td>必选项，基础库，提供了最核心的LLM交互功能和插件系统</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.2",
+    "version": "0.1.0-beta.0",
     "description": "@aidejs/core",
     "main": "./src/index.js",
     "typings": "./types/index.d.ts",

package/src/Memory.js

@@ -0,0 +1,41 @@
+module.exports = class Memory {
+
+    constructor(messages = []) {
+        this.messages = messages;
+        this.message_value = ""; // 当前流缓存值
+        this.message_type = ""; // 当前流类型
+    }
+
+    // 直接添加一次新信息
+    // 前置的流会关闭，开始一次新的待整理流
+    push(value) {
+        this.generate("");
+        this.messages.push(value);
+    }
+
+    // 完结或整理一次流信息
+    generate(newType) {
+        if (this.message_value) {
+            this.messages.push({
+                role: this.message_type,
+                content: this.message_value
+            });
+        }
+
+        this.message_type = newType;
+        this.message_value = "";
+    }
+
+    // 输入一个词元的助手信息
+    assistant(lexeme) {
+        if (this.message_type !== "assistant") this.generate("assistant");
+        this.message_value += lexeme;
+    }
+
+    // 获取记忆内容
+    valueOf() {
+        this.generate("");
+        return this.messages;
+    }
+
+}

package/src/{utils/OpenAI.js → OpenAI.js}

@@ -1,6 +1,6 @@
 const https = require('https');
 const http = require('http');
-const toJSON = require("./toJSON");
+const { toJSON } = require("./utils");
 
 module.exports = function (url, options = {}, databack, callback, errorback) {
 

package/src/Tool.js

@@ -1,3 +1,5 @@
+const { debug } = require("./utils");
+
 module.exports = class Tool {
 
     constructor() {
@@ -26,7 +28,13 @@ module.exports = class Tool {
         if (!this.tools[name]) {
             throw new Error(`工具${name}不存在`);
         }
-        return this.tools[name].valueOf.call(aidejs, 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,17 +1,21 @@
 const { initOption } = require("oipage/nodejs/option/index");
-const OpenAI = require("./utils/OpenAI");
-const Tool = require("./Tool.js");
+const OpenAI = require("./OpenAI");
+const Tool = require("./Tool");
+const Memory = require("./Memory");
+const { debug } = require("./utils");
 
 module.exports = class Aidejs {
 
-    // 工具管理对象
-    static tool = new Tool();
+    static tool = new Tool(); // 工具管理对象
+    static messages = [];
 
     constructor(options = {}) {
         this.options = initOption(options, {
+            debug: false,
             model: "",
             url: "http://localhost:11434/v1",
-            apiKey: ""
+            apiKey: "",
+            messages: []
         });
 
         if (!this.options.model) {
@@ -33,22 +37,15 @@ module.exports = class Aidejs {
 
     // 执行任务
     task(message, logback, inputback, thinkback) {
-        let _this = this;
+        let _this = this, toolCalls = false;
 
-        let messages = [], lastIndex = -1, toolCalls = false;
-
-        let resetLastIndex = () => {
-            messages.push({
-                role: "assistant",
-                content: ""
-            });
-            lastIndex = messages.length - 1;
-        };
+        // 记忆管理对象
+        let memory = new Memory([...Aidejs.messages, ..._this.options.messages]);
 
         let runInputback = () => {
             if (inputback) {
                 inputback().then(message => {
-                    messages.push({
+                    memory.push({
                         role: "user",
                         content: message
                     });
@@ -62,15 +59,80 @@ module.exports = class Aidejs {
         };
 
         let runChat = () => {
-            OpenAI(this.options.url + "/chat/completions", {
+            let tools = Aidejs.tool.valueOf();
+
+            if (_this.options.debug) {
+                debug("OpenAI messages", memory.valueOf());
+                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}`
+                    Authorization: `Bearer ${_this.options.apiKey}`
                 },
                 params: {
-                    model: this.options.model,
-                    messages,
-                    tools: Aidejs.tool.valueOf(),
-                    stream: true
+
+                    // 必需，模型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: memory.valueOf(),
+
+                    // 用户可选的一个字段，是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 {
@@ -83,11 +145,15 @@ module.exports = class Aidejs {
 
                         if (choice.delta.content) {
                             if (logback) logback(choice.delta.content);
+                            memory.assistant(choice.delta.content);
                         } else if (choice.delta.reasoning) {
                             if (thinkback) thinkback(choice.delta.reasoning);
                         }
 
                         if (choice.delta.tool_calls) {
+                            memory.push(choice.delta);
+
+                            if (_this.options.debug) debug("tool_calls", choice.delta.tool_calls);
 
                             // 执行一次工具
                             let runTool = (toolIndex) => {
@@ -99,8 +165,9 @@ module.exports = class Aidejs {
                                     let result = Aidejs.tool.invoke(_this, tool_call.function.name, JSON.parse(tool_call.function.arguments));
 
                                     let toolback = function (value) {
-                                        messages.push({
+                                        memory.push({
                                             role: "tool",
+                                            tool_call_id: tool_call.id,
                                             tool_name: tool_call.function.name,
                                             content: typeof value === "string" ? value : (JSON.stringify(value) + "")
                                         });
@@ -111,7 +178,7 @@ module.exports = class Aidejs {
                                         result.then(function (value) {
                                             toolback(value);
                                         }).catch(function (error) {
-                                            toolback(error + "");
+                                            toolback(error || "失败");
                                         });
                                     } else {
                                         toolback(result);
@@ -120,15 +187,13 @@ module.exports = class Aidejs {
                             };
                             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) {
@@ -138,16 +203,14 @@ module.exports = class Aidejs {
                     runInputback();
                 }
             }, function (e) {
-                console.error("对接LLM解答问题时发生错误：", e);
+                debug("对接LLM解答问题时发生错误", e);
                 toolCalls = false;
                 runInputback();
             });
-
-            resetLastIndex();
         };
 
         if (message) {
-            messages.push({
+            memory.push({
                 role: "user",
                 content: message
             });
@@ -155,8 +218,6 @@ module.exports = class Aidejs {
         } else {
             runInputback();
         }
-
-        return this;
     }
 
 };

package/src/utils.js

@@ -0,0 +1,17 @@
+// 打印调试语句
+exports.debug = function (name, content) {
+    console.log("\n\x1b[33m【" + name + "】 " + new Date().toString() + "\x1b[0m");
+    console.log(content);
+    console.log("\x1b[33m[DONE]\x1b[0m\n");
+};
+
+// 字符串转JSON
+// 适配LLM返回数据格式
+exports.toJSON = function (value) {
+    try {
+        value = value.trim().replace(/data: \[DONE\]$/, "");
+        return JSON.parse(value);
+    } catch (e) {
+        return value;
+    }
+};

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>
     })
 
     /**
@@ -14,7 +16,7 @@ export default class Aidejs {
      * @param name 
      * @param value 
      */
-    static registerTool(name: string, value: any): void
+    static registerTool(name: string, value: any): Aidejs
 
     /**
      * 安装插件
@@ -26,6 +28,6 @@ export default class 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): void
 
 }

package/src/utils/toJSON.js

@@ -1,8 +0,0 @@
-module.exports = function (value) {
-    try {
-        value = value.trim().replace(/data: \[DONE\]$/, "");
-        return JSON.parse(value);
-    } catch (e) {
-        return value;
-    }
-}