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

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

@@ -9,11 +9,13 @@
 import { Model, Transaction } from '@nocobase/database';
 import PluginAIServer from '../plugin';
 import { AIMessage, SubAgentConversationMetadata, UserDecision } from '../types';
+import type { FrontendToolManifest } from '../../common/frontend-tools';
 export type AIConversationsOptions = {
     systemMessage?: unknown;
     skillSettings?: unknown;
     conversationSettings?: unknown;
     modelSettings?: unknown;
+    frontendTools?: FrontendToolManifest[];
     [key: string]: unknown;
 };
 export type AIConversationFilterParams = {
@@ -29,6 +31,7 @@ export type CreateAIConversationParams = {
     title?: string;
     options?: AIConversationsOptions;
     from?: 'main-agent' | 'sub-agent';
+    scope?: string;
     transaction?: Transaction;
     category?: 'chat' | 'task';
 };
@@ -55,7 +58,7 @@ export declare const registerAIConversationReadNotification: (plugin: PluginAISe
 export declare class AIConversationsManager {
     protected plugin: PluginAIServer;
     constructor(plugin: PluginAIServer);
-    create({ userId, aiEmployee, title, options, from, transaction, category, }: CreateAIConversationParams): Promise<any>;
+    create({ userId, aiEmployee, title, options, from, scope, transaction, category, }: CreateAIConversationParams): Promise<any>;
     update({ userId, sessionId, title, options: inputOptions }: UpdateAIConversationParams): Promise<any>;
     getConversation({ sessionId, userId }: {
         sessionId: string;

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

@@ -66,6 +66,7 @@ class AIConversationsManager {
     title,
     options = {},
     from = "main-agent",
+    scope,
     transaction,
     category = "chat"
   }) {
@@ -77,6 +78,7 @@ class AIConversationsManager {
         options,
         thread: 1,
         from,
+        ...scope !== void 0 ? { scope } : {},
         category
       },
       transaction

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

@@ -36,6 +36,7 @@ export declare class AIEmployee {
     employee: Model;
     aiChatConversation: AIChatConversation;
     skillSettings?: Record<string, any>;
+    userMessageCount: number;
     private plugin;
     private db;
     private ctx;
@@ -117,7 +118,7 @@ export declare class AIEmployee {
     initToolCall(transaction: Transaction, messageId: string, toolCalls: {
         id: string;
         name: string;
-        args: any;
+        args: unknown;
     }[]): Promise<Model<AIToolMessage>[]>;
     updateToolCallInterrupted(sessionId: string, messageId: string, toolCallId: string, interruptId: string, interruptAction: {
         order: number;

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

@@ -56,12 +56,15 @@ 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");
 class AIEmployee {
   sessionId;
   from = "main-agent";
   employee;
   aiChatConversation;
   skillSettings;
+  userMessageCount = 0;
   plugin;
   db;
   ctx;
@@ -142,7 +145,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,
@@ -199,6 +207,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,
@@ -747,7 +756,8 @@ ${addSystemPrompt.map((it) => it.content).join("\n")}`;
       },
       knowledgeBase,
       availableSkills,
-      availableAIEmployees
+      availableAIEmployees,
+      webSearch: this.webSearch
     });
     const { important } = ((_g = (_f = this.ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.values) || {};
     if (important === "GraphRecursionError") {
@@ -763,11 +773,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,
@@ -1184,7 +1195,12 @@ If information is missing, clearly state it in the summary.</Important>`;
     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);
@@ -1211,20 +1227,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);
       }
     }
   }
@@ -1266,6 +1288,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/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/tool-call-sanitizer.d.ts

@@ -20,6 +20,7 @@ type SanitizeAdditionalKwargsOptions = {
 type SanitizeAdditionalKwargsResult = {
     changed: boolean;
     additionalKwargs?: AdditionalKwargs;
+    malformedToolCalls?: unknown[];
 };
 export declare const sanitizeAdditionalKwargsForToolCalls: (additionalKwargs: AdditionalKwargs | undefined, parsedToolCalls?: unknown[] | null, options?: SanitizeAdditionalKwargsOptions) => SanitizeAdditionalKwargsResult;
 export declare const sanitizeLangChainAIMessage: (message: AIMessage, options?: SanitizeAdditionalKwargsOptions) => AIMessage<import("@langchain/core/dist/messages/message").MessageStructure<import("@langchain/core/dist/messages/message").MessageToolSet>>;

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

@@ -65,7 +65,8 @@ const sanitizeAdditionalKwargsForToolCalls = (additionalKwargs, parsedToolCalls,
   delete sanitized.tool_calls;
   return {
     changed: true,
-    additionalKwargs: Object.keys(sanitized).length > 0 ? sanitized : void 0
+    additionalKwargs: Object.keys(sanitized).length > 0 ? sanitized : void 0,
+    malformedToolCalls: rawToolCalls
   };
 };
 const sanitizeLangChainAIMessage = (message, options = {}) => {

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

@@ -40,7 +40,7 @@ const convertAIMessage = ({
   model,
   aiMessage
 }) => {
-  var _a;
+  var _a, _b;
   const message = aiMessage.content;
   const toolCalls = aiMessage.tool_calls;
   const tools = (_a = aiEmployee.skillSettings) == null ? void 0 : _a.tools;
@@ -91,20 +91,26 @@ const convertAIMessage = ({
   if (aiMessage.response_metadata) {
     values.metadata.response_metadata = aiMessage.response_metadata;
   }
-  const additionalKwargs = (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)(aiMessage.additional_kwargs, toolCalls, {
+  const sanitizedToolCalls = (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)(aiMessage.additional_kwargs, toolCalls, {
     onDiscard: (info) => {
-      var _a2, _b;
-      (_b = aiEmployee.logger) == null ? void 0 : _b.warn("Discard malformed raw tool calls from AI message", {
+      var _a2, _b2;
+      (_b2 = aiEmployee.logger) == null ? void 0 : _b2.warn("Discard malformed raw tool calls from AI message", {
         phase: "convertAIMessage",
         messageId: aiMessage.id,
         invalidToolCallCount: ((_a2 = aiMessage.invalid_tool_calls) == null ? void 0 : _a2.length) ?? 0,
         ...info
       });
     }
-  }).additionalKwargs;
+  });
+  const additionalKwargs = sanitizedToolCalls.additionalKwargs;
   if (additionalKwargs) {
     values.metadata.additional_kwargs = additionalKwargs;
   }
+  if ((_b = sanitizedToolCalls.malformedToolCalls) == null ? void 0 : _b.length) {
+    values.metadata.diagnostics = {
+      malformedToolCalls: sanitizedToolCalls.malformedToolCalls
+    };
+  }
   providerInstance.reshapeAIMessage({ aiMessage, values });
   return values;
 };

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/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/dashscope.d.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { AIMessageChunk } from '@langchain/core/messages';
-import { EmbeddingProvider, LLMProvider } from './provider';
+import { EmbeddingProvider, LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from './provider';
 import { EmbeddingsInterface } from '@langchain/core/embeddings';
 import { SupportedModel } from '../manager/ai-manager';
 import { Model } from '@nocobase/database';
@@ -19,6 +19,7 @@ export declare class DashscopeProvider extends LLMProvider {
     createModel(): ReasoningChatOpenAI;
     isToolConflict(): boolean;
     resolveTools(toolDefinitions: any[]): any[];
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     parseResponseMessage(message: Model): {
         key: any;
         createdAt: any;

package/dist/server/llm-providers/dashscope.js

@@ -56,6 +56,7 @@ class DashscopeProvider extends import_provider.LLMProvider {
     const { apiKey } = this.serviceOptions || {};
     const { responseFormat, structuredOutput } = this.modelOptions || {};
     const { name, schema } = structuredOutput || {};
+    const reasoningOptions = this.resolveReasoningOptions(this.modelReasoningOptions);
     const modelKwargs = {};
     if (responseFormat) {
       const responseFormatOptions = {
@@ -76,7 +77,11 @@ class DashscopeProvider extends import_provider.LLMProvider {
       topP: 0.8,
       temperature: 0.7,
       ...this.modelOptions,
-      modelKwargs,
+      ...reasoningOptions.modelRequestParams || {},
+      modelKwargs: {
+        ...modelKwargs,
+        ...reasoningOptions.modelKwargs || {}
+      },
       configuration: {
         baseURL: this.getResolvedBaseURL()
       },
@@ -94,6 +99,16 @@ class DashscopeProvider extends import_provider.LLMProvider {
       return toolDefinitions;
     }
   }
+  resolveReasoningOptions(reasoning) {
+    if ((reasoning == null ? void 0 : reasoning.mode) !== "off") {
+      return {};
+    }
+    return {
+      modelKwargs: {
+        enable_thinking: false
+      }
+    };
+  }
   parseResponseMessage(message) {
     var _a;
     const result = super.parseResponseMessage(message);

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

@@ -8,7 +8,7 @@
  */
 import { ChatDeepSeek } from '@langchain/deepseek';
 import { AIMessageChunk, BaseMessage } from '@langchain/core/messages';
-import { LLMProvider } from './provider';
+import { LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from './provider';
 import { LLMProviderMeta } from '../manager/ai-manager';
 import { Model } from '@nocobase/database';
 import type OpenAI from 'openai';
@@ -33,6 +33,7 @@ export declare class DeepSeekProvider extends LLMProvider {
         status: string;
         content: string;
     };
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     protected isApiSupportedAttachment(attachment: AttachmentModel): boolean;
 }
 export declare const deepseekProviderOptions: LLMProviderMeta;