@nocobase/plugin-ai 2.1.0-beta.14 → 2.1.0-beta.16

package/dist/server/ai-employees/ai-knowledge-base.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { AIEmployee } from '../../collections/ai-employees';
+import { DocumentSegmentedWithScore } from '../features';
+import type PluginAIServer from '../plugin';
+export type KnowledgeBaseRetrieveOptions = {
+    username?: string;
+    employee?: AIEmployee;
+    query: string;
+};
+export declare class KnowledgeBaseManager {
+    private readonly plugin;
+    constructor(plugin: PluginAIServer);
+    retrievePrompt({ username, employee, query }: KnowledgeBaseRetrieveOptions): Promise<string>;
+    retrieve({ username, employee, query }: KnowledgeBaseRetrieveOptions): Promise<DocumentSegmentedWithScore[]>;
+    isEnabledKnowledgeBase(username: string): Promise<boolean>;
+    isEnabledKnowledgeBase(employee: AIEmployee): Promise<boolean>;
+    private getAIEmployeeKnowledgeBaseConfig;
+    private getKnowledgeBaseGroup;
+    private getEmployee;
+    private get aiEmployeeRepo();
+}

package/dist/server/ai-employees/ai-knowledge-base.js

@@ -0,0 +1,167 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_knowledge_base_exports = {};
+__export(ai_knowledge_base_exports, {
+  KnowledgeBaseManager: () => KnowledgeBaseManager
+});
+module.exports = __toCommonJS(ai_knowledge_base_exports);
+var import_prompts = require("@langchain/core/prompts");
+var import_ai_feature_manager = require("../manager/ai-feature-manager");
+var import_lodash = __toESM(require("lodash"));
+class KnowledgeBaseManager {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  async retrievePrompt({ username, employee, query }) {
+    employee = employee ?? await this.getEmployee(username);
+    if (!employee) {
+      return "Specified knowledge base not existed";
+    }
+    const promptTemplate = import_prompts.ChatPromptTemplate.fromTemplate(employee.knowledgeBasePrompt);
+    const docs = await this.retrieve({
+      employee,
+      query
+    });
+    if (!(docs == null ? void 0 : docs.length)) {
+      return "No document match in knowledge base";
+    }
+    const knowledgeBaseData = docs.map((x) => x.content).join("\n");
+    return import_lodash.default.isEmpty(knowledgeBaseData) ? void 0 : await promptTemplate.format({
+      knowledgeBaseData
+    });
+  }
+  async retrieve({ username, employee, query }) {
+    const vectorStoreProvider = this.plugin.features.vectorStoreProvider;
+    let queryResult = [];
+    if (!query || import_lodash.default.isEmpty(query)) {
+      return queryResult;
+    }
+    employee = employee ?? await this.getEmployee(username);
+    if (!employee) {
+      return queryResult;
+    }
+    const { topK, score } = this.getAIEmployeeKnowledgeBaseConfig(employee);
+    const knowledgeBaseGroup = await this.getKnowledgeBaseGroup(employee);
+    for (const entry of knowledgeBaseGroup) {
+      const { vectorStoreConfig, knowledgeBaseType, knowledgeBaseList } = entry;
+      if (!knowledgeBaseList || import_lodash.default.isEmpty(knowledgeBaseList)) {
+        continue;
+      }
+      if (knowledgeBaseType === "LOCAL") {
+        const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
+          vectorStoreConfig.vectorStoreProvider,
+          [
+            {
+              key: "vectorStoreConfigId",
+              value: vectorStoreConfig.vectorStoreConfigId
+            }
+          ]
+        );
+        const knowledgeBaseOuterIds = knowledgeBaseList.map((x) => x.knowledgeBaseOuterId);
+        const result = await vectorStoreService.search(query, {
+          topK,
+          score,
+          filter: {
+            knowledgeBaseOuterId: { in: knowledgeBaseOuterIds }
+          }
+        });
+        queryResult = [...queryResult, ...result];
+      } else if (knowledgeBaseType === "READONLY") {
+        for (const knowledgeBase of knowledgeBaseList) {
+          const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
+            vectorStoreConfig.vectorStoreProvider,
+            [
+              ...knowledgeBase.vectorStoreProps,
+              {
+                key: "vectorStoreConfigId",
+                value: vectorStoreConfig.vectorStoreConfigId
+              }
+            ]
+          );
+          const result = await vectorStoreService.search(query, {
+            topK,
+            score
+          });
+          queryResult = [...queryResult, ...result];
+        }
+      } else if (knowledgeBaseType === "EXTERNAL") {
+        for (const knowledgeBase of knowledgeBaseList) {
+          const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
+            vectorStoreConfig.vectorStoreProvider,
+            knowledgeBase.vectorStoreProps
+          );
+          const result = await vectorStoreService.search(query, {
+            topK,
+            score
+          });
+          queryResult = [...queryResult, ...result];
+        }
+      }
+    }
+    return queryResult;
+  }
+  async isEnabledKnowledgeBase(usernameOrEmployee) {
+    const featureEnabled = this.plugin.features.isFeaturesEnabled(Object.values(import_ai_feature_manager.EEFeatures));
+    const employee = typeof usernameOrEmployee === "string" ? await this.getEmployee(usernameOrEmployee) : usernameOrEmployee;
+    const knowledgeBaseEnabled = employee == null ? void 0 : employee.enableKnowledgeBase;
+    return featureEnabled && knowledgeBaseEnabled;
+  }
+  getAIEmployeeKnowledgeBaseConfig(employee) {
+    const { topK, score } = (employee == null ? void 0 : employee.knowledgeBase) ?? {};
+    return {
+      topK,
+      score
+    };
+  }
+  async getKnowledgeBaseGroup(employee) {
+    const { knowledgeBaseIds } = (employee == null ? void 0 : employee.knowledgeBase) ?? {};
+    if (!knowledgeBaseIds || import_lodash.default.isEmpty(knowledgeBaseIds)) {
+      return [];
+    }
+    return await this.plugin.features.knowledgeBase.getKnowledgeBaseGroup(knowledgeBaseIds);
+  }
+  async getEmployee(username) {
+    return await this.aiEmployeeRepo.findOne({ filter: { username } });
+  }
+  get aiEmployeeRepo() {
+    return this.plugin.db.getRepository("aiEmployees");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KnowledgeBaseManager
+});

package/dist/server/ai-employees/middleware/conversation.d.ts

@@ -26,6 +26,8 @@ export declare const conversationMiddleware: (aiEmployee: AIEmployee, options: {
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     ctx: z.ZodAny;
+    appendMessage: z.ZodAny;
 }, z.core.$strip>, {
     ctx: any;
+    appendMessage: any;
 }, readonly (import("@langchain/core/dist/tools").ClientTool | import("@langchain/core/dist/tools").ServerTool)[]>;

package/dist/server/ai-employees/middleware/conversation.js

@@ -77,7 +77,8 @@ const conversationMiddleware = (aiEmployee, options) => {
   return (0, import_langchain.createMiddleware)({
     name: "ConversationMiddleware",
     contextSchema: import_zod.default.object({
-      ctx: import_zod.default.any()
+      ctx: import_zod.default.any(),
+      appendMessage: import_zod.default.any()
     }),
     stateSchema: import_zod.default.object({
       messageId: import_zod.default.coerce.string().optional(),
@@ -125,13 +126,28 @@ const conversationMiddleware = (aiEmployee, options) => {
             toolMessages.map((x) => x.metadata.toolCallId)
           );
         });
-        (_a = runtime.writer) == null ? void 0 : _a.call(runtime, { action: "beforeSendToolMessage", body: { messageId: messageId2, messages: toolMessages } });
+        const currentConversation = {
+          sessionId: aiEmployee.sessionId,
+          username: aiEmployee.employee.username,
+          from: aiEmployee.from
+        };
+        (_a = runtime.writer) == null ? void 0 : _a.call(runtime, {
+          action: "beforeSendToolMessage",
+          body: { messageId: messageId2, messages: toolMessages },
+          currentConversation
+        });
       }
     },
     afterModel: async (state, runtime) => {
       var _a, _b, _c, _d, _e, _f;
       try {
+        const currentConversation = {
+          sessionId: aiEmployee.sessionId,
+          username: aiEmployee.employee.username,
+          from: aiEmployee.from
+        };
         const newState = {
+          messageId: state.messageId,
           lastMessageIndex: {
             lastHumanMessageIndex: state.messages.filter((x) => x.type === "human").length,
             lastAIMessageIndex: state.messages.filter((x) => x.type === "ai").length,
@@ -153,7 +169,7 @@ const conversationMiddleware = (aiEmployee, options) => {
         if (values) {
           await aiEmployee.aiChatConversation.withTransaction(async (conversation, transaction) => {
             const result = await conversation.addMessages(values);
-            state.messageId = result.messageId;
+            newState.messageId = result.messageId;
             if (toolCalls == null ? void 0 : toolCalls.length) {
               const toolsMap = await aiEmployee.getToolsMap();
               const initializedToolCalls = await aiEmployee.initToolCall(
@@ -166,19 +182,36 @@ const conversationMiddleware = (aiEmployee, options) => {
           });
           (_b = runtime.writer) == null ? void 0 : _b.call(runtime, {
             action: "AfterAIMessageSaved",
-            body: { id: aiMessage.id, messageId: state.messageId }
+            body: { id: aiMessage.id, messageId: newState.messageId },
+            currentConversation
           });
         }
         if (toolCalls == null ? void 0 : toolCalls.length) {
           (_c = runtime.writer) == null ? void 0 : _c.call(runtime, {
             action: "initToolCalls",
-            body: { toolCalls }
+            body: { toolCalls },
+            currentConversation
           });
         }
         return newState;
       } catch (e) {
         (_f = (_e = (_d = runtime.context) == null ? void 0 : _d.ctx) == null ? void 0 : _e.logger) == null ? void 0 : _f.error(e);
       }
+    },
+    wrapModelCall: async (request, handler) => {
+      const runtimeContext = request.runtime.context;
+      const appendMessage = runtimeContext == null ? void 0 : runtimeContext.appendMessage;
+      if (Array.isArray(appendMessage) && appendMessage.length) {
+        await aiEmployee.aiChatConversation.withTransaction(async (conversation) => {
+          await conversation.addMessages(convertToolMessage(request.messages.at(-1)));
+          await conversation.addMessages(appendMessage.map((x) => x).map(convertHumanMessage));
+        });
+        request.messages.push(...appendMessage);
+        if (runtimeContext) {
+          delete runtimeContext.appendMessage;
+        }
+      }
+      return handler(request);
     }
   });
 };

package/dist/server/ai-employees/middleware/index.d.ts

@@ -7,4 +7,6 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 export * from './conversation';
+export * from './skill-tools';
 export * from './tools';
+export * from './workflow-history';

package/dist/server/ai-employees/middleware/index.js

@@ -24,9 +24,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var middleware_exports = {};
 module.exports = __toCommonJS(middleware_exports);
 __reExport(middleware_exports, require("./conversation"), module.exports);
+__reExport(middleware_exports, require("./skill-tools"), module.exports);
 __reExport(middleware_exports, require("./tools"), module.exports);
+__reExport(middleware_exports, require("./workflow-history"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./conversation"),
-  ...require("./tools")
+  ...require("./skill-tools"),
+  ...require("./tools"),
+  ...require("./workflow-history")
 });

package/dist/server/ai-employees/middleware/skill-tools.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { AIEmployee } from '../ai-employee';
+export declare const skillToolBindingMiddleware: (aiEmployee: AIEmployee, options: {
+    baseToolNames: string[];
+}) => import("langchain/dist/agents/middleware/types.cjs").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/dist/tools").ClientTool | import("@langchain/core/dist/tools").ServerTool)[]>;

package/dist/server/ai-employees/middleware/skill-tools.js

@@ -0,0 +1,88 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var skill_tools_exports = {};
+__export(skill_tools_exports, {
+  skillToolBindingMiddleware: () => skillToolBindingMiddleware
+});
+module.exports = __toCommonJS(skill_tools_exports);
+var import_langchain = require("langchain");
+const skillToolBindingMiddleware = (aiEmployee, options) => {
+  const baseToolNames = new Set(options.baseToolNames ?? []);
+  const getAllowedToolNames = async () => {
+    const activatedSkillToolNames = await aiEmployee.getActivatedSkillToolNames();
+    return /* @__PURE__ */ new Set([...baseToolNames, ...activatedSkillToolNames]);
+  };
+  const getToolName = (tool) => {
+    var _a;
+    if (!tool || typeof tool !== "object") {
+      return null;
+    }
+    if (typeof tool.name === "string") {
+      return tool.name;
+    }
+    if (typeof ((_a = tool.function) == null ? void 0 : _a.name) === "string") {
+      return tool.function.name;
+    }
+    return null;
+  };
+  const filterRequestTools = async (tools = []) => {
+    const allowedToolNames = await getAllowedToolNames();
+    return tools.filter((tool) => {
+      const name = getToolName(tool);
+      if (name == null) {
+        return true;
+      }
+      return name && allowedToolNames.has(name);
+    });
+  };
+  return (0, import_langchain.createMiddleware)({
+    name: "SkillToolBindingMiddleware",
+    wrapModelCall: async (request, handler) => {
+      const tools = await filterRequestTools(request.tools ?? []);
+      return handler({
+        ...request,
+        tools
+      });
+    },
+    wrapToolCall: async (request, handler) => {
+      const allowedToolNames = await getAllowedToolNames();
+      if (!allowedToolNames.has(request.toolCall.name)) {
+        return new import_langchain.ToolMessage({
+          tool_call_id: request.toolCall.id,
+          name: request.toolCall.name,
+          status: "error",
+          content: "Tool unavailable."
+        });
+      }
+      return handler(request);
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  skillToolBindingMiddleware
+});

package/dist/server/ai-employees/middleware/tools.js

@@ -46,7 +46,16 @@ var import_lodash = __toESM(require("lodash"));
 const toolInteractionMiddleware = (aiEmployee, tools) => {
   const interruptOn = {};
   for (const tool of tools) {
-    interruptOn[tool.definition.name] = aiEmployee.shouldInterruptToolCall(tool);
+    interruptOn[tool.definition.name] = aiEmployee.shouldInterruptToolCall(tool) ? {
+      allowedDecisions: ["approve", "reject", "edit"],
+      description: (toolCall) => JSON.stringify({
+        sessionId: aiEmployee.sessionId,
+        from: aiEmployee.from,
+        username: aiEmployee.employee.username,
+        toolCallId: toolCall.id,
+        toolCallName: toolCall.name
+      })
+    } : false;
   }
   return (0, import_langchain.humanInTheLoopMiddleware)({
     interruptOn
@@ -60,13 +69,23 @@ const toolCallStatusMiddleware = (aiEmployee) => {
     }),
     wrapToolCall: async (request, handler) => {
       var _a, _b, _c, _d;
+      let interrupted = false;
       const { runtime, toolCall } = request;
       const { messageId } = request.state;
+      const currentConversation = {
+        sessionId: aiEmployee.sessionId,
+        username: aiEmployee.employee.username,
+        from: aiEmployee.from
+      };
       const tm = await aiEmployee.getToolCallResult(messageId, request.toolCall.id);
+      if (!tm) {
+        throw new Error(`Tool call result not found for messageId=${messageId}, toolCallId=${request.toolCall.id}`);
+      }
       if (tm.status === "error") {
         (_a = runtime.writer) == null ? void 0 : _a.call(runtime, {
           action: "afterToolCall",
-          body: { toolCall, toolCallResult: tm }
+          body: { toolCall, toolCallResult: tm },
+          currentConversation
         });
         return new import_langchain.ToolMessage({
           tool_call_id: request.toolCall.id,
@@ -78,7 +97,7 @@ const toolCallStatusMiddleware = (aiEmployee) => {
         });
       }
       await aiEmployee.updateToolCallPending(messageId, request.toolCall.id);
-      (_b = runtime.writer) == null ? void 0 : _b.call(runtime, { action: "beforeToolCall", body: { toolCall } });
+      (_b = runtime.writer) == null ? void 0 : _b.call(runtime, { action: "beforeToolCall", body: { toolCall }, currentConversation });
       let result;
       try {
         const toolMessage = await handler(request);
@@ -100,11 +119,16 @@ const toolCallStatusMiddleware = (aiEmployee) => {
         }
         return toolMessage;
       } catch (e) {
+        if (e.name === "GraphInterrupt") {
+          interrupted = true;
+          throw e;
+        }
         aiEmployee.logger.error(e);
         result = { status: "error", content: e.message };
         (_c = runtime.writer) == null ? void 0 : _c.call(runtime, {
           action: "afterToolCallError",
-          body: { toolCall, error: e }
+          body: { toolCall, error: e },
+          currentConversation
         });
         return new import_langchain.ToolMessage({
           tool_call_id: request.toolCall.id,
@@ -115,12 +139,15 @@ const toolCallStatusMiddleware = (aiEmployee) => {
           }
         });
       } finally {
-        await aiEmployee.updateToolCallDone(messageId, request.toolCall.id, result);
-        const toolCallResult = await aiEmployee.getToolCallResult(messageId, request.toolCall.id);
-        (_d = runtime.writer) == null ? void 0 : _d.call(runtime, {
-          action: "afterToolCall",
-          body: { toolCall, toolCallResult }
-        });
+        if (!interrupted) {
+          await aiEmployee.updateToolCallDone(messageId, request.toolCall.id, result);
+          const toolCallResult = await aiEmployee.getToolCallResult(messageId, request.toolCall.id);
+          (_d = runtime.writer) == null ? void 0 : _d.call(runtime, {
+            action: "afterToolCall",
+            body: { toolCall, toolCallResult },
+            currentConversation
+          });
+        }
       }
     }
   });

package/dist/server/ai-employees/middleware/workflow-history.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Database } from '@nocobase/database';
+import { createMiddleware } from 'langchain';
+import { AIEmployee } from '../ai-employee';
+export declare class WorkflowJobsLogHandler {
+    private readonly db;
+    private readonly sessionId;
+    constructor(db: Database, sessionId: string);
+    append(entries: Array<{
+        type: 'toolMessage' | 'toolCall';
+        toolCallId?: string;
+        value: unknown;
+    }>): Promise<void>;
+}
+export declare const workflowHistoryMiddleware: (aiEmployee: AIEmployee, db: Database) => ReturnType<typeof createMiddleware>;