@nocobase/plugin-ai 2.3.0-alpha.1 → 2.3.0-beta.10

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,65 @@ 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"));
+var import_ai_employee_validation = require("../../common/ai-employee-validation");
+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,24 +115,37 @@ 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 promptTemplate = import_prompts.ChatPromptTemplate.fromTemplate(employee.knowledgeBasePrompt ?? "{knowledgeBaseData}");
-    const docs = await this.plugin.features.knowledgeBase.search({ knowledgeBaseKeys, query, topK, score });
+    const { knowledgeBaseKeys = [], topK, score } = employee.knowledgeBase ?? {};
+    const knowledgeBasePrompt = employee.knowledgeBasePrompt ?? "{knowledgeBaseData}";
+    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";
     }
     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
-    });
+    if (import_lodash.default.isEmpty(knowledgeBaseData)) {
+      return "No document match in knowledge base";
+    }
+    if (!(0, import_ai_employee_validation.hasKnowledgeBaseDataPlaceholder)(knowledgeBasePrompt)) {
+      return `${knowledgeBasePrompt}
+
+${knowledgeBaseData}`;
+    }
+    return import_prompts.ChatPromptTemplate.fromTemplate(knowledgeBasePrompt).format({ 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));
@@ -96,5 +162,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();
@@ -172,31 +179,30 @@ const conversationMiddleware = (aiEmployee, options) => {
         const toolCalls = aiMessage.tool_calls;
         const values = convertAIMessage(aiMessage);
         if (values) {
-          await aiEmployee.aiChatConversation.withTransaction(async (conversation, transaction) => {
-            const result = await conversation.addMessages(values);
-            newState.messageId = result.messageId;
-            if (toolCalls == null ? void 0 : toolCalls.length) {
-              const toolsMap = await aiEmployee.getToolsMap();
-              const initializedToolCalls = await aiEmployee.initToolCall(
-                transaction,
-                result.messageId,
-                toolCalls
-              );
-              fillToolCall(result, toolsMap, initializedToolCalls, toolCalls);
-            }
+          const result = await aiEmployee.persistAIMessage({
+            values,
+            langChainMessageId: aiMessage.id,
+            toolCalls: toolCalls ?? []
           });
+          newState.messageId = result.message.messageId;
           if (toolCalls == null ? void 0 : toolCalls.length) {
-            (_b = runtime.writer) == null ? void 0 : _b.call(runtime, {
-              action: "initToolCalls",
-              body: { toolCalls },
+            const toolsMap = await aiEmployee.getToolsMap();
+            fillToolCall(result.message, toolsMap, result.initializedToolCalls, toolCalls);
+          }
+          if (result.created) {
+            if (toolCalls == null ? void 0 : toolCalls.length) {
+              (_b = runtime.writer) == null ? void 0 : _b.call(runtime, {
+                action: "initToolCalls",
+                body: { toolCalls },
+                currentConversation
+              });
+            }
+            (_c = runtime.writer) == null ? void 0 : _c.call(runtime, {
+              action: "AfterAIMessageSaved",
+              body: { id: aiMessage.id, messageId: newState.messageId },
               currentConversation
             });
           }
-          (_c = runtime.writer) == null ? void 0 : _c.call(runtime, {
-            action: "AfterAIMessageSaved",
-            body: { id: aiMessage.id, messageId: newState.messageId },
-            currentConversation
-          });
         }
         return newState;
       } catch (e) {

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

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

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

@@ -26,6 +26,7 @@ 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("./tool-result-integrity"), 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:
@@ -33,6 +34,7 @@ __reExport(middleware_exports, require("./workflow-history"), module.exports);
   ...require("./conversation"),
   ...require("./skill-tools"),
   ...require("./tool-call-sanitizer"),
+  ...require("./tool-result-integrity"),
   ...require("./tools"),
   ...require("./workflow-history")
 });

package/dist/server/ai-employees/middleware/tool-result-integrity.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 { BaseMessage } from '@langchain/core/messages';
+import type { AIToolMessage } from '../../types/ai-message.type';
+type ToolResultIntegrityLogger = {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+};
+export type NormalizeToolCallHistoryOptions = {
+    sessionId: string;
+    logger?: ToolResultIntegrityLogger;
+    loadToolResults: (toolCallIds: string[]) => Promise<Map<string, AIToolMessage>>;
+};
+export declare const isToolCallHistoryValid: (messages: readonly BaseMessage[]) => boolean;
+export declare const normalizeToolCallHistory: (messages: readonly BaseMessage[], options: NormalizeToolCallHistoryOptions) => Promise<BaseMessage[]>;
+export declare const toolResultIntegrityMiddleware: (options: NormalizeToolCallHistoryOptions) => import("langchain/dist/agents/middleware/types.cjs").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/dist/tools").ClientTool | import("@langchain/core/dist/tools").ServerTool)[]>;
+export {};

package/dist/server/ai-employees/middleware/tool-result-integrity.js

@@ -0,0 +1,211 @@
+/**
+ * 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_result_integrity_exports = {};
+__export(tool_result_integrity_exports, {
+  isToolCallHistoryValid: () => isToolCallHistoryValid,
+  normalizeToolCallHistory: () => normalizeToolCallHistory,
+  toolResultIntegrityMiddleware: () => toolResultIntegrityMiddleware
+});
+module.exports = __toCommonJS(tool_result_integrity_exports);
+var import_messages = require("@langchain/core/messages");
+var import_langchain = require("langchain");
+const SYNTHETIC_TOOL_RESULT_ERROR = "Tool execution was interrupted before a result was recorded.";
+const getValidToolCalls = (message) => (message.tool_calls ?? []).filter((toolCall) => typeof toolCall.id === "string" && toolCall.id.length > 0);
+const isToolCallHistoryValid = (messages) => {
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (import_messages.ToolMessage.isInstance(message)) {
+      return false;
+    }
+    if (!import_messages.AIMessage.isInstance(message)) {
+      continue;
+    }
+    const toolCalls = getValidToolCalls(message);
+    if (!toolCalls.length) {
+      continue;
+    }
+    const expectedToolCallIds = new Set(toolCalls.map((toolCall) => toolCall.id));
+    const seenToolResultIds = /* @__PURE__ */ new Set();
+    for (let resultIndex = 0; resultIndex < toolCalls.length; resultIndex++) {
+      index++;
+      if (index >= messages.length) {
+        return false;
+      }
+      const result = messages[index];
+      if (!import_messages.ToolMessage.isInstance(result) || !expectedToolCallIds.has(result.tool_call_id) || seenToolResultIds.has(result.tool_call_id)) {
+        return false;
+      }
+      seenToolResultIds.add(result.tool_call_id);
+    }
+  }
+  return true;
+};
+const serializeToolResultContent = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  return JSON.stringify(content ?? null);
+};
+const createSyntheticToolResult = (sessionId, toolCall) => new import_messages.ToolMessage({
+  id: `synthetic-tool-result:${sessionId}:${toolCall.id}`,
+  tool_call_id: toolCall.id,
+  name: toolCall.name,
+  status: "error",
+  content: JSON.stringify({
+    status: "error",
+    error: SYNTHETIC_TOOL_RESULT_ERROR
+  })
+});
+const createRestoredToolResult = (sessionId, toolCall, persisted) => {
+  if (!persisted || persisted.invokeStatus !== "confirmed" && persisted.invokeStatus !== "done") {
+    return;
+  }
+  try {
+    return new import_messages.ToolMessage({
+      id: `restored-tool-result:${sessionId}:${toolCall.id}`,
+      tool_call_id: toolCall.id,
+      name: toolCall.name,
+      status: persisted.status === "error" ? "error" : "success",
+      content: serializeToolResultContent(persisted.content)
+    });
+  } catch {
+    return;
+  }
+};
+const countMisplacedResults = (messages) => {
+  let misplacedResultCount = 0;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (!import_messages.AIMessage.isInstance(message)) {
+      continue;
+    }
+    const toolCalls = getValidToolCalls(message);
+    if (!toolCalls.length) {
+      continue;
+    }
+    const expectedToolCallIds = new Set(toolCalls.map((toolCall) => toolCall.id));
+    const contiguousResultIds = /* @__PURE__ */ new Set();
+    for (let offset = 1; offset <= toolCalls.length; offset++) {
+      const result = messages[index + offset];
+      if (!import_messages.ToolMessage.isInstance(result)) {
+        break;
+      }
+      if (expectedToolCallIds.has(result.tool_call_id)) {
+        contiguousResultIds.add(result.tool_call_id);
+      }
+    }
+    misplacedResultCount += expectedToolCallIds.size - contiguousResultIds.size;
+  }
+  return misplacedResultCount;
+};
+const normalizeToolCallHistory = async (messages, options) => {
+  var _a;
+  const toolResultsByCallId = /* @__PURE__ */ new Map();
+  const referencedToolCallIds = /* @__PURE__ */ new Set();
+  let toolCallCount = 0;
+  let toolResultCount = 0;
+  for (const message of messages) {
+    if (import_messages.AIMessage.isInstance(message)) {
+      for (const toolCall of getValidToolCalls(message)) {
+        toolCallCount++;
+        referencedToolCallIds.add(toolCall.id);
+      }
+    } else if (import_messages.ToolMessage.isInstance(message)) {
+      toolResultCount++;
+      if (message.tool_call_id) {
+        const results = toolResultsByCallId.get(message.tool_call_id) ?? [];
+        results.push(message);
+        toolResultsByCallId.set(message.tool_call_id, results);
+      }
+    }
+  }
+  const missingToolCallIds = Array.from(referencedToolCallIds).filter((id) => !toolResultsByCallId.has(id));
+  const persistedResults = missingToolCallIds.length ? await options.loadToolResults(missingToolCallIds) : /* @__PURE__ */ new Map();
+  const normalized = [];
+  const nextToolResultIndexByCallId = /* @__PURE__ */ new Map();
+  let restoredResultCount = 0;
+  let syntheticResultCount = 0;
+  let consumedExistingResultCount = 0;
+  for (const message of messages) {
+    if (import_messages.ToolMessage.isInstance(message)) {
+      continue;
+    }
+    normalized.push(message);
+    if (!import_messages.AIMessage.isInstance(message)) {
+      continue;
+    }
+    for (const toolCall of getValidToolCalls(message)) {
+      const existingResults = toolResultsByCallId.get(toolCall.id);
+      const existingResultIndex = nextToolResultIndexByCallId.get(toolCall.id) ?? 0;
+      const existingResult = existingResults == null ? void 0 : existingResults[existingResultIndex];
+      if (existingResult) {
+        nextToolResultIndexByCallId.set(toolCall.id, existingResultIndex + 1);
+        normalized.push(existingResult);
+        consumedExistingResultCount++;
+        continue;
+      }
+      const restoredResult = createRestoredToolResult(options.sessionId, toolCall, persistedResults.get(toolCall.id));
+      if (restoredResult) {
+        normalized.push(restoredResult);
+        restoredResultCount++;
+        continue;
+      }
+      normalized.push(createSyntheticToolResult(options.sessionId, toolCall));
+      syntheticResultCount++;
+    }
+  }
+  const stats = {
+    messageCount: messages.length,
+    toolCallCount,
+    missingResultCount: missingToolCallIds.length,
+    misplacedResultCount: countMisplacedResults(messages),
+    orphanResultCount: toolResultCount - consumedExistingResultCount,
+    restoredResultCount,
+    syntheticResultCount
+  };
+  (_a = options.logger) == null ? void 0 : _a.warn("Normalize invalid tool call history before model call", {
+    sessionId: options.sessionId,
+    ...stats
+  });
+  return normalized;
+};
+const toolResultIntegrityMiddleware = (options) => (0, import_langchain.createMiddleware)({
+  name: "ToolResultIntegrityMiddleware",
+  wrapModelCall: async (request, handler) => {
+    if (isToolCallHistoryValid(request.messages)) {
+      return handler(request);
+    }
+    request.messages = await normalizeToolCallHistory(request.messages, options);
+    return handler(request);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isToolCallHistoryValid,
+  normalizeToolCallHistory,
+  toolResultIntegrityMiddleware
+});

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;

package/dist/server/ai-employees/reasoning-stream-state.js

@@ -0,0 +1,63 @@
+/**
+ * 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 reasoning_stream_state_exports = {};
+__export(reasoning_stream_state_exports, {
+  ReasoningStreamState: () => ReasoningStreamState,
+  isReasoningFinishChunk: () => isReasoningFinishChunk
+});
+module.exports = __toCommonJS(reasoning_stream_state_exports);
+const getConversationKey = (conversation) => `${conversation.from}:${conversation.sessionId}:${conversation.username}`;
+class ReasoningStreamState {
+  active = /* @__PURE__ */ new Map();
+  start(conversation) {
+    this.active.set(getConversationKey(conversation), conversation);
+  }
+  stop(conversation) {
+    return this.active.delete(getConversationKey(conversation));
+  }
+  drain() {
+    const conversations = Array.from(this.active.values());
+    this.active.clear();
+    return conversations;
+  }
+}
+const isReasoningFinishChunk = (chunk) => {
+  const metadata = chunk.response_metadata;
+  if (!metadata) {
+    return false;
+  }
+  const finishReason = metadata.finish_reason ?? metadata.finishReason;
+  if (typeof finishReason === "string" && finishReason.length > 0) {
+    return true;
+  }
+  return metadata.status === "completed" || metadata.status === "incomplete" || metadata.status === "failed";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReasoningStreamState,
+  isReasoningFinishChunk
+});

package/dist/server/collections/ai-conversations.js

@@ -57,6 +57,11 @@ var ai_conversations_default = (0, import_database.defineCollection)({
       defaultValue: "main-agent",
       allowNull: false
     },
+    {
+      name: "scope",
+      type: "string",
+      index: true
+    },
     {
       name: "user",
       type: "belongsTo",

package/dist/server/document-loader/constants.js

@@ -33,12 +33,12 @@ module.exports = __toCommonJS(constants_exports);
 const DOCUMENT_PARSE_META_KEY = "documentParse";
 const SUPPORTED_DOCUMENT_EXTNAMES = [
   ".pdf",
-  ".ppt",
   ".pptx",
   ".doc",
   ".docx",
   ".xls",
   ".xlsx",
+  ".xlsm",
   ".txt",
   ".md",
   ".json",

package/dist/server/features/knowledge-base.d.ts

@@ -7,8 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { DocumentSegmentedWithScore, KnowledgeBase, KnowledgeBaseGroup, SearchOptions } from '../types';
+export type KnowledgeBaseAccessOptions = Pick<SearchOptions, 'knowledgeBaseKeys' | 'roleNames'>;
 export interface KnowledgeBaseFeature {
     getKnowledgeBase(knowledgeBaseKeys: string[]): Promise<KnowledgeBase[]>;
     getKnowledgeBaseGroup(knowledgeBaseKeys: string[]): Promise<KnowledgeBaseGroup[]>;
+    getAccessibleKnowledgeBaseKeys(options: KnowledgeBaseAccessOptions): Promise<string[]>;
     search(options: SearchOptions): Promise<DocumentSegmentedWithScore[]>;
 }

package/dist/server/frontend-tools.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 type { Context } from '@nocobase/actions';
+import { type FrontendToolManifest } from '../common/frontend-tools';
+import type { WorkContext } from './types/ai-message.type';
+export declare const extractFrontendToolManifests: (workContext: WorkContext[]) => FrontendToolManifest[];
+export declare const listCurrentFrontendTools: (ctx: Context, sessionId?: string) => Promise<FrontendToolManifest[]>;
+export declare const findCurrentFrontendTool: (ctx: Context, toolId: string, sessionId?: string) => Promise<FrontendToolManifest | undefined>;
+export declare const shouldAutoExecuteFrontendTool: (tools: FrontendToolManifest[], args: unknown) => boolean;
+export declare const prepareToolsForFrontendConversation: <T extends {
+    definition: {
+        name: string;
+        description: string;
+    };
+}>(tools: T[], frontendTools: FrontendToolManifest[]) => T[];
+export declare const readFrontendToolResult: (ctx: Context, toolCallId: string) => {
+    provided: true;
+    value: unknown;
+} | undefined;