@nocobase/plugin-ai 2.2.0-beta.9 → 2.2.1

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

@@ -45,6 +45,7 @@ var import_utils = require("../utils");
 var import_prompts = require("./prompts");
 var import_lodash = __toESM(require("lodash"));
 var import_ai_chat_conversation = require("../manager/ai-chat-conversation");
+var import_ai_knowledge_base = require("./ai-knowledge-base");
 var import_middleware = require("./middleware");
 var import_ai = require("@nocobase/ai");
 var import_checkpoints = require("./checkpoints");
@@ -55,12 +56,17 @@ var import_utils2 = require("./utils");
 var import_base = require("@langchain/core/callbacks/base");
 var import_shared = require("../../ai/tools/sub-agents/shared");
 var import_tool_call_sanitizer = require("./tool-call-sanitizer");
+var import_attachments = require("../attachments");
+var import_frontend_tools = require("../../common/frontend-tools");
+var import_frontend_tools2 = require("../frontend-tools");
+var import_reasoning_stream_state = require("./reasoning-stream-state");
 class AIEmployee {
   sessionId;
   from = "main-agent";
   employee;
   aiChatConversation;
   skillSettings;
+  userMessageCount = 0;
   plugin;
   db;
   ctx;
@@ -121,6 +127,9 @@ class AIEmployee {
   areToolsEnabled() {
     return this.chatSettings.enableTools !== false;
   }
+  getAIEmployeeRecord() {
+    return this.employee.toJSON();
+  }
   async getFormatMessages(userMessages) {
     const { provider } = await this.plugin.aiManager.getLLMService({
       ...this.model
@@ -141,7 +150,12 @@ class AIEmployee {
   }
   // === Chat flow ===
   buildState(messages) {
+    const toolCallMessage = messages.findLast((message) => {
+      var _a;
+      return (_a = message.toolCalls) == null ? void 0 : _a.length;
+    });
     return {
+      messageId: toolCallMessage == null ? void 0 : toolCallMessage.messageId,
       lastMessageIndex: {
         lastHumanMessageIndex: messages.filter((m) => m.role === "user").length,
         lastAIMessageIndex: messages.filter((m) => m.role === this.employee.username).length,
@@ -198,6 +212,7 @@ class AIEmployee {
     const { provider, model, service } = await this.plugin.aiManager.getLLMService({
       ...this.model
     });
+    this.userMessageCount = (userMessages ?? []).filter((message) => message.role === "user").length;
     const { historyMessages, tools, resolvedTools, middleware, config, state } = await this.initSession({
       messageId,
       provider,
@@ -405,10 +420,21 @@ class AIEmployee {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
     const aiMessageIdMap = /* @__PURE__ */ new Map();
     const { signal, providerName, llmService, model, provider, responseMetadata, allowEmpty = false } = options;
-    let isReasoning = false;
+    const reasoningState = new import_reasoning_stream_state.ReasoningStreamState();
+    const stopReasoning = async (conversation) => {
+      if (reasoningState.stop(conversation)) {
+        await this.protocol.with(conversation).stopReasoning();
+      }
+    };
+    const stopAllReasoning = async () => {
+      for (const conversation of reasoningState.drain()) {
+        await this.protocol.with(conversation).stopReasoning();
+      }
+    };
     let gathered;
     signal.addEventListener("abort", async () => {
       try {
+        await stopAllReasoning();
         if ((gathered == null ? void 0 : gathered.type) === "ai") {
           const values = (0, import_utils2.convertAIMessage)({
             aiEmployee: this,
@@ -450,27 +476,27 @@ class AIEmployee {
           const { currentConversation } = metadata;
           if (chunk.type === "ai") {
             gathered = gathered !== void 0 ? (0, import_stream.concat)(gathered, chunk) : chunk;
-            if (chunk.content) {
-              if (isReasoning) {
-                isReasoning = false;
-                await this.protocol.with(currentConversation).stopReasoning();
-              }
-              const parsedContent = provider.parseResponseChunk(chunk.content);
-              if (parsedContent) {
-                await this.protocol.with(currentConversation).content(parsedContent);
-              }
+            const reasoningContent = provider.parseReasoningContent(chunk);
+            if (reasoningContent) {
+              reasoningState.start(currentConversation);
+              await this.protocol.with(currentConversation).reasoning(reasoningContent);
+            }
+            const parsedContent = chunk.content ? provider.parseResponseChunk(chunk.content) : null;
+            if (parsedContent) {
+              await stopReasoning(currentConversation);
+              await this.protocol.with(currentConversation).content(parsedContent);
             }
             if ((_a = chunk.tool_call_chunks) == null ? void 0 : _a.length) {
+              await stopReasoning(currentConversation);
               await this.protocol.with(currentConversation).toolCallChunks(chunk.tool_call_chunks);
             }
             const webSearch = provider.parseWebSearchAction(chunk);
             if (webSearch == null ? void 0 : webSearch.length) {
+              await stopReasoning(currentConversation);
               await this.protocol.with(currentConversation).webSearch(webSearch);
             }
-            const reasoningContent = provider.parseReasoningContent(chunk);
-            if (reasoningContent) {
-              isReasoning = true;
-              await this.protocol.with(currentConversation).reasoning(reasoningContent);
+            if ((0, import_reasoning_stream_state.isReasoningFinishChunk)(chunk)) {
+              await stopReasoning(currentConversation);
             }
           }
         } else if (mode === "updates") {
@@ -526,6 +552,7 @@ class AIEmployee {
               }
             }
           } else if (chunks.action === "initToolCalls") {
+            await stopReasoning(currentConversation);
             await this.protocol.with(currentConversation).toolCalls(chunks.body);
           } else if (chunks.action === "beforeToolCall") {
             const toolsMap = await this.getToolsMap();
@@ -587,12 +614,14 @@ class AIEmployee {
           }
         }
       }
+      await stopAllReasoning();
       if (this.protocol.statistics.sent === 0 && !signal.aborted && !allowEmpty) {
         this.sendErrorResponse("Empty message");
         return;
       }
       await this.protocol.with(aiEmployeeConversation).endStream();
     } catch (err) {
+      await stopAllReasoning();
       this.ctx.log.error(err);
       if (err.name === "GraphRecursionError") {
         this.sendSpecificError({ name: err.name, message: err.message });
@@ -681,7 +710,7 @@ Field: ${field.name}, Title: ${(_a = field.options.uiSchema) == null ? void 0 :
     return message;
   }
   async getSystemPrompt(userMessages) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     if (this.systemPromptMode === "none") {
       return "";
     }
@@ -689,9 +718,16 @@ Field: ${field.name}, Title: ${(_a = field.options.uiSchema) == null ? void 0 :
     if (this.systemPromptMode === "raw") {
       return about;
     }
+    const employee = this.getAIEmployeeRecord();
+    const knowledgeBaseManager = this.plugin.knowledgeBaseManager;
+    const knowledgeBaseEnabled = await knowledgeBaseManager.isEnabledKnowledgeBase(employee);
+    const roleNames = (0, import_ai_knowledge_base.getCurrentRoleNames)(this.ctx.state);
+    const hasAccessibleKnowledgeBase = knowledgeBaseEnabled ? await knowledgeBaseManager.hasAccessibleKnowledgeBase({ employee, roleNames }) : false;
+    const knowledgeBaseAccessDenied = knowledgeBaseEnabled && !hasAccessibleKnowledgeBase;
+    const knowledgeBaseOnDemand = knowledgeBaseEnabled && hasAccessibleKnowledgeBase && (0, import_ai_knowledge_base.normalizeKnowledgeBaseRetrievalStrategy)((_a = employee.knowledgeBase) == null ? void 0 : _a.retrievalStrategy) === "onDemand";
     const userConfig = await this.db.getRepository("usersAiEmployees").findOne({
       filter: {
-        userId: ((_a = this.ctx.auth) == null ? void 0 : _a.user.id) ?? 0,
+        userId: ((_b = this.ctx.auth) == null ? void 0 : _b.user.id) ?? 0,
         aiEmployee: this.employee.username
       }
     });
@@ -716,17 +752,25 @@ ${workContextBackground.join("\n")}`;
 ${addSystemPrompt.map((it) => it.content).join("\n")}`;
     }
     let knowledgeBase;
-    const { knowledgeBaseManager } = this.plugin;
-    const employee = this.employee.toJSON();
-    if (await knowledgeBaseManager.isEnabledKnowledgeBase(employee) && employee.knowledgeBasePrompt && (userMessages == null ? void 0 : userMessages.length)) {
+    if (knowledgeBaseEnabled && hasAccessibleKnowledgeBase && !knowledgeBaseOnDemand && (userMessages == null ? void 0 : userMessages.length)) {
       const lastUserMessage = userMessages.filter((x) => x.role === "user").at(-1);
       if (lastUserMessage) {
         knowledgeBase = await knowledgeBaseManager.retrievePrompt({
           employee,
-          query: lastUserMessage.content.content
+          query: lastUserMessage.content.content,
+          roleNames
         });
       }
     }
+    const knowledgeBaseBackgroundPrompt = (0, import_ai_knowledge_base.getKnowledgeBaseBackgroundPrompt)({
+      accessDenied: knowledgeBaseAccessDenied,
+      onDemand: knowledgeBaseOnDemand,
+      preRetrieved: Boolean(knowledgeBase)
+    });
+    if (knowledgeBaseBackgroundPrompt) {
+      background = `${background}
+${knowledgeBaseBackgroundPrompt}`;
+    }
     const availableSkills = await this.getAvailableSkills();
     const availableAIEmployees = await this.getAvailableAIEmployees();
     const systemPrompt = (0, import_prompts.getSystemPrompt)({
@@ -740,15 +784,16 @@ ${addSystemPrompt.map((it) => it.content).join("\n")}`;
       personal: userConfig == null ? void 0 : userConfig.prompt,
       environment: {
         database: this.db.sequelize.getDialect(),
-        locale: ((_c = (_b = this.ctx).getCurrentLocale) == null ? void 0 : _c.call(_b)) || "en-US",
-        currentDateTime: getCurrentDateTimeForPrompt((_e = (_d = this.ctx).getCurrentLocale) == null ? void 0 : _e.call(_d), getCurrentTimezone(this.ctx)),
+        locale: ((_d = (_c = this.ctx).getCurrentLocale) == null ? void 0 : _d.call(_c)) || "en-US",
+        currentDateTime: getCurrentDateTimeForPrompt((_f = (_e = this.ctx).getCurrentLocale) == null ? void 0 : _f.call(_e), getCurrentTimezone(this.ctx)),
         timezone: getCurrentTimezone(this.ctx)
       },
       knowledgeBase,
       availableSkills,
-      availableAIEmployees
+      availableAIEmployees,
+      webSearch: this.webSearch
     });
-    const { important } = ((_g = (_f = this.ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.values) || {};
+    const { important } = ((_h = (_g = this.ctx.action) == null ? void 0 : _g.params) == null ? void 0 : _h.values) || {};
     if (important === "GraphRecursionError") {
       const importantPrompt = `<Important>You have already called tools multiple times and gathered sufficient information.
 First, provide a summary based on the existing information. Do not call additional tools.
@@ -762,11 +807,12 @@ If information is missing, clearly state it in the summary.</Important>`;
   async initToolCall(transaction, messageId, toolCalls) {
     const nowTime = /* @__PURE__ */ new Date();
     const toolMap = await this.getToolsMap();
+    const currentFrontendTools = toolCalls.some((toolCall) => toolCall.name === import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME) ? await (0, import_frontend_tools2.listCurrentFrontendTools)(this.ctx, this.sessionId) : [];
     return await this.aiToolMessagesRepo.create({
       values: toolCalls.map((toolCall) => {
         const toolsExisted = toolMap.has(toolCall.name);
         const tools = toolMap.get(toolCall.name);
-        const auto = this.isAutoCall(tools);
+        const auto = toolCall.name === import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME ? toolsExisted && (0, import_frontend_tools2.shouldAutoExecuteFrontendTool)(currentFrontendTools, toolCall.args) : this.isAutoCall(tools);
         return {
           id: this.plugin.snowflake.generate(),
           sessionId: this.sessionId,
@@ -1019,15 +1065,43 @@ If information is missing, clearly state it in the summary.</Important>`;
     const presetTools = employeeTools.find((s) => s.name === tools.definition.name);
     return presetTools ? presetTools.autoCall : isAutoCall;
   }
+  async normalizeMessageAttachments(messages) {
+    const attachments = messages.filter((message) => Array.isArray(message.attachments)).flatMap((message) => message.attachments);
+    if (!attachments.length) {
+      return messages;
+    }
+    const attachmentsByLookup = await (0, import_attachments.findMessageAttachments)(this.ctx, attachments);
+    return messages.map((message) => {
+      if (!Array.isArray(message.attachments) || !message.attachments.length) {
+        return message;
+      }
+      return {
+        ...message,
+        attachments: message.attachments.flatMap((attachment) => {
+          const source = (0, import_attachments.getAttachmentSource)(attachment);
+          if (!source || (0, import_attachments.shouldSkipAttachmentSourceLookup)(source)) {
+            return [attachment];
+          }
+          const lookupKey = (0, import_attachments.getMessageAttachmentLookupKey)(attachment);
+          const verifiedAttachment = lookupKey ? attachmentsByLookup.get(lookupKey) : null;
+          if (!verifiedAttachment) {
+            return [];
+          }
+          return [{ ...verifiedAttachment, source }];
+        })
+      };
+    });
+  }
   async formatMessages({ messages, provider }) {
     var _a, _b;
     const formattedMessages = [];
     const workContextHandler = this.plugin.workContextHandler;
+    const normalizedMessages = await this.normalizeMessageAttachments(messages);
     const truncate = (text, maxLen = 5e4) => {
       if (!text || text.length <= maxLen) return text;
       return text.slice(0, maxLen) + "\n...[truncated]";
     };
-    for (const msg of messages) {
+    for (const msg of normalizedMessages) {
       const attachments = msg.attachments;
       const workContext = msg.workContext;
       const userContent = msg.content;
@@ -1092,20 +1166,21 @@ If information is missing, clearly state it in the summary.</Important>`;
         });
         continue;
       }
+      const additionalKwargs = (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)((_b = msg.metadata) == null ? void 0 : _b.additional_kwargs, msg.toolCalls, {
+        onDiscard: (info) => {
+          var _a2;
+          this.logger.warn("Discard malformed raw tool calls from AI message", {
+            phase: "formatMessages",
+            messageId: (_a2 = msg.metadata) == null ? void 0 : _a2.id,
+            ...info
+          });
+        }
+      }).additionalKwargs;
       formattedMessages.push({
         role: "assistant",
         content,
         tool_calls: msg.toolCalls,
-        additional_kwargs: (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)((_b = msg.metadata) == null ? void 0 : _b.additional_kwargs, msg.toolCalls, {
-          onDiscard: (info) => {
-            var _a2;
-            this.logger.warn("Discard malformed raw tool calls from AI message", {
-              phase: "formatMessages",
-              messageId: (_a2 = msg.metadata) == null ? void 0 : _a2.id,
-              ...info
-            });
-          }
-        }).additionalKwargs
+        additional_kwargs: provider.prepareStoredAssistantAdditionalKwargs(additionalKwargs)
       });
     }
     return formattedMessages;
@@ -1150,12 +1225,32 @@ If information is missing, clearly state it in the summary.</Important>`;
     }
     return result;
   }
+  async getKnowledgeBaseRetrieveTool() {
+    const employee = this.getAIEmployeeRecord();
+    const knowledgeBaseManager = this.plugin.knowledgeBaseManager;
+    if (!await knowledgeBaseManager.isEnabledKnowledgeBase(employee)) {
+      return void 0;
+    }
+    const hasAccessibleKnowledgeBase = await knowledgeBaseManager.hasAccessibleKnowledgeBase({
+      employee,
+      roleNames: (0, import_ai_knowledge_base.getCurrentRoleNames)(this.ctx.state)
+    });
+    if (!hasAccessibleKnowledgeBase) {
+      return void 0;
+    }
+    return await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE, { ctx: this.ctx });
+  }
   async getAIEmployeeTools() {
     var _a;
     if (!this.areToolsEnabled()) {
       return [];
     }
+    const currentFrontendTools = await (0, import_frontend_tools2.listCurrentFrontendTools)(this.ctx, this.sessionId);
     const tools = await this.listTools({ scope: "GENERAL" });
+    const getSkill = await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.GET_SKILL, { ctx: this.ctx });
+    if (getSkill) {
+      tools.push(getSkill);
+    }
     if (this.webSearch === true) {
       const subAgentWebSearch = await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.WEB_SEARCH, { ctx: this.ctx });
       tools.push(subAgentWebSearch);
@@ -1164,13 +1259,9 @@ If information is missing, clearly state it in the summary.</Important>`;
     const toolMap = await this.getToolsMap();
     const settingsTools = ((_a = this.employee.skillSettings) == null ? void 0 : _a.tools) ?? [];
     const employeeTools = [...settingsTools, ...this.tools];
-    if (await this.plugin.knowledgeBaseManager.isEnabledKnowledgeBase(this.employee.toJSON())) {
-      const knowledgeBaseRetrieveTool = await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE, {
-        ctx: this.ctx
-      });
-      if (knowledgeBaseRetrieveTool) {
-        employeeTools.push({ name: import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE });
-      }
+    const knowledgeBaseRetrieveTool = await this.getKnowledgeBaseRetrieveTool();
+    if (knowledgeBaseRetrieveTool) {
+      employeeTools.push({ name: import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE });
     }
     for (const toolSetting of employeeTools) {
       if (generalToolsNameSet.has(toolSetting.name)) {
@@ -1182,20 +1273,26 @@ If information is missing, clearly state it in the summary.</Important>`;
       }
       tools.push(tool);
     }
-    const systemTools = (0, import_ai.listSystemTools)();
+    const systemTools = [...(0, import_ai.listSystemTools)(), import_frontend_tools.LOAD_FRONTEND_TOOL_NAME, import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME];
     if (!this.skillSettings) {
-      return tools;
+      return (0, import_frontend_tools2.prepareToolsForFrontendConversation)(tools, currentFrontendTools);
     } else if (!this.skillSettings.toolsVersion) {
       const toolFilter = this.skillSettings.tools ?? [];
-      return tools.filter(
-        (t) => toolFilter.length === 0 || systemTools.includes(t.definition.name) || toolFilter.includes(t.definition.name)
+      return (0, import_frontend_tools2.prepareToolsForFrontendConversation)(
+        tools.filter(
+          (t) => toolFilter.length === 0 || systemTools.includes(t.definition.name) || toolFilter.includes(t.definition.name)
+        ),
+        currentFrontendTools
       );
     } else {
       const toolFilter = this.skillSettings.tools;
       if (import_lodash.default.isArray(toolFilter)) {
-        return tools.filter((t) => systemTools.includes(t.definition.name) || toolFilter.includes(t.definition.name));
+        return (0, import_frontend_tools2.prepareToolsForFrontendConversation)(
+          tools.filter((t) => systemTools.includes(t.definition.name) || toolFilter.includes(t.definition.name)),
+          currentFrontendTools
+        );
       } else {
-        return tools;
+        return (0, import_frontend_tools2.prepareToolsForFrontendConversation)(tools, currentFrontendTools);
       }
     }
   }
@@ -1237,6 +1334,9 @@ If information is missing, clearly state it in the summary.</Important>`;
     }
     const baseTools = await this.getAIEmployeeTools();
     const toolMap = await this.getToolsMap();
+    for (const tool of baseTools) {
+      toolMap.set(tool.definition.name, tool);
+    }
     const availableSkills = await this.getAvailableSkills();
     const skillOwnedToolNames = new Set(availableSkills.flatMap((it) => it.tools ?? []));
     const baseToolNames = new Set(

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

@@ -8,15 +8,35 @@
  */
 import { AIEmployee } from '../../collections/ai-employees';
 import type PluginAIServer from '../plugin';
+export declare const KNOWLEDGE_BASE_RETRIEVAL_STRATEGIES: readonly ["always", "onDemand"];
+export type KnowledgeBaseRetrievalStrategy = (typeof KNOWLEDGE_BASE_RETRIEVAL_STRATEGIES)[number];
+export declare const isKnowledgeBaseRetrievalStrategy: (value: unknown) => value is "always" | "onDemand";
+export declare const normalizeKnowledgeBaseRetrievalStrategy: (value: unknown) => KnowledgeBaseRetrievalStrategy;
+export declare const withDefaultKnowledgeBaseRetrievalStrategy: (knowledgeBase: unknown) => Record<string, unknown>;
+export declare const getCurrentRoleNames: (state: unknown) => string[];
+export declare const KNOWLEDGE_BASE_ON_DEMAND_PROMPT: string;
+export declare const KNOWLEDGE_BASE_PRE_RETRIEVED_PROMPT: string;
+export declare const KNOWLEDGE_BASE_NO_ACCESS_PROMPT: string;
+export declare const getKnowledgeBaseBackgroundPrompt: ({ accessDenied, onDemand, preRetrieved, }: {
+    accessDenied: boolean;
+    onDemand: boolean;
+    preRetrieved: boolean;
+}) => string | undefined;
 export type KnowledgeBaseRetrieveOptions = {
     username?: string;
     employee?: AIEmployee;
     query: string;
+    roleNames?: string[];
+};
+export type KnowledgeBaseAccessOptions = {
+    employee: AIEmployee;
+    roleNames: string[];
 };
 export declare class KnowledgeBaseManager {
     private readonly plugin;
     constructor(plugin: PluginAIServer);
-    retrievePrompt({ username, employee, query }: KnowledgeBaseRetrieveOptions): Promise<string>;
+    retrievePrompt({ username, employee, query, roleNames }: KnowledgeBaseRetrieveOptions): Promise<string>;
+    hasAccessibleKnowledgeBase({ employee, roleNames }: KnowledgeBaseAccessOptions): Promise<boolean>;
     isEnabledKnowledgeBase(username: string): Promise<boolean>;
     isEnabledKnowledgeBase(employee: AIEmployee): Promise<boolean>;
     private getEmployee;

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

@@ -36,12 +36,64 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ai_knowledge_base_exports = {};
 __export(ai_knowledge_base_exports, {
-  KnowledgeBaseManager: () => KnowledgeBaseManager
+  KNOWLEDGE_BASE_NO_ACCESS_PROMPT: () => KNOWLEDGE_BASE_NO_ACCESS_PROMPT,
+  KNOWLEDGE_BASE_ON_DEMAND_PROMPT: () => KNOWLEDGE_BASE_ON_DEMAND_PROMPT,
+  KNOWLEDGE_BASE_PRE_RETRIEVED_PROMPT: () => KNOWLEDGE_BASE_PRE_RETRIEVED_PROMPT,
+  KNOWLEDGE_BASE_RETRIEVAL_STRATEGIES: () => KNOWLEDGE_BASE_RETRIEVAL_STRATEGIES,
+  KnowledgeBaseManager: () => KnowledgeBaseManager,
+  getCurrentRoleNames: () => getCurrentRoleNames,
+  getKnowledgeBaseBackgroundPrompt: () => getKnowledgeBaseBackgroundPrompt,
+  isKnowledgeBaseRetrievalStrategy: () => isKnowledgeBaseRetrievalStrategy,
+  normalizeKnowledgeBaseRetrievalStrategy: () => normalizeKnowledgeBaseRetrievalStrategy,
+  withDefaultKnowledgeBaseRetrievalStrategy: () => withDefaultKnowledgeBaseRetrievalStrategy
 });
 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 KNOWLEDGE_BASE_RETRIEVAL_STRATEGIES = ["always", "onDemand"];
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const getRoleNames = (roles) => Array.isArray(roles) ? Array.from(
+  new Set(
+    roles.map((role) => isRecord(role) ? role.name : role).filter((role) => typeof role === "string" && role.length > 0)
+  )
+) : [];
+const isKnowledgeBaseRetrievalStrategy = (value) => typeof value === "string" && KNOWLEDGE_BASE_RETRIEVAL_STRATEGIES.includes(value);
+const normalizeKnowledgeBaseRetrievalStrategy = (value) => isKnowledgeBaseRetrievalStrategy(value) ? value : "always";
+const withDefaultKnowledgeBaseRetrievalStrategy = (knowledgeBase) => {
+  const settings = isRecord(knowledgeBase) ? { ...knowledgeBase } : {};
+  if (!isKnowledgeBaseRetrievalStrategy(settings.retrievalStrategy)) {
+    settings.retrievalStrategy = "onDemand";
+  }
+  return settings;
+};
+const getCurrentRoleNames = (state) => {
+  const { currentRole, currentRoles, currentUser } = isRecord(state) ? state : {};
+  const currentUserRoleNames = getRoleNames(isRecord(currentUser) ? currentUser.roles : void 0);
+  if (currentUserRoleNames.length) {
+    return currentUserRoleNames;
+  }
+  if (Array.isArray(currentRoles)) {
+    return getRoleNames(currentRoles);
+  }
+  return typeof currentRole === "string" && currentRole.length > 0 ? [currentRole] : [];
+};
+const KNOWLEDGE_BASE_ON_DEMAND_PROMPT = "Use the knowledge base retrieval tool only when the request needs internal knowledge, uploaded documents, or knowledge-base facts. Do not call it for requests that clearly do not need those sources.";
+const KNOWLEDGE_BASE_PRE_RETRIEVED_PROMPT = "The <knowledgeBase> content was retrieved in advance for the current user request. Use it directly when it is sufficient to answer; do not call the knowledge base retrieval tool again unless additional or different knowledge-base information is genuinely needed.";
+const KNOWLEDGE_BASE_NO_ACCESS_PROMPT = "The current user does not have permission to access any knowledge base in this AI employee's configured scope. First answer the user's question as helpfully as possible using only information available without knowledge-base content; do not replace or interrupt the answer with a permission notice, and do not fabricate unavailable facts. Only after completing the answer, append a brief notice in the user's language stating that this response did not use knowledge-base content because the current user does not have permission to access these knowledge bases. Format this notice as a visually prominent Markdown reminder, using a blockquote with a bold warning or reminder heading so that it is easy to notice. If knowledge-base access is needed, advise the user to contact an administrator. Do not claim to have searched or used knowledge-base content.";
+const getKnowledgeBaseBackgroundPrompt = ({
+  accessDenied,
+  onDemand,
+  preRetrieved
+}) => {
+  if (accessDenied) {
+    return KNOWLEDGE_BASE_NO_ACCESS_PROMPT;
+  }
+  if (onDemand) {
+    return KNOWLEDGE_BASE_ON_DEMAND_PROMPT;
+  }
+  return preRetrieved ? KNOWLEDGE_BASE_PRE_RETRIEVED_PROMPT : void 0;
+};
 const normalizeMatchedQuestions = (value) => {
   if (!Array.isArray(value)) {
     return [];
@@ -62,17 +114,14 @@ class KnowledgeBaseManager {
   constructor(plugin) {
     this.plugin = plugin;
   }
-  async retrievePrompt({ username, employee, query }) {
+  async retrievePrompt({ username, employee, query, roleNames }) {
     employee = employee ?? (username ? await this.getEmployee(username) : null);
     if (!employee) {
       return "Specified knowledge base not existed";
     }
-    const { knowledgeBaseKeys, topK, score } = employee.knowledgeBase ?? {};
-    if (!knowledgeBaseKeys || import_lodash.default.isEmpty(knowledgeBaseKeys)) {
-      return "Specified knowledge base not existed";
-    }
+    const { knowledgeBaseKeys = [], topK, score } = employee.knowledgeBase ?? {};
     const promptTemplate = import_prompts.ChatPromptTemplate.fromTemplate(employee.knowledgeBasePrompt ?? "{knowledgeBaseData}");
-    const docs = await this.plugin.features.knowledgeBase.search({ knowledgeBaseKeys, query, topK, score });
+    const docs = await this.plugin.features.knowledgeBase.search({ knowledgeBaseKeys, query, topK, score, roleNames });
     if (!(docs == null ? void 0 : docs.length)) {
       return "No document match in knowledge base";
     }
@@ -81,6 +130,16 @@ class KnowledgeBaseManager {
       knowledgeBaseData
     });
   }
+  async hasAccessibleKnowledgeBase({ employee, roleNames }) {
+    var _a;
+    const knowledgeBaseKeys = ((_a = employee.knowledgeBase) == null ? void 0 : _a.knowledgeBaseKeys) ?? [];
+    const knowledgeBaseFeature = this.plugin.features.knowledgeBase;
+    if (!knowledgeBaseFeature.getAccessibleKnowledgeBaseKeys) {
+      return true;
+    }
+    const accessibleKeys = await knowledgeBaseFeature.getAccessibleKnowledgeBaseKeys({ knowledgeBaseKeys, roleNames });
+    return accessibleKeys.length > 0;
+  }
   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;
@@ -96,5 +155,14 @@ class KnowledgeBaseManager {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  KnowledgeBaseManager
+  KNOWLEDGE_BASE_NO_ACCESS_PROMPT,
+  KNOWLEDGE_BASE_ON_DEMAND_PROMPT,
+  KNOWLEDGE_BASE_PRE_RETRIEVED_PROMPT,
+  KNOWLEDGE_BASE_RETRIEVAL_STRATEGIES,
+  KnowledgeBaseManager,
+  getCurrentRoleNames,
+  getKnowledgeBaseBackgroundPrompt,
+  isKnowledgeBaseRetrievalStrategy,
+  normalizeKnowledgeBaseRetrievalStrategy,
+  withDefaultKnowledgeBaseRetrievalStrategy
 });

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

@@ -98,8 +98,9 @@ const conversationMiddleware = (aiEmployee, options) => {
       })
     }),
     beforeAgent: async (state) => {
-      const lastHumanMessageIndex = state.lastMessageIndex.lastHumanMessageIndex;
-      const userMessages = state.messages.filter((x) => x.type === "human").slice(lastHumanMessageIndex).map((x) => x).map(convertHumanMessage);
+      const humanMessages = state.messages.filter((x) => x.type === "human");
+      const currentHumanMessageIndex = humanMessages.length;
+      const userMessages = (aiEmployee.userMessageCount ? humanMessages.slice(-aiEmployee.userMessageCount) : []).map((x) => x).map(convertHumanMessage);
       await aiEmployee.aiChatConversation.withTransaction(async (conversation, transaction) => {
         if (agentThread) {
           await aiEmployee.updateThread(transaction, agentThread);
@@ -111,6 +112,12 @@ const conversationMiddleware = (aiEmployee, options) => {
           await conversation.addMessages(userMessages);
         }
       });
+      return {
+        lastMessageIndex: {
+          ...state.lastMessageIndex,
+          lastHumanMessageIndex: currentHumanMessageIndex
+        }
+      };
     },
     afterAgent: async () => {
       aiEmployee.removeAbortController();

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

@@ -6,7 +6,7 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export declare function getSystemPrompt({ aiEmployee, personal, task, environment, knowledgeBase, availableSkills, availableAIEmployees, }: {
+export declare function getSystemPrompt({ aiEmployee, personal, task, environment, knowledgeBase, availableSkills, availableAIEmployees, webSearch, }: {
     aiEmployee: {
         nickname: string;
         about: string;
@@ -23,6 +23,7 @@ export declare function getSystemPrompt({ aiEmployee, personal, task, environmen
         timezone?: string;
     };
     knowledgeBase?: string;
+    webSearch?: boolean;
     availableSkills?: {
         name: string;
         description: string;

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

@@ -36,7 +36,8 @@ function getSystemPrompt({
   environment,
   knowledgeBase,
   availableSkills,
-  availableAIEmployees
+  availableAIEmployees,
+  webSearch
 }) {
   const getDatabaseQuotingRules = () => {
     const quotingMap = {
@@ -52,6 +53,11 @@ function getSystemPrompt({
   };
   const quotingRules = getDatabaseQuotingRules();
   const isUnderscored = process.env.DB_UNDERSCORED === "true";
+  const webSearchInstructions = webSearch === true ? `
+   - When using web search, batch all independent search queries needed for this turn into one tool call whenever possible so they can run in parallel.
+   - Do not make repeated web search calls with the same or similar queries in the same turn.
+   - After receiving usable web search results, synthesize an answer from those results instead of searching again.
+   - Search again only when a critical fact is still missing and the new query is materially different from previous queries.` : "";
   return `You are **${aiEmployee.nickname}**, an AI employee working in **NocoBase**, the leading no-code platform.
 
 You assist developers in building enterprise management systems (CRM, ERP, OA, etc.) and help end users complete business tasks.
@@ -114,7 +120,7 @@ This prompt uses a structured tag system to organize your operational framework:
 5. **Tool Integration**
    - Utilize system-provided tools to enhance response quality
    - **NEVER refer to tool names when speaking to the USER.** Instead, just say what the tool is doing in natural language.
-   - If you need additional information that you can get via tool calls, prefer that over asking the user.
+   - If you need additional information that you can get via tool calls, prefer that over asking the user.${webSearchInstructions}
 </global>
 
 <ai_employee>

package/dist/server/ai-employees/reasoning-stream-state.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+export type StreamConversation = {
+    sessionId: string;
+    from: string;
+    username: string;
+};
+export declare class ReasoningStreamState {
+    private readonly active;
+    start(conversation: StreamConversation): void;
+    stop(conversation: StreamConversation): boolean;
+    drain(): StreamConversation[];
+}
+export declare const isReasoningFinishChunk: (chunk: {
+    response_metadata?: Record<string, unknown>;
+    usage_metadata?: Record<string, unknown>;
+}) => boolean;