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

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/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;

package/dist/server/frontend-tools.js

@@ -0,0 +1,171 @@
+/**
+ * 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 frontend_tools_exports = {};
+__export(frontend_tools_exports, {
+  extractFrontendToolManifests: () => extractFrontendToolManifests,
+  findCurrentFrontendTool: () => findCurrentFrontendTool,
+  listCurrentFrontendTools: () => listCurrentFrontendTools,
+  prepareToolsForFrontendConversation: () => prepareToolsForFrontendConversation,
+  readFrontendToolResult: () => readFrontendToolResult,
+  shouldAutoExecuteFrontendTool: () => shouldAutoExecuteFrontendTool
+});
+module.exports = __toCommonJS(frontend_tools_exports);
+var import_zod = require("zod");
+var import_frontend_tools = require("../common/frontend-tools");
+const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const isMessageLike = (value) => !!value && typeof value === "object";
+const normalizeFrontendToolManifests = (value) => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const manifests = /* @__PURE__ */ new Map();
+  for (const manifest of value) {
+    if ((0, import_frontend_tools.isFrontendToolManifest)(manifest) && manifest.id === `${manifest.blockUid}:${manifest.name}`) {
+      manifests.set(manifest.id, manifest);
+    }
+  }
+  return Array.from(manifests.values());
+};
+const extractFrontendToolManifests = (workContext) => {
+  const manifests = /* @__PURE__ */ new Map();
+  for (const item of workContext) {
+    const frontendTools = Array.isArray(item == null ? void 0 : item.frontendTools) ? item.frontendTools : [];
+    for (const frontendTool of frontendTools) {
+      if ((0, import_frontend_tools.isFrontendToolManifest)(frontendTool) && frontendTool.blockUid === item.uid && frontendTool.id === `${item.uid}:${frontendTool.name}`) {
+        manifests.set(frontendTool.id, frontendTool);
+      }
+    }
+  }
+  return Array.from(manifests.values());
+};
+const findRequestFrontendTools = (ctx) => {
+  var _a, _b;
+  const values = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values;
+  const messages = Array.isArray(values == null ? void 0 : values.messages) ? values.messages.filter(isMessageLike) : [];
+  for (const message of messages) {
+    if (message.role !== "user") {
+      continue;
+    }
+    const frontendTools = extractFrontendToolManifests(Array.isArray(message.workContext) ? message.workContext : []);
+    if (frontendTools.length) {
+      return frontendTools;
+    }
+  }
+  return [];
+};
+const listCurrentFrontendTools = async (ctx, sessionId) => {
+  var _a, _b, _c;
+  const requestSessionId = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.sessionId;
+  const currentSessionId = sessionId ?? (typeof requestSessionId === "string" ? requestSessionId : "");
+  if (!currentSessionId) {
+    return findRequestFrontendTools(ctx);
+  }
+  const conversationRepository = ctx.db.getRepository("aiConversations");
+  const conversation = await conversationRepository.findOne({
+    filter: {
+      sessionId: currentSessionId
+    }
+  });
+  const options = conversation == null ? void 0 : conversation.options;
+  const boundTools = normalizeFrontendToolManifests(isRecord(options) ? options.frontendTools : void 0);
+  if (boundTools.length) {
+    return boundTools;
+  }
+  const frontendTools = findRequestFrontendTools(ctx);
+  if (!frontendTools.length || !conversation) {
+    return frontendTools;
+  }
+  await conversationRepository.update({
+    filter: {
+      sessionId: currentSessionId
+    },
+    values: {
+      options: {
+        ...isRecord(options) ? options : {},
+        frontendTools
+      }
+    }
+  });
+  return frontendTools;
+};
+const findCurrentFrontendTool = async (ctx, toolId, sessionId) => {
+  const tools = await listCurrentFrontendTools(ctx, sessionId);
+  return tools.find((tool) => tool.id === toolId);
+};
+const shouldAutoExecuteFrontendTool = (tools, args) => {
+  var _a;
+  if (!isRecord(args) || typeof args.toolId !== "string") {
+    return false;
+  }
+  return ((_a = tools.find((tool) => tool.id === args.toolId)) == null ? void 0 : _a.permission) === "ALLOW";
+};
+const prepareToolsForFrontendConversation = (tools, frontendTools) => {
+  if (!frontendTools.length) {
+    return tools.filter(
+      (tool) => tool.definition.name !== import_frontend_tools.LOAD_FRONTEND_TOOL_NAME && tool.definition.name !== import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME
+    );
+  }
+  const catalog = frontendTools.map(({ id, name, title, description }) => ({ id, name, title, description }));
+  const toolIds = frontendTools.map((tool) => tool.id);
+  const toolIdSchema = import_zod.z.enum(toolIds).describe(`Use an exact tool id from this catalog: ${JSON.stringify(catalog)}`);
+  return tools.map((tool) => {
+    if (tool.definition.name !== import_frontend_tools.LOAD_FRONTEND_TOOL_NAME && tool.definition.name !== import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME) {
+      return tool;
+    }
+    const isLoader = tool.definition.name === import_frontend_tools.LOAD_FRONTEND_TOOL_NAME;
+    return {
+      ...tool,
+      definition: {
+        ...tool.definition,
+        description: `${tool.definition.description}
+
+frontendToolCatalog: ${JSON.stringify(catalog)}`,
+        schema: isLoader ? import_zod.z.object({ toolId: toolIdSchema }) : import_zod.z.object({
+          toolId: toolIdSchema,
+          args: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).default({})
+        })
+      }
+    };
+  });
+};
+const readFrontendToolResult = (ctx, toolCallId) => {
+  var _a, _b, _c;
+  const toolCallResults = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.toolCallResults;
+  const result = Array.isArray(toolCallResults) ? toolCallResults.find(
+    (item) => isRecord(item) && item.id === toolCallId && "result" in item
+  ) : void 0;
+  return result ? { provided: true, value: result.result } : void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractFrontendToolManifests,
+  findCurrentFrontendTool,
+  listCurrentFrontendTools,
+  prepareToolsForFrontendConversation,
+  readFrontendToolResult,
+  shouldAutoExecuteFrontendTool
+});

package/dist/server/llm-providers/common/reasoning.js

@@ -55,19 +55,27 @@ const collectReasoningMap = (messages) => {
   return reasoningMap;
 };
 const patchRequestMessagesReasoning = (request, reasoningMap) => {
+  var _a;
   if (!(reasoningMap == null ? void 0 : reasoningMap.size) || !Array.isArray(request == null ? void 0 : request.messages)) {
     return;
   }
-  if (request.messages.some((msg) => msg.role === "tool")) {
-    for (let i = 0; i < request.messages.length; i++) {
-      const message = request.messages[i];
-      if ((message == null ? void 0 : message.role) !== "assistant") {
-        continue;
-      }
-      if (message.reasoning_content) {
-        continue;
-      }
-      const reasoningContent = reasoningMap.get(String(i));
+  let lastUserMessageIndex = -1;
+  for (let i = request.messages.length - 1; i >= 0; i--) {
+    if (((_a = request.messages[i]) == null ? void 0 : _a.role) === "user") {
+      lastUserMessageIndex = i;
+      break;
+    }
+  }
+  for (let i = lastUserMessageIndex + 1; i < request.messages.length; i++) {
+    const message = request.messages[i];
+    if ((message == null ? void 0 : message.role) !== "assistant" || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
+      continue;
+    }
+    if (typeof message.reasoning_content === "string" && message.reasoning_content.length > 0) {
+      continue;
+    }
+    const reasoningContent = reasoningMap.get(String(i));
+    if (typeof reasoningContent === "string" && reasoningContent.length > 0) {
       message.reasoning_content = reasoningContent;
     }
   }

package/dist/server/llm-providers/deepseek/index.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.
+ */
+export * from './provider';
+export * from './reasoning';

package/dist/server/llm-providers/deepseek/index.js

@@ -0,0 +1,32 @@
+/**
+ * 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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deepseek_exports = {};
+module.exports = __toCommonJS(deepseek_exports);
+__reExport(deepseek_exports, require("./provider"), module.exports);
+__reExport(deepseek_exports, require("./reasoning"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./provider"),
+  ...require("./reasoning")
+});

package/dist/server/llm-providers/deepseek/provider.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 { ChatDeepSeek, type ChatDeepSeekInput } from '@langchain/deepseek';
+import { AIMessage, AIMessageChunk, BaseMessage } from '@langchain/core/messages';
+import { ChatOpenAI } from '@langchain/openai';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type OpenAI from 'openai';
+import { Model } from '@nocobase/database';
+import { LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from '../provider';
+import { LLMProviderMeta } from '../../manager/ai-manager';
+import { DeepSeekReasoningConfig } from './reasoning';
+import type { AIMessageInput } from '../../types';
+declare class ReasoningDeepSeek extends ChatDeepSeek {
+    private readonly reasoningConfig;
+    constructor(fields: ChatDeepSeekInput, reasoningConfig: DeepSeekReasoningConfig);
+    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<import("@langchain/core/dist/outputs").ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<import("@langchain/core/dist/outputs").ChatGenerationChunk, void, unknown>;
+    completionWithRetry(request: OpenAI.Chat.ChatCompletionCreateParamsStreaming, requestOptions?: OpenAI.RequestOptions): Promise<AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>>;
+    completionWithRetry(request: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming, requestOptions?: OpenAI.RequestOptions): Promise<OpenAI.Chat.Completions.ChatCompletion>;
+}
+export declare class DeepSeekProvider extends LLMProvider {
+    chatModel: ChatDeepSeek | ChatOpenAI;
+    get baseURL(): string;
+    createModel(): ChatOpenAI<import("@langchain/openai/dist/chat_models/index.cjs").ChatOpenAICallOptions> | ReasoningDeepSeek;
+    parseResponseChunk(chunk: unknown): string;
+    parseResponseMessage(message: Model): {
+        key: any;
+        createdAt: any;
+        content: any;
+        role: any;
+    };
+    parseReasoningContent(chunk: AIMessageChunk): {
+        status: string;
+        content: string;
+    } | null;
+    reshapeAIMessage({ aiMessage, values }: {
+        aiMessage: AIMessage;
+        values: AIMessageInput;
+    }): void;
+    prepareStoredAssistantAdditionalKwargs(additionalKwargs?: Record<string, unknown>): Record<string, unknown> | undefined;
+    protected builtInTools(): Record<string, unknown>[];
+    parseWebSearchAction(chunk: AIMessageChunk): {
+        type: string;
+        query: string;
+    }[];
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
+    isToolConflict(): boolean;
+    protected isApiSupportedAttachment(): boolean;
+}
+export declare const deepseekProviderOptions: LLMProviderMeta;
+export {};