@nocobase/plugin-ai 2.1.0-beta.15 → 2.1.0-beta.16

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

@@ -36,17 +36,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ai_employee_exports = {};
 __export(ai_employee_exports, {
-  AIEmployee: () => AIEmployee
+  AIEmployee: () => AIEmployee,
+  ChatStreamProtocol: () => ChatStreamProtocol
 });
 module.exports = __toCommonJS(ai_employee_exports);
 var import_database = require("@nocobase/database");
-var import_provider = require("../llm-providers/provider");
 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_feature_manager = require("../manager/ai-feature-manager");
-var import_prompts2 = require("@langchain/core/prompts");
 var import_middleware = require("./middleware");
 var import_checkpoints = require("./checkpoints");
 var import_langchain = require("langchain");
@@ -54,20 +52,35 @@ var import_langgraph = require("@langchain/langgraph");
 var import_stream = require("@langchain/core/utils/stream");
 var import_utils2 = require("./utils");
 var import_base = require("@langchain/core/callbacks/base");
+var import_shared = require("../../ai/tools/sub-agents/shared");
 class AIEmployee {
+  sessionId;
+  from = "main-agent";
   employee;
   aiChatConversation;
   skillSettings;
   plugin;
   db;
-  sessionId;
   ctx;
   systemMessage;
+  protocol;
   webSearch;
   model;
   legacy;
-  protocol;
-  constructor(ctx, employee, sessionId, systemMessage, skillSettings, webSearch, model, legacy) {
+  tools;
+  inWorkflow;
+  constructor({
+    ctx,
+    employee,
+    sessionId,
+    systemMessage,
+    skillSettings,
+    webSearch,
+    model,
+    legacy,
+    from = "main-agent",
+    tools = []
+  }) {
     this.employee = employee;
     this.ctx = ctx;
     this.plugin = ctx.app.pm.get("ai");
@@ -78,11 +91,30 @@ class AIEmployee {
     this.skillSettings = skillSettings;
     this.model = model;
     this.legacy = legacy;
-    const locale = this.ctx.getCurrentLocale();
+    this.from = from;
+    this.tools = tools;
     const builtInManager = this.plugin.builtInManager;
-    builtInManager.setupBuiltInInfo(locale, this.employee);
+    builtInManager.setupBuiltInInfo(ctx, this.employee);
     this.webSearch = webSearch;
-    this.protocol = ChatStreamProtocol.create(ctx);
+    this.protocol = ChatStreamProtocol.fromContext(ctx);
+  }
+  async getFormatMessages(userMessages) {
+    const { provider } = await this.plugin.aiManager.getLLMService({
+      ...this.model
+    });
+    const { messages } = await this.aiChatConversation.getChatContext({
+      userMessages,
+      formatMessages: (messages2) => this.formatMessages({ messages: messages2, provider })
+    });
+    return messages;
+  }
+  async isInWorkflow() {
+    if (this.inWorkflow !== void 0) {
+      return this.inWorkflow;
+    }
+    const conversation = await this.aiConversationsRepo.findByTargetKey(this.sessionId);
+    this.inWorkflow = (conversation == null ? void 0 : conversation.category) === "task";
+    return this.inWorkflow;
   }
   // === Chat flow ===
   buildState(messages) {
@@ -96,12 +128,14 @@ class AIEmployee {
     };
   }
   async initSession({ messageId, provider, model, providerName }) {
-    const tools = await this.getAIEmployeeTools();
+    const { tools, baseToolNames } = await this.getAgentTools();
+    const resolvedTools = provider.resolveTools(tools.map(import_utils.buildTool));
     if (!messageId && this.legacy !== true) {
       return {
         historyMessages: [],
         tools,
-        middleware: this.getMiddleware({ tools, model, providerName }),
+        resolvedTools,
+        middleware: await this.getMiddleware({ tools, baseToolNames, model, providerName }),
         config: void 0,
         state: void 0
       };
@@ -113,8 +147,10 @@ class AIEmployee {
     return {
       historyMessages,
       tools,
-      middleware: this.getMiddleware({
+      resolvedTools,
+      middleware: await this.getMiddleware({
         tools,
+        baseToolNames,
         model,
         providerName,
         messageId,
@@ -136,7 +172,7 @@ class AIEmployee {
     const { provider, model, service } = await this.plugin.aiManager.getLLMService({
       ...this.model
     });
-    const { historyMessages, tools, middleware, config, state } = await this.initSession({
+    const { historyMessages, tools, resolvedTools, middleware, config, state } = await this.initSession({
       messageId,
       provider,
       model,
@@ -145,7 +181,7 @@ class AIEmployee {
     const chatContext = await this.aiChatConversation.getChatContext({
       userMessages: [...historyMessages, ...userMessages ?? []],
       userDecisions,
-      tools,
+      tools: resolvedTools,
       middleware,
       getSystemPrompt: (userMessages2) => this.getSystemPrompt(userMessages2),
       formatMessages: (messages) => this.formatMessages({ messages, provider })
@@ -157,6 +193,12 @@ class AIEmployee {
     userMessages = [],
     userDecisions
   }) {
+    await this.aiConversationsRepo.update({
+      values: { llmActiveState: "streaming" },
+      filter: {
+        sessionId: this.sessionId
+      }
+    });
     try {
       const { providerName, model, provider, chatContext, config, state } = await this.buildChatContext({
         messageId,
@@ -183,13 +225,29 @@ class AIEmployee {
       this.ctx.log.error(err);
       this.sendErrorResponse(err.message || "Chat error warning");
       return false;
+    } finally {
+      await this.aiConversationsRepo.update({
+        values: { llmActiveState: "idle" },
+        filter: {
+          sessionId: this.sessionId
+        }
+      });
     }
   }
   async invoke({
     messageId,
     userMessages = [],
-    userDecisions
+    userDecisions,
+    writer,
+    context
   }) {
+    var _a;
+    await this.aiConversationsRepo.update({
+      values: { llmActiveState: "invoking" },
+      filter: {
+        sessionId: this.sessionId
+      }
+    });
     try {
       const { provider, chatContext, config, state } = await this.buildChatContext({
         messageId,
@@ -198,15 +256,28 @@ class AIEmployee {
       });
       const { threadId } = await this.getCurrentThread();
       const invokeConfig = {
-        configurable: { thread_id: threadId },
-        context: { ctx: this.ctx },
+        context: { ctx: this.ctx, decisions: chatContext.decisions, ...context },
         recursionLimit: 100,
+        configurable: this.from === "main-agent" ? { thread_id: threadId } : void 0,
+        writer,
         ...config
       };
-      return await this.agentInvoke(provider, chatContext, invokeConfig, state);
+      const invokeResult = await this.agentInvoke(provider, chatContext, invokeConfig, state);
+      await this.handleInterruptedToolCalls((_a = invokeResult == null ? void 0 : invokeResult.__interrupt__) == null ? void 0 : _a[0], () => invokeResult == null ? void 0 : invokeResult.messageId);
+      return invokeResult;
     } catch (err) {
+      if (err.name === "GraphInterrupt") {
+        throw err;
+      }
       this.ctx.log.error(err);
       throw err;
+    } finally {
+      await this.aiConversationsRepo.update({
+        values: { llmActiveState: "idle" },
+        filter: {
+          sessionId: this.sessionId
+        }
+      });
     }
   }
   // === Agent wiring & execution ===
@@ -217,17 +288,24 @@ class AIEmployee {
     middleware
   }) {
     const model = provider.createModel();
-    const toolDefinitions = (tools == null ? void 0 : tools.map(import_provider.ToolDefinition.from("ToolsEntry"))) ?? [];
-    const allTools = provider.resolveTools(toolDefinitions);
-    const checkpointer = new import_checkpoints.SequelizeCollectionSaver(() => this.ctx.app.mainDataSource);
-    return (0, import_langchain.createAgent)({ model, tools: allTools, middleware, systemPrompt, checkpointer });
+    const allTools = tools ?? [];
+    if (this.from === "main-agent") {
+      const checkpointer = new import_checkpoints.SequelizeCollectionSaver(() => this.ctx.app.mainDataSource);
+      return (0, import_langchain.createAgent)({ model, tools: allTools, middleware, systemPrompt, checkpointer });
+    } else {
+      return (0, import_langchain.createAgent)({ model, tools: allTools, middleware, systemPrompt });
+    }
   }
   getAgentInput(context, state) {
-    var _a;
-    if ((_a = context.decisions) == null ? void 0 : _a.length) {
+    var _a, _b;
+    if ((_b = (_a = context.decisions) == null ? void 0 : _a.decisions) == null ? void 0 : _b.length) {
       return new import_langgraph.Command({
-        resume: {
-          decisions: context.decisions
+        resume: context.decisions.interruptId ? {
+          [context.decisions.interruptId]: {
+            decisions: context.decisions.decisions
+          }
+        } : {
+          decisions: context.decisions.decisions
         }
       });
     }
@@ -240,13 +318,16 @@ class AIEmployee {
     const { systemPrompt, tools, middleware } = context;
     const agent = await this.createAgent({ provider, systemPrompt, tools, middleware });
     const input = this.getAgentInput(context, state);
-    return agent.stream(input, config);
+    if (this.from === "sub-agent") {
+      delete config.configurable;
+    }
+    return agent.stream(input, this.withRunMetadata(config));
   }
   async agentInvoke(provider, context, config, state) {
     const { systemPrompt, tools, middleware } = context;
     const agent = await this.createAgent({ provider, systemPrompt, tools, middleware });
     const input = this.getAgentInput(context, state);
-    return agent.invoke(input, config);
+    return agent.invoke(input, this.withRunMetadata(config));
   }
   async prepareChatStream({
     chatContext,
@@ -264,8 +345,8 @@ class AIEmployee {
         {
           signal,
           streamMode: ["updates", "messages", "custom"],
-          configurable: { thread_id: threadId },
-          context: { ctx: this.ctx },
+          configurable: this.from === "main-agent" ? { thread_id: threadId } : void 0,
+          context: { ctx: this.ctx, decisions: chatContext.decisions },
           recursionLimit: 100,
           ...config
         },
@@ -278,8 +359,8 @@ class AIEmployee {
     }
   }
   async processChatStream(stream, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
-    let toolCalls;
+    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, model, provider, responseMetadata, allowEmpty = false } = options;
     let isReasoning = false;
     let gathered;
@@ -297,9 +378,6 @@ class AIEmployee {
           }
           await this.aiChatConversation.withTransaction(async (conversation, transaction) => {
             const result = await conversation.addMessages(values);
-            if (toolCalls == null ? void 0 : toolCalls.length) {
-              await this.initToolCall(transaction, result.messageId, toolCalls);
-            }
           });
         }
       } catch (e) {
@@ -307,60 +385,66 @@ class AIEmployee {
       }
     });
     try {
-      this.protocol.startStream();
+      const aiEmployeeConversation = {
+        sessionId: this.sessionId,
+        from: this.from,
+        username: this.employee.username
+      };
+      this.protocol.with(aiEmployeeConversation).startStream();
       for await (const [mode, chunks] of stream) {
         if (mode === "messages") {
-          const [chunk] = chunks;
+          const [chunk, metadata] = chunks;
+          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;
-                this.protocol.stopReasoning();
+                this.protocol.with(currentConversation).stopReasoning();
               }
               const parsedContent = provider.parseResponseChunk(chunk.content);
               if (parsedContent) {
-                this.protocol.content(parsedContent);
+                this.protocol.with(currentConversation).content(parsedContent);
               }
             }
             if ((_a = chunk.tool_call_chunks) == null ? void 0 : _a.length) {
-              this.protocol.toolCallChunks(chunk.tool_call_chunks);
+              this.protocol.with(currentConversation).toolCallChunks(chunk.tool_call_chunks);
             }
             const webSearch = provider.parseWebSearchAction(chunk);
             if (webSearch == null ? void 0 : webSearch.length) {
-              this.protocol.webSearch(webSearch);
+              this.protocol.with(currentConversation).webSearch(webSearch);
             }
             const reasoningContent = provider.parseReasoningContent(chunk);
             if (reasoningContent) {
               isReasoning = true;
-              this.protocol.reasoning(reasoningContent);
+              this.protocol.with(currentConversation).reasoning(reasoningContent);
             }
           }
         } else if (mode === "updates") {
-          if ("__interrupt__" in chunks) {
-            const interruptActions = this.toInterruptActions(chunks.__interrupt__[0].value);
-            if (interruptActions.size) {
-              for (const toolCall of toolCalls ?? []) {
-                const interruptAction = interruptActions.get(toolCall.name);
-                if (!interruptAction) {
-                  continue;
-                }
-                await this.updateToolCallInterrupted(toolCall.messageId, toolCall.id, interruptAction);
-                this.protocol.toolCallStatus({
+          const interrupt = (_b = chunks == null ? void 0 : chunks.__interrupt__) == null ? void 0 : _b[0];
+          if (interrupt) {
+            const toolsMap = await this.getToolsMap();
+            await this.handleInterruptedToolCalls(
+              interrupt,
+              (sessionId) => aiMessageIdMap.get(sessionId),
+              ({ messageId, interruptAction, toolCall, currentConversation }) => {
+                this.protocol.with(currentConversation).toolCallStatus({
                   toolCall: {
-                    messageId: toolCall.messageId,
+                    messageId,
                     id: toolCall.id,
                     name: toolCall.name,
-                    willInterrupt: toolCall.willInterrupt
+                    willInterrupt: this.shouldInterruptToolCall(toolsMap.get(toolCall.name))
                   },
                   invokeStatus: "interrupted",
                   interruptAction
                 });
               }
-            }
+            );
           }
         } else if (mode === "custom") {
+          const { currentConversation } = chunks;
           if (chunks.action === "AfterAIMessageSaved") {
+            aiMessageIdMap.set(currentConversation.sessionId, chunks.body.messageId);
             const data = responseMetadata.get(chunks.body.id);
             if (data) {
               const savedMessage = await this.aiMessagesModel.findOne({
@@ -388,12 +472,11 @@ class AIEmployee {
               }
             }
           } else if (chunks.action === "initToolCalls") {
-            toolCalls = ((_b = chunks.body) == null ? void 0 : _b.toolCalls) ?? [];
-            this.protocol.toolCalls(chunks.body);
+            this.protocol.with(currentConversation).toolCalls(chunks.body);
           } else if (chunks.action === "beforeToolCall") {
             const toolsMap = await this.getToolsMap();
             const willInterrupt = this.shouldInterruptToolCall(toolsMap.get((_d = (_c = chunks.body) == null ? void 0 : _c.toolCall) == null ? void 0 : _d.name));
-            this.protocol.toolCallStatus({
+            this.protocol.with(currentConversation).toolCallStatus({
               toolCall: {
                 messageId: (_f = (_e = chunks.body) == null ? void 0 : _e.toolCall) == null ? void 0 : _f.messageId,
                 id: (_h = (_g = chunks.body) == null ? void 0 : _g.toolCall) == null ? void 0 : _h.id,
@@ -405,7 +488,7 @@ class AIEmployee {
           } else if (chunks.action === "afterToolCall") {
             const toolsMap = await this.getToolsMap();
             const willInterrupt = this.shouldInterruptToolCall(toolsMap.get((_l = (_k = chunks.body) == null ? void 0 : _k.toolCall) == null ? void 0 : _l.name));
-            this.protocol.toolCallStatus({
+            this.protocol.with(currentConversation).toolCallStatus({
               toolCall: {
                 messageId: (_n = (_m = chunks.body) == null ? void 0 : _m.toolCall) == null ? void 0 : _n.messageId,
                 id: (_p = (_o = chunks.body) == null ? void 0 : _o.toolCall) == null ? void 0 : _p.id,
@@ -413,7 +496,10 @@ class AIEmployee {
                 willInterrupt
               },
               invokeStatus: "done",
-              status: (_t = (_s = chunks.body) == null ? void 0 : _s.toolCallResult) == null ? void 0 : _t.status
+              status: (_t = (_s = chunks.body) == null ? void 0 : _s.toolCallResult) == null ? void 0 : _t.status,
+              invokeStartTime: (_v = (_u = chunks.body) == null ? void 0 : _u.toolCallResult) == null ? void 0 : _v.invokeStartTime,
+              invokeEndTime: (_x = (_w = chunks.body) == null ? void 0 : _w.toolCallResult) == null ? void 0 : _x.invokeEndTime,
+              content: (_z = (_y = chunks.body) == null ? void 0 : _y.toolCallResult) == null ? void 0 : _z.content
             });
           } else if (chunks.action === "beforeSendToolMessage") {
             const { messageId, messages } = chunks.body ?? {};
@@ -426,7 +512,7 @@ class AIEmployee {
               for (const { metadata } of messages) {
                 const tools = toolsMap.get(metadata.toolName);
                 const toolCallResult = toolCallResultMap.get(metadata.toolCallId);
-                this.protocol.toolCallStatus({
+                this.protocol.with(currentConversation).toolCallStatus({
                   toolCall: {
                     messageId,
                     id: metadata.toolCallId,
@@ -434,11 +520,16 @@ class AIEmployee {
                     willInterrupt: this.shouldInterruptToolCall(tools)
                   },
                   invokeStatus: "confirmed",
-                  status: toolCallResult == null ? void 0 : toolCallResult.status
+                  status: toolCallResult == null ? void 0 : toolCallResult.status,
+                  invokeStartTime: toolCallResult == null ? void 0 : toolCallResult.invokeStartTime,
+                  invokeEndTime: toolCallResult == null ? void 0 : toolCallResult.invokeEndTime,
+                  content: toolCallResult == null ? void 0 : toolCallResult.content
                 });
               }
             }
-            this.protocol.newMessage();
+            this.protocol.with(currentConversation).newMessage();
+          } else if (chunks.action === "afterSubAgentInvoke") {
+            this.protocol.with(currentConversation).subAgentCompleted();
           }
         }
       }
@@ -446,7 +537,7 @@ class AIEmployee {
         this.sendErrorResponse("Empty message");
         return;
       }
-      this.protocol.endStream();
+      this.protocol.with(aiEmployeeConversation).endStream();
     } catch (err) {
       this.ctx.log.error(err);
       if (err.name === "GraphRecursionError") {
@@ -455,7 +546,42 @@ class AIEmployee {
         this.sendErrorResponse(provider.parseResponseError(err));
       }
     } finally {
-      this.ctx.res.end();
+      if (this.from === "main-agent") {
+        this.ctx.res.end();
+      }
+    }
+  }
+  async handleInterruptedToolCalls(interrupt, getMessageId, onInterrupted) {
+    const interruptId = interrupt == null ? void 0 : interrupt.id;
+    const interruptActions = this.toInterruptActions(interrupt == null ? void 0 : interrupt.value);
+    if (!interruptId || !interruptActions.size) {
+      return;
+    }
+    for (const interruptAction of interruptActions.values()) {
+      const currentConversation = interruptAction.currentConversation;
+      const toolCall = interruptAction.toolCall;
+      if (!currentConversation || !toolCall) {
+        this.logger.warn("currentConversation or toolCall not exist in __interrupt__", interruptAction);
+        continue;
+      }
+      const messageId = getMessageId(currentConversation.sessionId);
+      if (!messageId) {
+        continue;
+      }
+      await this.updateToolCallInterrupted(
+        currentConversation.sessionId,
+        messageId,
+        toolCall.id,
+        interruptId,
+        interruptAction
+      );
+      await (onInterrupted == null ? void 0 : onInterrupted({
+        messageId,
+        interruptId,
+        interruptAction,
+        toolCall,
+        currentConversation
+      }));
     }
   }
   // === Prompts & knowledge base ===
@@ -501,10 +627,10 @@ Field: ${field.name}, Title: ${(_a = field.options.uiSchema) == null ? void 0 :
     return message;
   }
   async getSystemPrompt(userMessages) {
-    var _a;
+    var _a, _b, _c, _d, _e, _f, _g;
     const userConfig = await this.db.getRepository("usersAiEmployees").findOne({
       filter: {
-        userId: (_a = this.ctx.auth) == null ? void 0 : _a.user.id,
+        userId: ((_a = this.ctx.auth) == null ? void 0 : _a.user.id) ?? 0,
         aiEmployee: this.employee.username
       }
     });
@@ -530,17 +656,19 @@ ${workContextBackground.join("\n")}`;
 ${addSystemPrompt.map((it) => it.content).join("\n")}`;
     }
     let knowledgeBase;
-    if (this.isEnabledKnowledgeBase() && this.employee.knowledgeBasePrompt && (userMessages == null ? void 0 : userMessages.length)) {
+    const { knowledgeBaseManager } = this.plugin;
+    const employee = this.employee.toJSON();
+    if (await knowledgeBaseManager.isEnabledKnowledgeBase(employee) && employee.knowledgeBasePrompt && (userMessages == null ? void 0 : userMessages.length)) {
       const lastUserMessage = userMessages.filter((x) => x.role === "user").at(-1);
       if (lastUserMessage) {
-        const docs = await this.retrieveKnowledgeBase(lastUserMessage);
-        const knowledgeBaseData = docs.map((x) => x.content).join("\n");
-        const promptTemplate = import_prompts2.ChatPromptTemplate.fromTemplate(this.employee.knowledgeBasePrompt);
-        knowledgeBase = import_lodash.default.isEmpty(knowledgeBaseData) ? void 0 : await promptTemplate.format({
-          knowledgeBaseData
+        knowledgeBase = await knowledgeBaseManager.retrievePrompt({
+          employee,
+          query: lastUserMessage.content.content
         });
       }
     }
+    const availableSkills = await this.getAvailableSkills();
+    const availableAIEmployees = await this.getAvailableAIEmployees();
     const systemPrompt = (0, import_prompts.getSystemPrompt)({
       aiEmployee: {
         nickname: this.employee.nickname,
@@ -553,11 +681,15 @@ ${addSystemPrompt.map((it) => it.content).join("\n")}`;
       dataSources: dataSourceMessage,
       environment: {
         database: this.db.sequelize.getDialect(),
-        locale: this.ctx.getCurrentLocale() || "en-US"
+        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)),
+        timezone: getCurrentTimezone(this.ctx)
       },
-      knowledgeBase
+      knowledgeBase,
+      availableSkills,
+      availableAIEmployees
     });
-    const { important } = this.ctx.action.params.values || {};
+    const { important } = ((_g = (_f = this.ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.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.
@@ -567,92 +699,6 @@ If information is missing, clearly state it in the summary.</Important>`;
       return systemPrompt;
     }
   }
-  async retrieveKnowledgeBase(userMessage) {
-    const vectorStoreProvider = this.plugin.features.vectorStoreProvider;
-    let queryResult = [];
-    const queryString = userMessage.content.content;
-    if (!queryString || import_lodash.default.isEmpty(queryString)) {
-      return queryResult;
-    }
-    const { topK, score } = this.getAIEmployeeKnowledgeBaseConfig();
-    const knowledgeBaseGroup = await this.getKnowledgeBaseGroup();
-    for (const entry of knowledgeBaseGroup) {
-      const { vectorStoreConfig, knowledgeBaseType, knowledgeBaseList } = entry;
-      if (!knowledgeBaseList || import_lodash.default.isEmpty(knowledgeBaseList)) {
-        continue;
-      }
-      if (knowledgeBaseType === "LOCAL") {
-        const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
-          vectorStoreConfig.vectorStoreProvider,
-          [
-            {
-              key: "vectorStoreConfigId",
-              value: vectorStoreConfig.vectorStoreConfigId
-            }
-          ]
-        );
-        const knowledgeBaseOuterIds = knowledgeBaseList.map((x) => x.knowledgeBaseOuterId);
-        const result = await vectorStoreService.search(queryString, {
-          topK,
-          score,
-          filter: {
-            knowledgeBaseOuterId: { in: knowledgeBaseOuterIds }
-          }
-        });
-        queryResult = [...queryResult, ...result];
-      } else if (knowledgeBaseType === "READONLY") {
-        for (const knowledgeBase of knowledgeBaseList) {
-          const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
-            vectorStoreConfig.vectorStoreProvider,
-            [
-              ...knowledgeBase.vectorStoreProps,
-              {
-                key: "vectorStoreConfigId",
-                value: vectorStoreConfig.vectorStoreConfigId
-              }
-            ]
-          );
-          const result = await vectorStoreService.search(queryString, {
-            topK,
-            score
-          });
-          queryResult = [...queryResult, ...result];
-        }
-      } else if (knowledgeBaseType === "EXTERNAL") {
-        for (const knowledgeBase of knowledgeBaseList) {
-          const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
-            vectorStoreConfig.vectorStoreProvider,
-            knowledgeBase.vectorStoreProps
-          );
-          const result = await vectorStoreService.search(queryString, {
-            topK,
-            score
-          });
-          queryResult = [...queryResult, ...result];
-        }
-      }
-    }
-    return queryResult;
-  }
-  isEnabledKnowledgeBase() {
-    const featureEnabled = this.plugin.features.isFeaturesEnabled(Object.values(import_ai_feature_manager.EEFeatures));
-    const knowledgeBaseEnabled = this.employee.enableKnowledgeBase;
-    return featureEnabled && knowledgeBaseEnabled;
-  }
-  getAIEmployeeKnowledgeBaseConfig() {
-    const { topK, score } = this.employee.knowledgeBase ?? {};
-    return {
-      topK,
-      score
-    };
-  }
-  async getKnowledgeBaseGroup() {
-    const { knowledgeBaseIds } = this.employee.knowledgeBase ?? {};
-    if (!knowledgeBaseIds || import_lodash.default.isEmpty(knowledgeBaseIds)) {
-      return [];
-    }
-    return await this.plugin.features.knowledgeBase.getKnowledgeBaseGroup(knowledgeBaseIds);
-  }
   // === Tool calls ===
   async initToolCall(transaction, messageId, toolCalls) {
     const nowTime = /* @__PURE__ */ new Date();
@@ -680,23 +726,54 @@ If information is missing, clearly state it in the summary.</Important>`;
       transaction
     });
   }
-  async updateToolCallInterrupted(messageId, toolCallId, interruptAction) {
-    const [updated] = await this.aiToolMessagesModel.update(
-      {
-        invokeStatus: "interrupted",
-        interruptActionOrder: interruptAction.order,
-        interruptAction
-      },
-      {
+  async updateToolCallInterrupted(sessionId, messageId, toolCallId, interruptId, interruptAction) {
+    return await this.db.sequelize.transaction(async (transaction) => {
+      const [updated] = await this.aiToolMessagesModel.update(
+        {
+          invokeStatus: "interrupted",
+          interruptActionOrder: interruptAction.order,
+          interruptAction
+        },
+        {
+          where: {
+            sessionId,
+            messageId,
+            toolCallId,
+            invokeStatus: "init"
+          },
+          transaction
+        }
+      );
+      if (!updated) {
+        return updated;
+      }
+      const message = await this.aiMessagesModel.findOne({
         where: {
-          sessionId: this.sessionId,
           messageId,
-          toolCallId,
-          invokeStatus: "init"
-        }
+          sessionId
+        },
+        transaction
+      });
+      if (!message) {
+        return updated;
       }
-    );
-    return updated;
+      await this.aiMessagesModel.update(
+        {
+          metadata: {
+            ...message.get("metadata") ?? {},
+            interruptId
+          }
+        },
+        {
+          where: {
+            messageId,
+            sessionId
+          },
+          transaction
+        }
+      );
+      return updated;
+    });
   }
   async updateToolCallPending(messageId, toolCallId) {
     const [updated] = await this.aiToolMessagesModel.update(
@@ -758,7 +835,6 @@ If information is missing, clearly state it in the summary.</Important>`;
     var _a;
     return (_a = await this.aiToolMessagesModel.findOne({
       where: {
-        sessionId: this.sessionId,
         messageId,
         toolCallId
       }
@@ -767,7 +843,6 @@ If information is missing, clearly state it in the summary.</Important>`;
   async getToolCallResultMap(messageId, toolCallIds) {
     const list = (await this.aiToolMessagesModel.findAll({
       where: {
-        sessionId: this.sessionId,
         messageId,
         toolCallId: {
           [import_database.Op.in]: toolCallIds
@@ -776,19 +851,6 @@ If information is missing, clearly state it in the summary.</Important>`;
     })).map((it) => it.toJSON());
     return new Map(list.map((it) => [it.toolCallId, it]));
   }
-  async getUserDecisions(messageId) {
-    const allInterruptedToolCall = await this.aiToolMessagesModel.findAll({
-      where: {
-        messageId,
-        interruptActionOrder: { [import_database.Op.not]: null }
-      },
-      order: [["interruptActionOrder", "ASC"]]
-    });
-    if (!allInterruptedToolCall.every((t) => t.invokeStatus === "waiting")) {
-      return [];
-    }
-    return allInterruptedToolCall.map((item) => item.userDecision);
-  }
   async cancelToolCall() {
     var _a;
     let messageId;
@@ -803,7 +865,6 @@ If information is missing, clearly state it in the summary.</Important>`;
     }
     const toolMessages = (await this.aiToolMessagesModel.findAll({
       where: {
-        sessionId: this.sessionId,
         messageId,
         invokeStatus: {
           [import_database.Op.ne]: "confirmed"
@@ -895,8 +956,8 @@ If information is missing, clearly state it in the summary.</Important>`;
     if (tools.scope !== "CUSTOM") {
       return isAutoCall;
     }
-    const skills = ((_a = this.employee.skillSettings) == null ? void 0 : _a.skills) ?? [];
-    const presetTools = skills.find((s) => s.name === tools.definition.name);
+    const employeeTools = ((_a = this.employee.skillSettings) == null ? void 0 : _a.tools) ?? [];
+    const presetTools = employeeTools.find((s) => s.name === tools.definition.name);
     return presetTools ? presetTools.autoCall : isAutoCall;
   }
   async formatMessages({ messages, provider }) {
@@ -1036,7 +1097,7 @@ If information is missing, clearly state it in the summary.</Important>`;
   toInterruptActions(interrupt) {
     var _a;
     const result = /* @__PURE__ */ new Map();
-    const { actionRequests = [], reviewConfigs = [] } = interrupt;
+    const { actionRequests = [], reviewConfigs = [] } = interrupt ?? {};
     if (!actionRequests.length) {
       return result;
     }
@@ -1044,10 +1105,20 @@ If information is missing, clearly state it in the summary.</Important>`;
     const actionRequestsMap = new Map(actionRequests.map((x) => [x.name, x]));
     const reviewConfigsMap = new Map(reviewConfigs.map((x) => [x.actionName, x]));
     for (const [name, actionRequest] of actionRequestsMap.entries()) {
+      const payload = actionRequest.description ? JSON.parse(actionRequest.description) : null;
       result.set(name, {
         order: order++,
         description: actionRequest.description,
-        allowedDecisions: (_a = reviewConfigsMap.get(name)) == null ? void 0 : _a.allowedDecisions
+        allowedDecisions: (_a = reviewConfigsMap.get(name)) == null ? void 0 : _a.allowedDecisions,
+        toolCall: {
+          id: payload.toolCallId,
+          name: payload.toolCallName
+        },
+        currentConversation: {
+          sessionId: payload.sessionId,
+          from: payload.from,
+          username: payload.username
+        }
       });
     }
     return result;
@@ -1061,25 +1132,120 @@ If information is missing, clearly state it in the summary.</Important>`;
     }
     const generalToolsNameSet = new Set(tools.map((x) => x.definition.name));
     const toolMap = await this.getToolsMap();
-    const skills = ((_a = this.employee.skillSettings) == null ? void 0 : _a.skills) ?? [];
-    for (const skill of skills) {
-      if (generalToolsNameSet.has(skill.name)) {
+    const employeeTools = ((_a = this.employee.skillSettings) == null ? void 0 : _a.tools) ?? [];
+    employeeTools.push(...this.tools);
+    if (await this.plugin.knowledgeBaseManager.isEnabledKnowledgeBase(this.employee.toJSON())) {
+      const knowledgeBaseRetrieveTool = await this.toolsManager.getTools("knowledge-base-retrieve");
+      if (knowledgeBaseRetrieveTool) {
+        employeeTools.push({ name: "knowledge-base-retrieve" });
+      }
+    }
+    for (const toolSetting of employeeTools) {
+      if (generalToolsNameSet.has(toolSetting.name)) {
         continue;
       }
-      const tool = toolMap.get(skill.name);
+      const tool = toolMap.get(toolSetting.name);
       if (!tool) {
         continue;
       }
       tools.push(tool);
     }
+    const toolFilter = ((_b = this.skillSettings) == null ? void 0 : _b.tools) ?? [];
+    return tools.filter((t) => toolFilter.length === 0 || toolFilter.includes(t.definition.name));
+  }
+  async getAvailableSkills() {
+    var _a, _b;
+    const { skillsManager } = this.plugin.ai;
+    const aIEmployeeTools = await this.getAIEmployeeTools();
+    const getSkill = aIEmployeeTools.find((it) => it.definition.name === "getSkill");
+    if (!getSkill) {
+      return [];
+    }
+    const generalSkills = await skillsManager.listSkills({ scope: "GENERAL" });
+    const specifiedSkillNames = ((_a = this.employee.skillSettings) == null ? void 0 : _a.skills) ?? [];
+    const specifiedSkills = specifiedSkillNames.length ? await skillsManager.getSkills(specifiedSkillNames) : [];
     const skillFilter = ((_b = this.skillSettings) == null ? void 0 : _b.skills) ?? [];
-    return tools.filter((t) => skillFilter.length === 0 || skillFilter.includes(t.definition.name));
+    return import_lodash.default.uniqBy([...specifiedSkills || [], ...generalSkills || []], "name").filter(
+      (it) => skillFilter.length === 0 || skillFilter.includes(it.name)
+    );
+  }
+  async getAgentTools() {
+    const baseTools = await this.getAIEmployeeTools();
+    const toolMap = await this.getToolsMap();
+    const availableSkills = await this.getAvailableSkills();
+    const skillOwnedToolNames = new Set(availableSkills.flatMap((it) => it.tools ?? []));
+    const baseToolNames = new Set(
+      baseTools.map((it) => it.definition.name).filter((name) => name === "getSkill" || !skillOwnedToolNames.has(name))
+    );
+    return {
+      tools: Array.from(toolMap.values()),
+      baseToolNames
+    };
+  }
+  async getLoadedSkillNames() {
+    const list = await this.aiToolMessagesModel.findAll({
+      where: {
+        sessionId: this.sessionId,
+        toolName: "getSkill",
+        status: "success"
+      },
+      order: [["id", "ASC"]]
+    });
+    const result = /* @__PURE__ */ new Set();
+    for (const item of list) {
+      const { content } = item.toJSON();
+      if (import_lodash.default.isPlainObject(content) && typeof content["skillName"] === "string") {
+        result.add(content["skillName"]);
+        continue;
+      }
+      if (typeof content === "string") {
+        try {
+          const parsed = JSON.parse(content);
+          if (import_lodash.default.isPlainObject(parsed) && typeof parsed["skillName"] === "string") {
+            result.add(parsed["skillName"]);
+          }
+        } catch (e) {
+        }
+      }
+    }
+    return Array.from(result.values());
+  }
+  async getActivatedSkillToolNames() {
+    const loadedSkillNames = await this.getLoadedSkillNames();
+    if (!loadedSkillNames.length) {
+      return /* @__PURE__ */ new Set();
+    }
+    const availableSkills = await this.getAvailableSkills();
+    const loadedSkills = await this.plugin.ai.skillsManager.getSkills(loadedSkillNames);
+    const normalizedLoadedSkills = Array.isArray(loadedSkills) ? loadedSkills : [loadedSkills];
+    const skillsMap = new Map(
+      [...availableSkills, ...normalizedLoadedSkills.filter(Boolean)].map((it) => [it.name, it])
+    );
+    const result = /* @__PURE__ */ new Set();
+    for (const skillName of loadedSkillNames) {
+      const target = skillsMap.get(skillName);
+      for (const toolName of (target == null ? void 0 : target.tools) ?? []) {
+        result.add(toolName);
+      }
+    }
+    return result;
+  }
+  async getAvailableAIEmployees() {
+    const availableAIEmployees = (await (0, import_shared.listAccessibleAIEmployees)(this.ctx)).map(
+      (employee) => (0, import_shared.serializeEmployeeSummary)(this.ctx, employee)
+    );
+    return availableAIEmployees;
   }
-  getMiddleware(options) {
-    const { providerName, model, tools, messageId, agentThread } = options;
+  async getMiddleware(options) {
+    const { providerName, model, tools, baseToolNames, messageId, agentThread } = options;
+    const inWorkflow = await this.isInWorkflow();
     return [
+      (0, import_middleware.skillToolBindingMiddleware)(this, {
+        baseToolNames: Array.from(baseToolNames.values())
+      }),
       (0, import_middleware.toolInteractionMiddleware)(this, tools),
       (0, import_middleware.toolCallStatusMiddleware)(this),
+      ...inWorkflow ? [(0, import_middleware.workflowHistoryMiddleware)(this, this.db)] : [],
       (0, import_middleware.conversationMiddleware)(this, { providerName, model, messageId, agentThread })
     ];
   }
@@ -1105,12 +1271,27 @@ If information is missing, clearly state it in the summary.</Important>`;
     throw new Error("Fail to create new agent thread");
   }
   async getToolsMap() {
-    const tools = await this.listTools();
+    const tools = await this.listTools({
+      sessionId: this.sessionId
+    });
     return new Map(tools.map((tool) => [tool.definition.name, tool]));
   }
   listTools(filter) {
     return this.toolsManager.listTools(filter);
   }
+  withRunMetadata(config) {
+    return {
+      ...config,
+      metadata: {
+        ...(config == null ? void 0 : config.metadata) ?? {},
+        currentConversation: {
+          sessionId: this.sessionId,
+          from: this.from,
+          username: this.employee.get("username")
+        }
+      }
+    };
+  }
   get toolsManager() {
     return this.ctx.app.aiManager.toolsManager;
   }
@@ -1133,6 +1314,33 @@ If information is missing, clearly state it in the summary.</Important>`;
     return this.ctx.db.getModel("aiFiles");
   }
 }
+function getCurrentTimezone(ctx) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const value = ((_a = ctx.get) == null ? void 0 : _a.call(ctx, "x-timezone")) || ((_c = (_b = ctx.request) == null ? void 0 : _b.get) == null ? void 0 : _c.call(_b, "x-timezone")) || ((_e = (_d = ctx.request) == null ? void 0 : _d.header) == null ? void 0 : _e["x-timezone"]) || ((_g = (_f = ctx.req) == null ? void 0 : _f.headers) == null ? void 0 : _g["x-timezone"]) || Intl.DateTimeFormat().resolvedOptions().timeZone;
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return typeof value === "string" ? value : void 0;
+}
+function getCurrentDateTimeForPrompt(locale, timezone) {
+  const now = /* @__PURE__ */ new Date();
+  const normalizedLocale = locale || "en-US";
+  try {
+    const formatter = new Intl.DateTimeFormat(normalizedLocale, {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    });
+    return `${formatter.format(now)}${timezone ? ` (${timezone})` : ""}`;
+  } catch (error) {
+    return `${now.toISOString()}${timezone ? ` (${timezone})` : ""}`;
+  }
+}
 class AgentThread {
   constructor(_sessionId, _thread) {
     this._sessionId = _sessionId;
@@ -1155,8 +1363,8 @@ class AgentThread {
   }
 }
 class ChatStreamProtocol {
-  constructor(ctx) {
-    this.ctx = ctx;
+  constructor(streamConsumer) {
+    this.streamConsumer = streamConsumer;
   }
   _statistics = {
     sent: 0,
@@ -1167,71 +1375,85 @@ class ChatStreamProtocol {
       this._statistics.sent = 0;
     }
   };
-  static create(ctx) {
-    return new ChatStreamProtocol(ctx);
-  }
-  startStream() {
-    this._statistics.reset();
-    this.write({ type: "stream_start" });
-  }
-  endStream() {
-    this.write({ type: "stream_end" });
-  }
-  newMessage(content) {
-    this.write({ type: "new_message", body: content });
-  }
-  content(content) {
-    this.write({ type: "content", body: content });
-  }
-  webSearch(content) {
-    this.write({ type: "web_search", body: content });
-  }
-  reasoning(content) {
-    this.write({ type: "reasoning", body: content });
-  }
-  stopReasoning() {
-    this.write({
-      type: "reasoning",
-      body: {
-        status: "stop",
-        content: ""
-      }
-    });
-  }
-  toolCallChunks(content) {
-    this.write({ type: "tool_call_chunks", body: content });
-  }
-  toolCalls(content) {
-    this.write({ type: "tool_calls", body: content });
+  static fromContext(ctx) {
+    return new ChatStreamProtocol(ctx.res);
   }
-  toolCallStatus({
-    toolCall,
-    invokeStatus,
-    status,
-    interruptAction
-  }) {
-    this.write({
-      type: "tool_call_status",
-      body: {
+  with(conversation) {
+    const write = ({ type, body }) => {
+      const { sessionId, from, username } = conversation;
+      const data = `data: ${JSON.stringify({ sessionId, from, username, type, body })}
+
+`;
+      this.streamConsumer.write(data);
+      this._statistics.addSent(data.length);
+    };
+    return {
+      startStream: () => {
+        this._statistics.reset();
+        write({ type: "stream_start" });
+      },
+      endStream: () => {
+        write({ type: "stream_end" });
+      },
+      subAgentCompleted: () => {
+        write({ type: "sub_agent_completed" });
+      },
+      newMessage: (content) => {
+        write({ type: "new_message", body: content });
+      },
+      content: (content) => {
+        write({ type: "content", body: content });
+      },
+      webSearch: (content) => {
+        write({ type: "web_search", body: content });
+      },
+      reasoning: (content) => {
+        write({ type: "reasoning", body: content });
+      },
+      stopReasoning: () => {
+        write({
+          type: "reasoning",
+          body: {
+            status: "stop",
+            content: ""
+          }
+        });
+      },
+      toolCallChunks: (content) => {
+        write({ type: "tool_call_chunks", body: content });
+      },
+      toolCalls: (content) => {
+        write({ type: "tool_calls", body: content });
+      },
+      toolCallStatus: ({
         toolCall,
         invokeStatus,
         status,
+        invokeStartTime,
+        invokeEndTime,
+        content,
         interruptAction
+      }) => {
+        write({
+          type: "tool_call_status",
+          body: {
+            toolCall,
+            invokeStatus,
+            status,
+            invokeStartTime,
+            invokeEndTime,
+            content,
+            interruptAction
+          }
+        });
       }
-    });
+    };
   }
   get statistics() {
     return {
       sent: this._statistics.sent
     };
   }
-  write({ type, body }) {
-    const data = `data: ${JSON.stringify({ type, body })}
-
-`;
-    this.ctx.res.write(data);
-    this._statistics.addSent(data.length);
-  }
 }
 class ResponseMetadataCollector extends import_base.BaseCallbackHandler {
   constructor(llmProvider, responseMetadata) {
@@ -1252,5 +1474,6 @@ class ResponseMetadataCollector extends import_base.BaseCallbackHandler {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AIEmployee
+  AIEmployee,
+  ChatStreamProtocol
 });