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

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

@@ -45,6 +45,7 @@ var import_utils = require("../utils");
 var import_prompts = require("./prompts");
 var import_lodash = __toESM(require("lodash"));
 var import_ai_chat_conversation = require("../manager/ai-chat-conversation");
+var import_ai_knowledge_base = require("./ai-knowledge-base");
 var import_middleware = require("./middleware");
 var import_ai = require("@nocobase/ai");
 var import_checkpoints = require("./checkpoints");
@@ -56,12 +57,17 @@ var import_base = require("@langchain/core/callbacks/base");
 var import_shared = require("../../ai/tools/sub-agents/shared");
 var import_tool_call_sanitizer = require("./tool-call-sanitizer");
 var import_attachments = require("../attachments");
+var import_frontend_tools = require("../../common/frontend-tools");
+var import_frontend_tools2 = require("../frontend-tools");
+var import_reasoning_stream_state = require("./reasoning-stream-state");
+const ABORTED_TOOL_CALL_CONTENT = "The tool call was interrupted because the conversation was aborted.";
 class AIEmployee {
   sessionId;
   from = "main-agent";
   employee;
   aiChatConversation;
   skillSettings;
+  userMessageCount = 0;
   plugin;
   db;
   ctx;
@@ -73,6 +79,7 @@ class AIEmployee {
   tools;
   inWorkflow;
   streamCached;
+  static conversationPersistenceQueues = /* @__PURE__ */ new WeakMap();
   constructor({
     ctx,
     employee,
@@ -122,6 +129,9 @@ class AIEmployee {
   areToolsEnabled() {
     return this.chatSettings.enableTools !== false;
   }
+  getAIEmployeeRecord() {
+    return this.employee.toJSON();
+  }
   async getFormatMessages(userMessages) {
     const { provider } = await this.plugin.aiManager.getLLMService({
       ...this.model
@@ -204,6 +214,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,
@@ -410,39 +421,52 @@ 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, _u, _v, _w, _x, _y, _z;
     const aiMessageIdMap = /* @__PURE__ */ new Map();
+    const persistedAIMessageIdMap = /* @__PURE__ */ new Map();
     const { signal, providerName, llmService, model, provider, responseMetadata, allowEmpty = false } = options;
-    let isReasoning = false;
+    const reasoningState = new import_reasoning_stream_state.ReasoningStreamState();
+    const stopReasoning = async (conversation) => {
+      if (reasoningState.stop(conversation)) {
+        await this.protocol.with(conversation).stopReasoning();
+      }
+    };
+    const stopAllReasoning = async () => {
+      for (const conversation of reasoningState.drain()) {
+        await this.protocol.with(conversation).stopReasoning();
+      }
+    };
     let gathered;
-    signal.addEventListener("abort", async () => {
-      try {
-        if ((gathered == null ? void 0 : gathered.type) === "ai") {
-          const values = (0, import_utils2.convertAIMessage)({
-            aiEmployee: this,
-            providerName,
-            provider,
-            llmService,
-            model,
-            aiMessage: gathered
-          });
-          if (values) {
-            values.metadata.interrupted = true;
-          }
-          await this.aiChatConversation.withTransaction(async (conversation, transaction) => {
-            const result = await conversation.addMessages(values);
-          });
-        }
-      } catch (e) {
-        this.logger.error("Fail to save message after conversation abort", gathered);
-      } finally {
-        await this.aiConversationsRepo.update({
-          values: { llmActiveState: "idle", read: true },
-          filter: {
-            sessionId: this.sessionId
+    let abortFinalization;
+    signal.addEventListener(
+      "abort",
+      () => {
+        abortFinalization = (async () => {
+          try {
+            await stopAllReasoning();
+            if ((gathered == null ? void 0 : gathered.type) === "ai") {
+              await this.finalizeAbortedAIMessage({
+                aiMessage: gathered,
+                providerName,
+                provider,
+                llmService,
+                model,
+                knownMessageId: persistedAIMessageIdMap.get(gathered.id)
+              });
+            }
+          } catch (e) {
+            this.logger.error("Fail to save message after conversation abort", gathered);
+          } finally {
+            await this.aiConversationsRepo.update({
+              values: { llmActiveState: "idle", read: true },
+              filter: {
+                sessionId: this.sessionId
+              }
+            });
+            await this.streamCached.clear();
           }
-        });
-        await this.streamCached.clear();
-      }
-    });
+        })();
+      },
+      { once: true }
+    );
     try {
       const aiEmployeeConversation = {
         sessionId: this.sessionId,
@@ -456,27 +480,27 @@ class AIEmployee {
           const { currentConversation } = metadata;
           if (chunk.type === "ai") {
             gathered = gathered !== void 0 ? (0, import_stream.concat)(gathered, chunk) : chunk;
-            if (chunk.content) {
-              if (isReasoning) {
-                isReasoning = false;
-                await this.protocol.with(currentConversation).stopReasoning();
-              }
-              const parsedContent = provider.parseResponseChunk(chunk.content);
-              if (parsedContent) {
-                await this.protocol.with(currentConversation).content(parsedContent);
-              }
+            const reasoningContent = provider.parseReasoningContent(chunk);
+            if (reasoningContent) {
+              reasoningState.start(currentConversation);
+              await this.protocol.with(currentConversation).reasoning(reasoningContent);
+            }
+            const parsedContent = chunk.content ? provider.parseResponseChunk(chunk.content) : null;
+            if (parsedContent) {
+              await stopReasoning(currentConversation);
+              await this.protocol.with(currentConversation).content(parsedContent);
             }
             if ((_a = chunk.tool_call_chunks) == null ? void 0 : _a.length) {
+              await stopReasoning(currentConversation);
               await this.protocol.with(currentConversation).toolCallChunks(chunk.tool_call_chunks);
             }
             const webSearch = provider.parseWebSearchAction(chunk);
             if (webSearch == null ? void 0 : webSearch.length) {
+              await stopReasoning(currentConversation);
               await this.protocol.with(currentConversation).webSearch(webSearch);
             }
-            const reasoningContent = provider.parseReasoningContent(chunk);
-            if (reasoningContent) {
-              isReasoning = true;
-              await this.protocol.with(currentConversation).reasoning(reasoningContent);
+            if ((0, import_reasoning_stream_state.isReasoningFinishChunk)(chunk)) {
+              await stopReasoning(currentConversation);
             }
           }
         } else if (mode === "updates") {
@@ -505,6 +529,7 @@ class AIEmployee {
           if (chunks.action === "AfterAIMessageSaved") {
             await this.streamCached.skipped();
             aiMessageIdMap.set(currentConversation.sessionId, chunks.body.messageId);
+            persistedAIMessageIdMap.set(chunks.body.id, chunks.body.messageId);
             const data = responseMetadata.get(chunks.body.id);
             if (data) {
               const savedMessage = await this.aiMessagesModel.findOne({
@@ -532,6 +557,7 @@ class AIEmployee {
               }
             }
           } else if (chunks.action === "initToolCalls") {
+            await stopReasoning(currentConversation);
             await this.protocol.with(currentConversation).toolCalls(chunks.body);
           } else if (chunks.action === "beforeToolCall") {
             const toolsMap = await this.getToolsMap();
@@ -593,12 +619,14 @@ class AIEmployee {
           }
         }
       }
+      await stopAllReasoning();
       if (this.protocol.statistics.sent === 0 && !signal.aborted && !allowEmpty) {
         this.sendErrorResponse("Empty message");
         return;
       }
       await this.protocol.with(aiEmployeeConversation).endStream();
     } catch (err) {
+      await stopAllReasoning();
       this.ctx.log.error(err);
       if (err.name === "GraphRecursionError") {
         this.sendSpecificError({ name: err.name, message: err.message });
@@ -606,6 +634,7 @@ class AIEmployee {
         this.sendErrorResponse(provider.parseResponseError(err));
       }
     } finally {
+      await abortFinalization;
       if (this.from === "main-agent") {
         this.ctx.res.end();
       }
@@ -687,7 +716,7 @@ Field: ${field.name}, Title: ${(_a = field.options.uiSchema) == null ? void 0 :
     return message;
   }
   async getSystemPrompt(userMessages) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     if (this.systemPromptMode === "none") {
       return "";
     }
@@ -695,9 +724,16 @@ Field: ${field.name}, Title: ${(_a = field.options.uiSchema) == null ? void 0 :
     if (this.systemPromptMode === "raw") {
       return about;
     }
+    const employee = this.getAIEmployeeRecord();
+    const knowledgeBaseManager = this.plugin.knowledgeBaseManager;
+    const knowledgeBaseEnabled = await knowledgeBaseManager.isEnabledKnowledgeBase(employee);
+    const roleNames = (0, import_ai_knowledge_base.getCurrentRoleNames)(this.ctx.state);
+    const hasAccessibleKnowledgeBase = knowledgeBaseEnabled ? await knowledgeBaseManager.hasAccessibleKnowledgeBase({ employee, roleNames }) : false;
+    const knowledgeBaseAccessDenied = knowledgeBaseEnabled && !hasAccessibleKnowledgeBase;
+    const knowledgeBaseOnDemand = knowledgeBaseEnabled && hasAccessibleKnowledgeBase && (0, import_ai_knowledge_base.normalizeKnowledgeBaseRetrievalStrategy)((_a = employee.knowledgeBase) == null ? void 0 : _a.retrievalStrategy) === "onDemand";
     const userConfig = await this.db.getRepository("usersAiEmployees").findOne({
       filter: {
-        userId: ((_a = this.ctx.auth) == null ? void 0 : _a.user.id) ?? 0,
+        userId: ((_b = this.ctx.auth) == null ? void 0 : _b.user.id) ?? 0,
         aiEmployee: this.employee.username
       }
     });
@@ -722,17 +758,25 @@ ${workContextBackground.join("\n")}`;
 ${addSystemPrompt.map((it) => it.content).join("\n")}`;
     }
     let knowledgeBase;
-    const { knowledgeBaseManager } = this.plugin;
-    const employee = this.employee.toJSON();
-    if (await knowledgeBaseManager.isEnabledKnowledgeBase(employee) && employee.knowledgeBasePrompt && (userMessages == null ? void 0 : userMessages.length)) {
+    if (knowledgeBaseEnabled && hasAccessibleKnowledgeBase && !knowledgeBaseOnDemand && (userMessages == null ? void 0 : userMessages.length)) {
       const lastUserMessage = userMessages.filter((x) => x.role === "user").at(-1);
       if (lastUserMessage) {
         knowledgeBase = await knowledgeBaseManager.retrievePrompt({
           employee,
-          query: lastUserMessage.content.content
+          query: lastUserMessage.content.content,
+          roleNames
         });
       }
     }
+    const knowledgeBaseBackgroundPrompt = (0, import_ai_knowledge_base.getKnowledgeBaseBackgroundPrompt)({
+      accessDenied: knowledgeBaseAccessDenied,
+      onDemand: knowledgeBaseOnDemand,
+      preRetrieved: Boolean(knowledgeBase)
+    });
+    if (knowledgeBaseBackgroundPrompt) {
+      background = `${background}
+${knowledgeBaseBackgroundPrompt}`;
+    }
     const availableSkills = await this.getAvailableSkills();
     const availableAIEmployees = await this.getAvailableAIEmployees();
     const systemPrompt = (0, import_prompts.getSystemPrompt)({
@@ -746,8 +790,12 @@ ${addSystemPrompt.map((it) => it.content).join("\n")}`;
       personal: userConfig == null ? void 0 : userConfig.prompt,
       environment: {
         database: this.db.sequelize.getDialect(),
-        locale: ((_c = (_b = this.ctx).getCurrentLocale) == null ? void 0 : _c.call(_b)) || "en-US",
-        currentDateTime: getCurrentDateTimeForPrompt((_e = (_d = this.ctx).getCurrentLocale) == null ? void 0 : _e.call(_d), getCurrentTimezone(this.ctx)),
+        locale: ((_d = (_c = this.ctx).getCurrentLocale) == null ? void 0 : _d.call(_c)) || "en-US",
+        currentDateTime: getCurrentDateTimeForPrompt(
+          await this.aiChatConversation.getCreatedAt(),
+          (_f = (_e = this.ctx).getCurrentLocale) == null ? void 0 : _f.call(_e),
+          getCurrentTimezone(this.ctx)
+        ),
         timezone: getCurrentTimezone(this.ctx)
       },
       knowledgeBase,
@@ -755,7 +803,7 @@ ${addSystemPrompt.map((it) => it.content).join("\n")}`;
       availableAIEmployees,
       webSearch: this.webSearch
     });
-    const { important } = ((_g = (_f = this.ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.values) || {};
+    const { important } = ((_h = (_g = this.ctx.action) == null ? void 0 : _g.params) == null ? void 0 : _h.values) || {};
     if (important === "GraphRecursionError") {
       const importantPrompt = `<Important>You have already called tools multiple times and gathered sufficient information.
 First, provide a summary based on the existing information. Do not call additional tools.
@@ -766,14 +814,179 @@ If information is missing, clearly state it in the summary.</Important>`;
     }
   }
   // === Tool calls ===
+  async withLockedConversation(callback) {
+    const persistenceQueues = AIEmployee.conversationPersistenceQueues.get(this.db) ?? /* @__PURE__ */ new Map();
+    AIEmployee.conversationPersistenceQueues.set(this.db, persistenceQueues);
+    const previous = persistenceQueues.get(this.sessionId) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    persistenceQueues.set(this.sessionId, current);
+    await previous;
+    try {
+      for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+          return await this.aiChatConversation.withTransaction(async (conversation, transaction) => {
+            const lockedConversation = await this.aiConversationsModel.findOne({
+              where: { sessionId: this.sessionId },
+              transaction,
+              lock: transaction.LOCK.UPDATE
+            });
+            if (!lockedConversation) {
+              throw new Error(`AI conversation ${this.sessionId} not found`);
+            }
+            return await callback(conversation, transaction);
+          });
+        } catch (error) {
+          if (!(error instanceof import_database.UniqueConstraintError) || attempt === 1) {
+            throw error;
+          }
+        }
+      }
+      throw new Error(`Failed to persist AI conversation ${this.sessionId}`);
+    } finally {
+      release();
+      if (persistenceQueues.get(this.sessionId) === current) {
+        persistenceQueues.delete(this.sessionId);
+      }
+    }
+  }
+  async findPersistedAIMessage(transaction, langChainMessageId, knownMessageId) {
+    var _a;
+    if (knownMessageId) {
+      const knownMessage = await this.aiMessagesModel.findOne({
+        where: { sessionId: this.sessionId, messageId: knownMessageId },
+        transaction
+      });
+      if (((_a = knownMessage == null ? void 0 : knownMessage.get("metadata")) == null ? void 0 : _a.id) === langChainMessageId) {
+        return knownMessage;
+      }
+    }
+    const messages = await this.aiMessagesModel.findAll({
+      where: { sessionId: this.sessionId, role: this.employee.username },
+      order: [["messageId", "DESC"]],
+      transaction
+    });
+    return messages.find((message) => {
+      var _a2;
+      return ((_a2 = message.get("metadata")) == null ? void 0 : _a2.id) === langChainMessageId;
+    });
+  }
+  async persistAIMessageInTransaction(conversation, transaction, options) {
+    const existingMessage = await this.findPersistedAIMessage(
+      transaction,
+      options.langChainMessageId,
+      options.knownMessageId
+    );
+    if (existingMessage) {
+      const message2 = existingMessage.toJSON();
+      const initializedToolCalls2 = await this.aiToolMessagesModel.findAll({
+        where: { sessionId: this.sessionId, messageId: message2.messageId },
+        transaction
+      });
+      return { message: message2, initializedToolCalls: initializedToolCalls2, created: false };
+    }
+    const message = await conversation.addMessages(options.values);
+    const initializedToolCalls = options.toolCalls.length ? await this.initToolCall(transaction, message.messageId, options.toolCalls) : [];
+    return { message, initializedToolCalls, created: true };
+  }
+  async persistAIMessage(options) {
+    return await this.withLockedConversation(async (conversation, transaction) => {
+      return await this.persistAIMessageInTransaction(conversation, transaction, options);
+    });
+  }
+  async finalizeAbortedAIMessage({
+    aiMessage,
+    providerName,
+    provider,
+    llmService,
+    model,
+    knownMessageId
+  }) {
+    const values = (0, import_utils2.convertAIMessage)({
+      aiEmployee: this,
+      providerName,
+      provider,
+      llmService,
+      model,
+      aiMessage
+    });
+    if (!values) {
+      return;
+    }
+    values.metadata = { ...values.metadata, interrupted: true };
+    const toolCalls = aiMessage.tool_calls ?? [];
+    return await this.withLockedConversation(async (conversation, transaction) => {
+      var _a;
+      const result = await this.persistAIMessageInTransaction(conversation, transaction, {
+        values,
+        langChainMessageId: aiMessage.id,
+        toolCalls,
+        knownMessageId
+      });
+      const unfinishedToolCalls = result.initializedToolCalls.map((toolCall) => toolCall.toJSON()).filter((toolCall) => toolCall.invokeStatus !== "confirmed");
+      if (!result.created && (!result.initializedToolCalls.length || unfinishedToolCalls.length) && !((_a = result.message.metadata) == null ? void 0 : _a.interrupted)) {
+        const metadata = { ...result.message.metadata, interrupted: true };
+        await this.aiMessagesModel.update(
+          { metadata },
+          { where: { sessionId: this.sessionId, messageId: result.message.messageId }, transaction }
+        );
+        result.message.metadata = metadata;
+      }
+      if (!unfinishedToolCalls.length) {
+        return result;
+      }
+      const persistedToolCalls = result.message.toolCalls ?? toolCalls;
+      const toolCallMap = new Map(persistedToolCalls.map((toolCall) => [toolCall.id, toolCall]));
+      const now = /* @__PURE__ */ new Date();
+      await conversation.addMessages(
+        unfinishedToolCalls.map((toolCall) => ({
+          role: "tool",
+          content: { type: "text", content: ABORTED_TOOL_CALL_CONTENT },
+          metadata: {
+            id: `aborted-tool:${aiMessage.id}:${toolCall.toolCallId}`,
+            model,
+            provider: providerName,
+            llmService,
+            messageId: result.message.messageId,
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            toolCall: toolCallMap.get(toolCall.toolCallId),
+            autoCall: toolCall.auto
+          }
+        }))
+      );
+      for (const toolCall of unfinishedToolCalls) {
+        await this.aiToolMessagesModel.update(
+          {
+            invokeStatus: "confirmed",
+            status: "error",
+            content: ABORTED_TOOL_CALL_CONTENT,
+            invokeStartTime: toolCall.invokeStartTime ?? now,
+            invokeEndTime: now
+          },
+          {
+            where: {
+              id: toolCall.id,
+              invokeStatus: { [import_database.Op.ne]: "confirmed" }
+            },
+            transaction
+          }
+        );
+      }
+      return result;
+    });
+  }
   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,
@@ -917,6 +1130,39 @@ 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 getToolCallResults(toolCallIds) {
+    if (!toolCallIds.length) {
+      return /* @__PURE__ */ new Map();
+    }
+    const list = (await this.aiToolMessagesModel.findAll({
+      where: {
+        sessionId: this.sessionId,
+        toolCallId: {
+          [import_database.Op.in]: toolCallIds
+        }
+      }
+    })).map((item) => item.toJSON());
+    const invokeStatusPriority = { confirmed: 2, done: 1 };
+    const results = /* @__PURE__ */ new Map();
+    for (const item of list) {
+      if (item.invokeStatus !== "confirmed" && item.invokeStatus !== "done") {
+        continue;
+      }
+      const existing = results.get(item.toolCallId);
+      if (!existing) {
+        results.set(item.toolCallId, item);
+        continue;
+      }
+      const priority = invokeStatusPriority[item.invokeStatus];
+      const existingPriority = invokeStatusPriority[existing.invokeStatus];
+      const updatedAt = item.updatedAt ? new Date(item.updatedAt).getTime() : 0;
+      const existingUpdatedAt = existing.updatedAt ? new Date(existing.updatedAt).getTime() : 0;
+      if (priority > existingPriority || priority === existingPriority && updatedAt > existingUpdatedAt) {
+        results.set(item.toolCallId, item);
+      }
+    }
+    return results;
+  }
   async cancelToolCall() {
     var _a;
     let messageId;
@@ -1054,7 +1300,7 @@ If information is missing, clearly state it in the summary.</Important>`;
     });
   }
   async formatMessages({ messages, provider }) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const formattedMessages = [];
     const workContextHandler = this.plugin.workContextHandler;
     const normalizedMessages = await this.normalizeMessageAttachments(messages);
@@ -1121,26 +1367,29 @@ If information is missing, clearly state it in the summary.</Important>`;
       }
       if (msg.role === "tool") {
         formattedMessages.push({
+          id: (_a = msg.metadata) == null ? void 0 : _a.id,
           role: "tool",
           content,
-          tool_call_id: (_a = msg.metadata) == null ? void 0 : _a.toolCallId
+          name: (_b = msg.metadata) == null ? void 0 : _b.toolName,
+          tool_call_id: (_c = msg.metadata) == null ? void 0 : _c.toolCallId
         });
         continue;
       }
+      const additionalKwargs = (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)((_d = msg.metadata) == null ? void 0 : _d.additional_kwargs, msg.toolCalls, {
+        onDiscard: (info) => {
+          var _a2;
+          this.logger.warn("Discard malformed raw tool calls from AI message", {
+            phase: "formatMessages",
+            messageId: (_a2 = msg.metadata) == null ? void 0 : _a2.id,
+            ...info
+          });
+        }
+      }).additionalKwargs;
       formattedMessages.push({
         role: "assistant",
         content,
         tool_calls: msg.toolCalls,
-        additional_kwargs: (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)((_b = msg.metadata) == null ? void 0 : _b.additional_kwargs, msg.toolCalls, {
-          onDiscard: (info) => {
-            var _a2;
-            this.logger.warn("Discard malformed raw tool calls from AI message", {
-              phase: "formatMessages",
-              messageId: (_a2 = msg.metadata) == null ? void 0 : _a2.id,
-              ...info
-            });
-          }
-        }).additionalKwargs
+        additional_kwargs: provider.prepareStoredAssistantAdditionalKwargs(additionalKwargs)
       });
     }
     return formattedMessages;
@@ -1185,12 +1434,32 @@ If information is missing, clearly state it in the summary.</Important>`;
     }
     return result;
   }
+  async getKnowledgeBaseRetrieveTool() {
+    const employee = this.getAIEmployeeRecord();
+    const knowledgeBaseManager = this.plugin.knowledgeBaseManager;
+    if (!await knowledgeBaseManager.isEnabledKnowledgeBase(employee)) {
+      return void 0;
+    }
+    const hasAccessibleKnowledgeBase = await knowledgeBaseManager.hasAccessibleKnowledgeBase({
+      employee,
+      roleNames: (0, import_ai_knowledge_base.getCurrentRoleNames)(this.ctx.state)
+    });
+    if (!hasAccessibleKnowledgeBase) {
+      return void 0;
+    }
+    return await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE, { ctx: this.ctx });
+  }
   async getAIEmployeeTools() {
     var _a;
     if (!this.areToolsEnabled()) {
       return [];
     }
+    const currentFrontendTools = await (0, import_frontend_tools2.listCurrentFrontendTools)(this.ctx, this.sessionId);
     const tools = await this.listTools({ scope: "GENERAL" });
+    const getSkill = await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.GET_SKILL, { ctx: this.ctx });
+    if (getSkill) {
+      tools.push(getSkill);
+    }
     if (this.webSearch === true) {
       const subAgentWebSearch = await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.WEB_SEARCH, { ctx: this.ctx });
       tools.push(subAgentWebSearch);
@@ -1199,13 +1468,9 @@ If information is missing, clearly state it in the summary.</Important>`;
     const toolMap = await this.getToolsMap();
     const settingsTools = ((_a = this.employee.skillSettings) == null ? void 0 : _a.tools) ?? [];
     const employeeTools = [...settingsTools, ...this.tools];
-    if (await this.plugin.knowledgeBaseManager.isEnabledKnowledgeBase(this.employee.toJSON())) {
-      const knowledgeBaseRetrieveTool = await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE, {
-        ctx: this.ctx
-      });
-      if (knowledgeBaseRetrieveTool) {
-        employeeTools.push({ name: import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE });
-      }
+    const knowledgeBaseRetrieveTool = await this.getKnowledgeBaseRetrieveTool();
+    if (knowledgeBaseRetrieveTool) {
+      employeeTools.push({ name: import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE });
     }
     for (const toolSetting of employeeTools) {
       if (generalToolsNameSet.has(toolSetting.name)) {
@@ -1217,20 +1482,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);
       }
     }
   }
@@ -1272,6 +1543,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(
@@ -1350,7 +1624,22 @@ If information is missing, clearly state it in the summary.</Important>`;
       (0, import_middleware.toolCallStatusMiddleware)(this),
       ...inWorkflow ? [(0, import_middleware.workflowHistoryMiddleware)(this, this.db)] : [],
       (0, import_middleware.conversationMiddleware)(this, { providerName, provider, llmService, model, messageId, agentThread }),
-      (0, import_middleware.toolCallSanitizerMiddleware)({ logger: this.logger })
+      (0, import_middleware.toolCallSanitizerMiddleware)({ logger: this.logger }),
+      (0, import_middleware.toolResultIntegrityMiddleware)({
+        sessionId: this.sessionId,
+        logger: this.logger,
+        loadToolResults: async (toolCallIds) => {
+          try {
+            return await this.getToolCallResults(toolCallIds);
+          } catch (error) {
+            this.logger.warn("Failed to load persisted tool results before model call", {
+              sessionId: this.sessionId,
+              error
+            });
+            return /* @__PURE__ */ new Map();
+          }
+        }
+      })
     ];
   }
   async getCurrentThread() {
@@ -1408,6 +1697,9 @@ If information is missing, clearly state it in the summary.</Important>`;
   get aiMessagesRepo() {
     return this.ctx.db.getRepository("aiMessages");
   }
+  get aiConversationsModel() {
+    return this.ctx.db.getModel("aiConversations");
+  }
   get aiMessagesModel() {
     return this.ctx.db.getModel("aiMessages");
   }
@@ -1429,8 +1721,10 @@ function getCurrentTimezone(ctx) {
   }
   return typeof value === "string" ? value : void 0;
 }
-function getCurrentDateTimeForPrompt(locale, timezone) {
-  const now = /* @__PURE__ */ new Date();
+function getCurrentDateTimeForPrompt(now, locale, timezone) {
+  if (!now) {
+    return void 0;
+  }
   const normalizedLocale = locale || "en-US";
   try {
     const formatter = new Intl.DateTimeFormat(normalizedLocale, {