@nocobase/plugin-ai 2.2.0-beta.1 → 2.2.0-beta.10

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

@@ -42,115 +42,51 @@ 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"));
+const normalizeMatchedQuestions = (value) => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string" && item.trim() !== "");
+};
+const buildKnowledgeBaseContent = (content, metadata) => {
+  const matchedQuestions = normalizeMatchedQuestions(metadata == null ? void 0 : metadata.matchedQuestions);
+  if (!matchedQuestions.length) {
+    return content;
+  }
+  return `Related questions:
+${matchedQuestions.join("\n")}
+
+${content}`;
+};
 class KnowledgeBaseManager {
   constructor(plugin) {
     this.plugin = plugin;
   }
   async retrievePrompt({ username, employee, query }) {
-    employee = employee ?? await this.getEmployee(username);
+    employee = employee ?? (username ? await this.getEmployee(username) : null);
     if (!employee) {
       return "Specified knowledge base not existed";
     }
-    const promptTemplate = import_prompts.ChatPromptTemplate.fromTemplate(employee.knowledgeBasePrompt);
-    const docs = await this.retrieve({
-      employee,
-      query
-    });
+    const { knowledgeBaseKeys, topK, score } = employee.knowledgeBase ?? {};
+    if (!knowledgeBaseKeys || import_lodash.default.isEmpty(knowledgeBaseKeys)) {
+      return "Specified knowledge base not existed";
+    }
+    const promptTemplate = import_prompts.ChatPromptTemplate.fromTemplate(employee.knowledgeBasePrompt ?? "{knowledgeBaseData}");
+    const docs = await this.plugin.features.knowledgeBase.search({ knowledgeBaseKeys, query, topK, score });
     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({
+    const knowledgeBaseData = docs.map((doc) => buildKnowledgeBaseContent(doc.content, doc.metadata)).join("\n");
+    return import_lodash.default.isEmpty(knowledgeBaseData) ? "No document match in knowledge base" : 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: "vectorStoreConfigKey",
-              value: vectorStoreConfig.vectorStoreConfigKey ?? ""
-            }
-          ]
-        );
-        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") {
-        const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
-          vectorStoreConfig.vectorStoreProvider,
-          [
-            {
-              key: "vectorStoreConfigKey",
-              value: vectorStoreConfig.vectorStoreConfigKey ?? ""
-            }
-          ]
-        );
-        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 { knowledgeBaseKeys } = (employee == null ? void 0 : employee.knowledgeBase) ?? {};
-    if (!knowledgeBaseKeys || import_lodash.default.isEmpty(knowledgeBaseKeys)) {
-      return [];
-    }
-    return await this.plugin.features.knowledgeBase.getKnowledgeBaseGroup(knowledgeBaseKeys);
-  }
   async getEmployee(username) {
     return await this.aiEmployeeRepo.findOne({ filter: { username } });
   }

package/dist/server/ai-employees/checkpoints/cleaner.d.ts

@@ -23,6 +23,8 @@ export declare class CheckpointCleaner {
     private getThreadIds;
     private get aiConversationsModel();
     private get aiMessagesModel();
+    private get aiMessagesMessageIdColumn();
+    private get isUnderscoredDatabase();
     private get sequelize();
     private get collectionManager();
 }

package/dist/server/ai-employees/checkpoints/cleaner.js

@@ -53,7 +53,10 @@ class CheckpointCleaner {
     }
     const sessionIds = outdatedConversations.map((conversation) => conversation.sessionId);
     const latestMessageRefs = await this.aiMessagesModel.findAll({
-      attributes: ["sessionId", [this.sequelize.fn("MAX", this.sequelize.col("messageId")), "messageId"]],
+      attributes: [
+        "sessionId",
+        [this.sequelize.fn("MAX", this.sequelize.col(this.aiMessagesMessageIdColumn)), "messageId"]
+      ],
       where: {
         sessionId: {
           [import_database.Op.in]: sessionIds
@@ -127,6 +130,13 @@ class CheckpointCleaner {
   get aiMessagesModel() {
     return this.collectionManager.getCollection("aiMessages").model;
   }
+  get aiMessagesMessageIdColumn() {
+    var _a;
+    return ((_a = this.aiMessagesModel.rawAttributes.messageId) == null ? void 0 : _a.field) || (this.isUnderscoredDatabase ? "message_id" : "messageId");
+  }
+  get isUnderscoredDatabase() {
+    return this.collectionManager.db.options.underscored === true || process.env.DB_UNDERSCORED === "true";
+  }
   get sequelize() {
     return this.collectionManager.db.sequelize;
   }

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

@@ -8,8 +8,10 @@
  */
 import { AIEmployee } from '../ai-employee';
 import z from 'zod';
+import { LLMProvider } from '../../llm-providers/provider';
 export declare const conversationMiddleware: (aiEmployee: AIEmployee, options: {
     providerName: string;
+    provider: LLMProvider;
     llmService?: string;
     model: string;
     messageId?: string;

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

@@ -43,10 +43,11 @@ var import_langchain = require("langchain");
 var import_zod = __toESM(require("zod"));
 var import_utils = require("../utils");
 const conversationMiddleware = (aiEmployee, options) => {
-  const { providerName, llmService, model, messageId, agentThread } = options;
+  const { providerName, provider, llmService, model, messageId, agentThread } = options;
   const convertAIMessage = (aiMessage) => (0, import_utils.convertAIMessage)({
     aiEmployee,
     providerName,
+    provider,
     llmService,
     model,
     aiMessage

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

@@ -8,5 +8,6 @@
  */
 export * from './conversation';
 export * from './skill-tools';
+export * from './tool-call-sanitizer';
 export * from './tools';
 export * from './workflow-history';

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

@@ -25,12 +25,14 @@ 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("./tool-call-sanitizer"), 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("./skill-tools"),
+  ...require("./tool-call-sanitizer"),
   ...require("./tools"),
   ...require("./workflow-history")
 });

package/dist/server/ai-employees/middleware/tool-call-sanitizer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+type ToolCallSanitizerLogger = {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+};
+type ToolCallSanitizerMiddlewareOptions = {
+    logger?: ToolCallSanitizerLogger;
+};
+export declare const toolCallSanitizerMiddleware: (options?: ToolCallSanitizerMiddlewareOptions) => import("langchain/dist/agents/middleware/types.cjs").AgentMiddleware<never, undefined, unknown, readonly (import("@langchain/core/dist/tools").ClientTool | import("@langchain/core/dist/tools").ServerTool)[]>;
+export {};

package/dist/server/ai-employees/middleware/tool-call-sanitizer.js

@@ -0,0 +1,90 @@
+/**
+ * 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 tool_call_sanitizer_exports = {};
+__export(tool_call_sanitizer_exports, {
+  toolCallSanitizerMiddleware: () => toolCallSanitizerMiddleware
+});
+module.exports = __toCommonJS(tool_call_sanitizer_exports);
+var import_messages = require("@langchain/core/messages");
+var import_langchain = require("langchain");
+var import_tool_call_sanitizer = require("../tool-call-sanitizer");
+const buildMessageUpdates = (messages, options, phase) => {
+  const updates = [];
+  for (const message of messages) {
+    if (!import_messages.AIMessage.isInstance(message) || !message.id) {
+      continue;
+    }
+    const sanitizedMessage = (0, import_tool_call_sanitizer.sanitizeLangChainAIMessage)(message, {
+      onDiscard: (info) => {
+        var _a, _b;
+        (_b = options.logger) == null ? void 0 : _b.warn("Discard malformed raw tool calls from AI message", {
+          phase,
+          messageId: message.id,
+          invalidToolCallCount: ((_a = message.invalid_tool_calls) == null ? void 0 : _a.length) ?? 0,
+          ...info
+        });
+      }
+    });
+    if (!sanitizedMessage) {
+      continue;
+    }
+    updates.push(
+      new import_messages.AIMessage({
+        id: sanitizedMessage.id,
+        content: sanitizedMessage.content,
+        name: sanitizedMessage.name,
+        additional_kwargs: sanitizedMessage.additional_kwargs,
+        response_metadata: sanitizedMessage.response_metadata,
+        tool_calls: sanitizedMessage.tool_calls,
+        invalid_tool_calls: sanitizedMessage.invalid_tool_calls,
+        usage_metadata: sanitizedMessage.usage_metadata
+      })
+    );
+  }
+  return updates;
+};
+const toolCallSanitizerMiddleware = (options = {}) => (0, import_langchain.createMiddleware)({
+  name: "ToolCallSanitizerMiddleware",
+  beforeModel: (state) => {
+    const updates = buildMessageUpdates(state.messages ?? [], options, "beforeModel");
+    if (!updates.length) {
+      return;
+    }
+    return { messages: updates };
+  },
+  afterModel: (state) => {
+    const updates = buildMessageUpdates(state.messages ?? [], options, "afterModel");
+    if (!updates.length) {
+      return;
+    }
+    return { messages: updates };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toolCallSanitizerMiddleware
+});

package/dist/server/ai-employees/tool-call-sanitizer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { AIMessage } from '@langchain/core/messages';
+type AdditionalKwargs = Record<string, unknown>;
+type DiscardedToolCallsInfo = {
+    rawToolCallCount: number;
+    parsedToolCallCount: number;
+    rawToolCallIds: string[];
+    rawToolCallNames: string[];
+};
+type SanitizeAdditionalKwargsOptions = {
+    onDiscard?: (info: DiscardedToolCallsInfo) => void;
+};
+type SanitizeAdditionalKwargsResult = {
+    changed: boolean;
+    additionalKwargs?: AdditionalKwargs;
+};
+export declare const sanitizeAdditionalKwargsForToolCalls: (additionalKwargs: AdditionalKwargs | undefined, parsedToolCalls?: unknown[] | null, options?: SanitizeAdditionalKwargsOptions) => SanitizeAdditionalKwargsResult;
+export declare const sanitizeLangChainAIMessage: (message: AIMessage, options?: SanitizeAdditionalKwargsOptions) => AIMessage<import("@langchain/core/dist/messages/message").MessageStructure<import("@langchain/core/dist/messages/message").MessageToolSet>>;
+export {};

package/dist/server/ai-employees/tool-call-sanitizer.js

@@ -0,0 +1,84 @@
+/**
+ * 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 tool_call_sanitizer_exports = {};
+__export(tool_call_sanitizer_exports, {
+  sanitizeAdditionalKwargsForToolCalls: () => sanitizeAdditionalKwargsForToolCalls,
+  sanitizeLangChainAIMessage: () => sanitizeLangChainAIMessage
+});
+module.exports = __toCommonJS(tool_call_sanitizer_exports);
+const hasRawToolCalls = (additionalKwargs) => Array.isArray(additionalKwargs == null ? void 0 : additionalKwargs.tool_calls) && additionalKwargs.tool_calls.length > 0;
+const hasParsedToolCalls = (toolCalls) => Array.isArray(toolCalls) && toolCalls.length > 0;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const collectRawToolCallValues = (toolCalls, key) => toolCalls.map((toolCall) => {
+  if (!isRecord(toolCall)) {
+    return null;
+  }
+  if (key === "name") {
+    const fn = toolCall.function;
+    if (isRecord(fn) && typeof fn.name === "string") {
+      return fn.name;
+    }
+  }
+  const value = toolCall[key];
+  return typeof value === "string" ? value : null;
+}).filter((value) => Boolean(value));
+const sanitizeAdditionalKwargsForToolCalls = (additionalKwargs, parsedToolCalls, options = {}) => {
+  var _a;
+  if (!hasRawToolCalls(additionalKwargs) || hasParsedToolCalls(parsedToolCalls)) {
+    return {
+      changed: false,
+      additionalKwargs
+    };
+  }
+  const rawToolCalls = additionalKwargs.tool_calls;
+  (_a = options.onDiscard) == null ? void 0 : _a.call(options, {
+    rawToolCallCount: rawToolCalls.length,
+    parsedToolCallCount: (parsedToolCalls == null ? void 0 : parsedToolCalls.length) ?? 0,
+    rawToolCallIds: collectRawToolCallValues(rawToolCalls, "id"),
+    rawToolCallNames: collectRawToolCallValues(rawToolCalls, "name")
+  });
+  const sanitized = { ...additionalKwargs };
+  delete sanitized.tool_calls;
+  return {
+    changed: true,
+    additionalKwargs: Object.keys(sanitized).length > 0 ? sanitized : void 0
+  };
+};
+const sanitizeLangChainAIMessage = (message, options = {}) => {
+  const sanitized = sanitizeAdditionalKwargsForToolCalls(message.additional_kwargs, message.tool_calls, options);
+  if (!sanitized.changed) {
+    return null;
+  }
+  message.additional_kwargs = sanitized.additionalKwargs ?? {};
+  message.lc_kwargs.additional_kwargs = message.additional_kwargs;
+  return message;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sanitizeAdditionalKwargsForToolCalls,
+  sanitizeLangChainAIMessage
+});

package/dist/server/ai-employees/utils.d.ts

@@ -9,9 +9,11 @@
 import { AIMessage, HumanMessage, ToolMessage } from 'langchain';
 import { AIMessageInput } from '../types';
 import { AIEmployee } from './ai-employee';
-export declare const convertAIMessage: ({ aiEmployee, providerName: provider, llmService, model, aiMessage, }: {
+import { LLMProvider } from '../llm-providers/provider';
+export declare const convertAIMessage: ({ aiEmployee, providerName: provider, provider: providerInstance, llmService, model, aiMessage, }: {
     aiEmployee: AIEmployee;
     providerName: string;
+    provider: LLMProvider;
     llmService?: string;
     model: string;
     aiMessage: AIMessage;

package/dist/server/ai-employees/utils.js

@@ -31,9 +31,11 @@ __export(utils_exports, {
   convertToolMessage: () => convertToolMessage
 });
 module.exports = __toCommonJS(utils_exports);
+var import_tool_call_sanitizer = require("./tool-call-sanitizer");
 const convertAIMessage = ({
   aiEmployee,
   providerName: provider,
+  provider: providerInstance,
   llmService,
   model,
   aiMessage
@@ -89,9 +91,21 @@ const convertAIMessage = ({
   if (aiMessage.response_metadata) {
     values.metadata.response_metadata = aiMessage.response_metadata;
   }
-  if (aiMessage.additional_kwargs) {
-    values.metadata.additional_kwargs = aiMessage.additional_kwargs;
+  const additionalKwargs = (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)(aiMessage.additional_kwargs, toolCalls, {
+    onDiscard: (info) => {
+      var _a2, _b;
+      (_b = aiEmployee.logger) == null ? void 0 : _b.warn("Discard malformed raw tool calls from AI message", {
+        phase: "convertAIMessage",
+        messageId: aiMessage.id,
+        invalidToolCallCount: ((_a2 = aiMessage.invalid_tool_calls) == null ? void 0 : _a2.length) ?? 0,
+        ...info
+      });
+    }
+  }).additionalKwargs;
+  if (additionalKwargs) {
+    values.metadata.additional_kwargs = additionalKwargs;
   }
+  providerInstance.reshapeAIMessage({ aiMessage, values });
   return values;
 };
 const convertHumanMessage = ({

package/dist/server/collections/ai-usage-events.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;