@nocobase/plugin-ai 2.1.0-beta.9 → 2.2.0-alpha.1

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

@@ -36,38 +36,54 @@ 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_ai = require("@nocobase/ai");
 var import_checkpoints = require("./checkpoints");
 var import_langchain = require("langchain");
 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;
+  streamCached;
+  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 +94,50 @@ class AIEmployee {
     this.skillSettings = skillSettings;
     this.model = model;
     this.legacy = legacy;
-    const locale = this.ctx.getCurrentLocale();
+    this.from = from;
+    this.tools = tools;
+    this.streamCached = this.plugin.llmStreamCachedManager.getCached(sessionId);
     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 (chunk) => {
+      try {
+        await this.streamCached.append(chunk);
+      } catch (error) {
+        this.logger.warn("Failed to append LLM stream cache", { sessionId: this.sessionId, error });
+      }
+    });
+  }
+  get chatSettings() {
+    var _a, _b, _c;
+    return ((_b = (_a = this.employee) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "chatSettings")) ?? ((_c = this.employee) == null ? void 0 : _c.chatSettings) ?? {};
+  }
+  get systemPromptMode() {
+    return this.chatSettings.systemPromptMode ?? "default";
+  }
+  areSkillsEnabled() {
+    return this.chatSettings.enableSkills !== false;
+  }
+  areToolsEnabled() {
+    return this.chatSettings.enableTools !== false;
+  }
+  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) {
@@ -95,13 +150,15 @@ class AIEmployee {
       }
     };
   }
-  async initSession({ messageId, provider, model, providerName }) {
-    const tools = await this.getAIEmployeeTools();
+  async initSession({ messageId, provider, model, providerName, llmService }) {
+    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, llmService }),
         config: void 0,
         state: void 0
       };
@@ -113,10 +170,13 @@ class AIEmployee {
     return {
       historyMessages,
       tools,
-      middleware: this.getMiddleware({
+      resolvedTools,
+      middleware: await this.getMiddleware({
         tools,
+        baseToolNames,
         model,
         providerName,
+        llmService,
         messageId,
         agentThread
       }),
@@ -133,30 +193,49 @@ class AIEmployee {
     userMessages,
     userDecisions
   }) {
-    const { provider, model, service } = await this.getLLMService();
-    const { historyMessages, tools, middleware, config, state } = await this.initSession({
+    var _a, _b;
+    const { provider, model, service } = await this.plugin.aiManager.getLLMService({
+      ...this.model
+    });
+    const { historyMessages, tools, resolvedTools, middleware, config, state } = await this.initSession({
       messageId,
       provider,
       model,
-      providerName: service.provider
+      providerName: service.provider,
+      llmService: ((_a = service.get) == null ? void 0 : _a.call(service, "name")) || service.name
     });
     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 })
     });
-    return { providerName: service.provider, model, provider, chatContext, config, state };
+    return {
+      providerName: service.provider,
+      llmService: ((_b = service.get) == null ? void 0 : _b.call(service, "name")) || service.name,
+      model,
+      provider,
+      chatContext,
+      config,
+      state
+    };
   }
   async stream({
     messageId,
     userMessages = [],
     userDecisions
   }) {
+    await this.streamCached.clear();
+    await this.aiConversationsRepo.update({
+      values: { llmActiveState: "streaming" },
+      filter: {
+        sessionId: this.sessionId
+      }
+    });
     try {
-      const { providerName, model, provider, chatContext, config, state } = await this.buildChatContext({
+      const { providerName, llmService, model, provider, chatContext, config, state } = await this.buildChatContext({
         messageId,
         userMessages,
         userDecisions
@@ -172,6 +251,7 @@ class AIEmployee {
       await this.processChatStream(stream, {
         signal,
         providerName,
+        llmService,
         model,
         provider,
         responseMetadata
@@ -181,13 +261,31 @@ class AIEmployee {
       this.ctx.log.error(err);
       this.sendErrorResponse(err.message || "Chat error warning");
       return false;
+    } finally {
+      await this.aiConversationsRepo.update({
+        values: { llmActiveState: "idle", read: false },
+        filter: {
+          sessionId: this.sessionId
+        }
+      });
+      await this.streamCached.clear();
     }
   }
   async invoke({
     messageId,
     userMessages = [],
-    userDecisions
+    userDecisions,
+    writer,
+    context,
+    signal
   }) {
+    var _a;
+    await this.aiConversationsRepo.update({
+      values: { llmActiveState: "invoking" },
+      filter: {
+        sessionId: this.sessionId
+      }
+    });
     try {
       const { provider, chatContext, config, state } = await this.buildChatContext({
         messageId,
@@ -196,52 +294,31 @@ 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,
+        signal,
         ...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
+        }
+      });
     }
   }
-  // === LLM/provider setup ===
-  async getLLMService() {
-    var _a, _b;
-    if (!((_a = this.model) == null ? void 0 : _a.llmService) || !((_b = this.model) == null ? void 0 : _b.model)) {
-      throw new Error("LLM service not configured");
-    }
-    const llmServiceName = this.model.llmService;
-    const model = this.model.model;
-    const modelOptions = {
-      llmService: llmServiceName,
-      model
-    };
-    if (this.webSearch === true) {
-      modelOptions.builtIn = { webSearch: true };
-    }
-    const service = await this.db.getRepository("llmServices").findOne({
-      filter: {
-        name: llmServiceName
-      }
-    });
-    if (!service) {
-      throw new Error("LLM service not found");
-    }
-    const providerOptions = this.plugin.aiManager.llmProviders.get(service.provider);
-    if (!providerOptions) {
-      throw new Error("LLM service provider not found");
-    }
-    const Provider = providerOptions.provider;
-    const provider = new Provider({
-      app: this.ctx.app,
-      serviceOptions: service.options,
-      modelOptions
-    });
-    return { provider, model, service };
-  }
   // === Agent wiring & execution ===
   async createAgent({
     provider,
@@ -250,17 +327,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
         }
       });
     }
@@ -273,13 +357,19 @@ 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);
+    if (this.from === "sub-agent") {
+      delete config.configurable;
+    }
+    return agent.invoke(input, this.withRunMetadata(config));
   }
   async prepareChatStream({
     chatContext,
@@ -297,8 +387,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
         },
@@ -311,85 +401,102 @@ 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;
-    const { signal, providerName, model, provider, responseMetadata, allowEmpty = false } = 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 { signal, providerName, llmService, model, provider, responseMetadata, allowEmpty = false } = options;
     let isReasoning = false;
     let gathered;
     signal.addEventListener("abort", async () => {
-      if ((gathered == null ? void 0 : gathered.type) === "ai") {
-        const values = (0, import_utils2.convertAIMessage)({
-          aiEmployee: this,
-          providerName,
-          model,
-          aiMessage: gathered
-        });
-        if (values) {
-          values.metadata.interrupted = true;
+      try {
+        if ((gathered == null ? void 0 : gathered.type) === "ai") {
+          const values = (0, import_utils2.convertAIMessage)({
+            aiEmployee: this,
+            providerName,
+            llmService,
+            model,
+            aiMessage: gathered
+          });
+          if (values) {
+            values.metadata.interrupted = true;
+          }
+          await this.aiChatConversation.withTransaction(async (conversation, transaction) => {
+            const result = await conversation.addMessages(values);
+          });
         }
-        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) {
+        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();
       }
     });
     try {
-      this.protocol.startStream();
+      const aiEmployeeConversation = {
+        sessionId: this.sessionId,
+        from: this.from,
+        username: this.employee.username
+      };
+      await 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();
+                await this.protocol.with(currentConversation).stopReasoning();
               }
               const parsedContent = provider.parseResponseChunk(chunk.content);
               if (parsedContent) {
-                this.protocol.content(parsedContent);
+                await this.protocol.with(currentConversation).content(parsedContent);
               }
             }
             if ((_a = chunk.tool_call_chunks) == null ? void 0 : _a.length) {
-              this.protocol.toolCallChunks(chunk.tool_call_chunks);
+              await 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);
+              await this.protocol.with(currentConversation).webSearch(webSearch);
             }
             const reasoningContent = provider.parseReasoningContent(chunk);
             if (reasoningContent) {
               isReasoning = true;
-              this.protocol.reasoning(reasoningContent);
+              await 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),
+              async ({ messageId, interruptAction, toolCall, currentConversation }) => {
+                await 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") {
+            await this.streamCached.skipped();
+            aiMessageIdMap.set(currentConversation.sessionId, chunks.body.messageId);
             const data = responseMetadata.get(chunks.body.id);
             if (data) {
               const savedMessage = await this.aiMessagesModel.findOne({
@@ -417,12 +524,11 @@ class AIEmployee {
               }
             }
           } else if (chunks.action === "initToolCalls") {
-            toolCalls = ((_b = chunks.body) == null ? void 0 : _b.toolCalls) ?? [];
-            this.protocol.toolCalls(chunks.body);
+            await 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({
+            await 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,
@@ -434,7 +540,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({
+            await 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,
@@ -442,7 +548,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 ?? {};
@@ -455,7 +564,7 @@ class AIEmployee {
               for (const { metadata } of messages) {
                 const tools = toolsMap.get(metadata.toolName);
                 const toolCallResult = toolCallResultMap.get(metadata.toolCallId);
-                this.protocol.toolCallStatus({
+                await this.protocol.with(currentConversation).toolCallStatus({
                   toolCall: {
                     messageId,
                     id: metadata.toolCallId,
@@ -463,11 +572,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();
+            await this.protocol.with(currentConversation).newMessage();
+          } else if (chunks.action === "afterSubAgentInvoke") {
+            await this.protocol.with(currentConversation).subAgentCompleted();
           }
         }
       }
@@ -475,7 +589,7 @@ class AIEmployee {
         this.sendErrorResponse("Empty message");
         return;
       }
-      this.protocol.endStream();
+      await this.protocol.with(aiEmployeeConversation).endStream();
     } catch (err) {
       this.ctx.log.error(err);
       if (err.name === "GraphRecursionError") {
@@ -484,7 +598,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 ===
@@ -530,58 +679,74 @@ 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;
+    if (this.systemPromptMode === "none") {
+      return "";
+    }
+    const about = await (0, import_utils.parseVariables)(this.ctx, this.employee.about ?? this.employee.defaultPrompt ?? "");
+    if (this.systemPromptMode === "raw") {
+      return about;
+    }
     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
       }
     });
-    let systemMessage = await (0, import_utils.parseVariables)(this.ctx, this.employee.about ?? this.employee.defaultPrompt ?? "");
-    const dataSourceMessage = this.getEmployeeDataSourceContext();
-    if (dataSourceMessage) {
-      systemMessage = `${systemMessage}
-${dataSourceMessage}`;
-    }
     let background = "";
     if (this.systemMessage) {
       background = await (0, import_utils.parseVariables)(this.ctx, this.systemMessage);
     }
+    const dataSourceMessage = this.getEmployeeDataSourceContext();
+    if (dataSourceMessage) {
+      background = `${background}
+${dataSourceMessage}`;
+    }
     const aiMessages = await this.aiChatConversation.listMessages();
     const workContextBackground = await this.plugin.workContextHandler.background(this.ctx, aiMessages);
     if (workContextBackground == null ? void 0 : workContextBackground.length) {
       background = `${background}
 ${workContextBackground.join("\n")}`;
+    }
+    const addSystemPrompt = userMessages == null ? void 0 : userMessages.filter((it) => it.role == "system");
+    if (addSystemPrompt.length) {
+      background = `${background}
+${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,
-        about: this.employee.about ?? this.employee.defaultPrompt
+        about
       },
       task: {
         background
       },
       personal: userConfig == null ? void 0 : userConfig.prompt,
-      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.
@@ -610,8 +775,8 @@ If information is missing, clearly state it in the summary.</Important>`;
           vectorStoreConfig.vectorStoreProvider,
           [
             {
-              key: "vectorStoreConfigId",
-              value: vectorStoreConfig.vectorStoreConfigId
+              key: "vectorStoreConfigKey",
+              value: vectorStoreConfig.vectorStoreConfigKey ?? ""
             }
           ]
         );
@@ -625,23 +790,20 @@ If information is missing, clearly state it in the summary.</Important>`;
         });
         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];
-        }
+        const vectorStoreService = await vectorStoreProvider.createVectorStoreService(
+          vectorStoreConfig.vectorStoreProvider,
+          [
+            {
+              key: "vectorStoreConfigKey",
+              value: vectorStoreConfig.vectorStoreConfigKey ?? ""
+            }
+          ]
+        );
+        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(
@@ -671,11 +833,11 @@ If information is missing, clearly state it in the summary.</Important>`;
     };
   }
   async getKnowledgeBaseGroup() {
-    const { knowledgeBaseIds } = this.employee.knowledgeBase ?? {};
-    if (!knowledgeBaseIds || import_lodash.default.isEmpty(knowledgeBaseIds)) {
+    const { knowledgeBaseKeys } = this.employee.knowledgeBase ?? {};
+    if (!knowledgeBaseKeys || import_lodash.default.isEmpty(knowledgeBaseKeys)) {
       return [];
     }
-    return await this.plugin.features.knowledgeBase.getKnowledgeBaseGroup(knowledgeBaseIds);
+    return await this.plugin.features.knowledgeBase.getKnowledgeBaseGroup(knowledgeBaseKeys);
   }
   // === Tool calls ===
   async initToolCall(transaction, messageId, toolCalls) {
@@ -704,23 +866,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(
@@ -782,7 +975,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
       }
@@ -791,7 +983,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
@@ -800,19 +991,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;
@@ -827,7 +1005,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"
@@ -837,7 +1014,9 @@ If information is missing, clearly state it in the summary.</Important>`;
     if (!toolMessages || import_lodash.default.isEmpty(toolMessages)) {
       return;
     }
-    const { model, service } = await this.getLLMService();
+    const { model, service } = await this.plugin.aiManager.getLLMService({
+      ...this.model
+    });
     const toolCallMap = await this.getToolCallMap(messageId);
     const now = /* @__PURE__ */ new Date();
     const toolMessageContent = "The user ignored the application for tools usage and will continued to ask questions";
@@ -917,15 +1096,14 @@ 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 }) {
     var _a, _b;
     const formattedMessages = [];
     const workContextHandler = this.plugin.workContextHandler;
-    await this.hydrateAttachmentsMeta(messages);
     const truncate = (text, maxLen = 5e4) => {
       if (!text || text.length <= maxLen) return text;
       return text.slice(0, maxLen) + "\n...[truncated]";
@@ -1004,46 +1182,6 @@ If information is missing, clearly state it in the summary.</Important>`;
     }
     return formattedMessages;
   }
-  async hydrateAttachmentsMeta(messages) {
-    var _a, _b;
-    const attachmentIds = /* @__PURE__ */ new Set();
-    for (const message of messages) {
-      if (!((_a = message.attachments) == null ? void 0 : _a.length)) {
-        continue;
-      }
-      for (const attachment of message.attachments) {
-        if ((attachment == null ? void 0 : attachment.id) != null) {
-          attachmentIds.add(attachment.id);
-        }
-      }
-    }
-    if (!attachmentIds.size) {
-      return;
-    }
-    const files = await this.aiFilesModel.findAll({
-      where: {
-        id: {
-          [import_database.Op.in]: Array.from(attachmentIds)
-        }
-      },
-      attributes: ["id", "meta"]
-    });
-    const metaById = new Map(files.map((file) => [file.get("id"), file.get("meta")]));
-    for (const message of messages) {
-      if (!((_b = message.attachments) == null ? void 0 : _b.length)) {
-        continue;
-      }
-      for (const attachment of message.attachments) {
-        if ((attachment == null ? void 0 : attachment.id) == null) {
-          continue;
-        }
-        const meta = metaById.get(attachment.id);
-        if (meta !== void 0) {
-          attachment.meta = meta;
-        }
-      }
-    }
-  }
   async getToolCallMap(messageId) {
     const result = /* @__PURE__ */ new Map();
     const { toolCalls } = await this.aiMessagesRepo.findById(messageId);
@@ -1058,7 +1196,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;
     }
@@ -1066,39 +1204,187 @@ 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;
   }
   async getAIEmployeeTools() {
-    var _a, _b;
+    var _a;
+    if (!this.areToolsEnabled()) {
+      return [];
+    }
     const tools = await this.listTools({ scope: "GENERAL" });
+    if (this.webSearch === true) {
+      const subAgentWebSearch = await this.toolsManager.getTools(import_ai.SYSTEM_TOOLS.WEB_SEARCH);
+      tools.push(subAgentWebSearch);
+    }
     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 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);
+      if (knowledgeBaseRetrieveTool) {
+        employeeTools.push({ name: import_ai.SYSTEM_TOOLS.KNOWLEDGE_BASE });
+      }
+    }
+    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 skillFilter = ((_b = this.skillSettings) == null ? void 0 : _b.skills) ?? [];
-    return tools.filter((t) => skillFilter.length === 0 || skillFilter.includes(t.definition.name));
+    const systemTools = (0, import_ai.listSystemTools)();
+    if (!this.skillSettings) {
+      return tools;
+    } 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)
+      );
+    } 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));
+      } else {
+        return tools;
+      }
+    }
+  }
+  async getAvailableSkills() {
+    var _a;
+    if (!this.areSkillsEnabled()) {
+      return [];
+    }
+    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 mergedSkills = import_lodash.default.uniqBy([...specifiedSkills || [], ...generalSkills || []], "name");
+    if (!this.skillSettings) {
+      return mergedSkills;
+    } else if (!this.skillSettings.skillsVersion) {
+      const skillFilter = this.skillSettings.skills ?? [];
+      return mergedSkills.filter((it) => skillFilter.length === 0 || skillFilter.includes(it.name));
+    } else {
+      const skillFilter = this.skillSettings.skills;
+      if (import_lodash.default.isArray(skillFilter)) {
+        return mergedSkills.filter((it) => skillFilter.includes(it.name));
+      } else {
+        return mergedSkills;
+      }
+    }
   }
-  getMiddleware(options) {
-    const { providerName, model, tools, messageId, agentThread } = options;
+  async getAgentTools() {
+    if (!this.areToolsEnabled()) {
+      return {
+        tools: [],
+        baseToolNames: /* @__PURE__ */ new Set()
+      };
+    }
+    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() {
+    var _a, _b;
+    const specifiedToolNames = ((_b = (_a = this.employee.skillSettings) == null ? void 0 : _a.tools) == null ? void 0 : _b.map(({ name }) => name)) ?? [];
+    if (!specifiedToolNames.includes("dispatch-sub-agent-task")) {
+      return [];
+    }
+    const availableAIEmployees = (await (0, import_shared.listAccessibleAIEmployees)(this.ctx)).map((employee) => (0, import_shared.serializeEmployeeSummary)(this.ctx, employee)).filter((it) => it.username !== this.employee.username);
+    return availableAIEmployees;
+  }
+  async getMiddleware(options) {
+    const { providerName, llmService, 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),
-      (0, import_middleware.conversationMiddleware)(this, { providerName, model, messageId, agentThread })
+      ...inWorkflow ? [(0, import_middleware.workflowHistoryMiddleware)(this, this.db)] : [],
+      (0, import_middleware.conversationMiddleware)(this, { providerName, llmService, model, messageId, agentThread })
     ];
   }
   async getCurrentThread() {
@@ -1123,12 +1409,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;
   }
@@ -1151,6 +1452,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;
@@ -1173,8 +1501,9 @@ class AgentThread {
   }
 }
 class ChatStreamProtocol {
-  constructor(ctx) {
-    this.ctx = ctx;
+  constructor(streamConsumer, onWrite) {
+    this.streamConsumer = streamConsumer;
+    this.onWrite = onWrite;
   }
   _statistics = {
     sent: 0,
@@ -1185,71 +1514,87 @@ 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 });
-  }
-  toolCallStatus({
-    toolCall,
-    invokeStatus,
-    status,
-    interruptAction
-  }) {
-    this.write({
-      type: "tool_call_status",
-      body: {
+  static fromContext(ctx, onWrite) {
+    return new ChatStreamProtocol(ctx.res, onWrite);
+  }
+  with(conversation) {
+    const write = async ({ type, body }) => {
+      var _a;
+      const { sessionId, from, username } = conversation;
+      const data = `data: ${JSON.stringify({ sessionId, from, username, type, body })}
+
+`;
+      await ((_a = this.onWrite) == null ? void 0 : _a.call(this, data));
+      this.streamConsumer.write(data);
+      this._statistics.addSent(data.length);
+    };
+    return {
+      startStream: async () => {
+        this._statistics.reset();
+        await write({ type: "stream_start" });
+      },
+      endStream: async () => {
+        await write({ type: "stream_end" });
+      },
+      subAgentCompleted: async () => {
+        await write({ type: "sub_agent_completed" });
+      },
+      newMessage: async (content) => {
+        await write({ type: "new_message", body: content });
+      },
+      content: async (content) => {
+        await write({ type: "content", body: content });
+      },
+      webSearch: async (content) => {
+        await write({ type: "web_search", body: content });
+      },
+      reasoning: async (content) => {
+        await write({ type: "reasoning", body: content });
+      },
+      stopReasoning: async () => {
+        await write({
+          type: "reasoning",
+          body: {
+            status: "stop",
+            content: ""
+          }
+        });
+      },
+      toolCallChunks: async (content) => {
+        await write({ type: "tool_call_chunks", body: content });
+      },
+      toolCalls: async (content) => {
+        await write({ type: "tool_calls", body: content });
+      },
+      toolCallStatus: async ({
         toolCall,
         invokeStatus,
         status,
+        invokeStartTime,
+        invokeEndTime,
+        content,
         interruptAction
+      }) => {
+        await 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) {
@@ -1270,5 +1615,6 @@ class ResponseMetadataCollector extends import_base.BaseCallbackHandler {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AIEmployee
+  AIEmployee,
+  ChatStreamProtocol
 });