@nocobase/plugin-ai 1.9.0-beta.9 → 2.0.0-alpha.10

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

@@ -0,0 +1,817 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_employee_exports = {};
+__export(ai_employee_exports, {
+  AIEmployee: () => AIEmployee
+});
+module.exports = __toCommonJS(ai_employee_exports);
+var import_stream = require("@langchain/core/utils/stream");
+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");
+class AIEmployee {
+  employee;
+  plugin;
+  db;
+  sessionId;
+  ctx;
+  systemMessage;
+  aiChatConversation;
+  skillSettings;
+  webSearch;
+  constructor(ctx, employee, sessionId, systemMessage, skillSettings, webSearch) {
+    this.employee = employee;
+    this.ctx = ctx;
+    this.plugin = ctx.app.pm.get("ai");
+    this.db = ctx.db;
+    this.sessionId = sessionId;
+    this.systemMessage = systemMessage;
+    this.aiChatConversation = (0, import_ai_chat_conversation.createAIChatConversation)(this.ctx, this.sessionId);
+    this.skillSettings = skillSettings;
+    const locale = this.ctx.getCurrentLocale();
+    const builtInManager = this.plugin.builtInManager;
+    builtInManager.setupBuiltInInfo(locale, this.employee);
+    this.webSearch = webSearch;
+  }
+  async getLLMService() {
+    var _a;
+    const modelSettings = this.employee.modelSettings;
+    if (!(modelSettings == null ? void 0 : modelSettings.llmService)) {
+      throw new Error("LLM service not configured");
+    }
+    if (((_a = modelSettings == null ? void 0 : modelSettings.builtIn) == null ? void 0 : _a.webSearch) === true) {
+      if (this.webSearch !== false) {
+        modelSettings.builtIn.webSearch = true;
+      } else {
+        modelSettings.builtIn.webSearch = false;
+      }
+    }
+    const service = await this.db.getRepository("llmServices").findOne({
+      filter: {
+        name: modelSettings.llmService
+      }
+    });
+    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: {
+        ...modelSettings
+      }
+    });
+    return { provider, model: modelSettings.model, service };
+  }
+  async prepareChatStream(chatContext, provider) {
+    const controller = new AbortController();
+    const { signal } = controller;
+    try {
+      const stream = await provider.stream(chatContext, { signal, version: "v2" });
+      this.plugin.aiEmployeesManager.conversationController.set(this.sessionId, controller);
+      return { stream, controller, signal };
+    } catch (error) {
+      throw error;
+    }
+  }
+  async processChatStream(stream, options) {
+    var _a;
+    const { signal, messageId, model, service, provider, allowEmpty = false } = options;
+    let gathered;
+    let errMsg = "";
+    try {
+      for await (const streamEvent of stream) {
+        if (streamEvent.event !== "on_chat_model_stream") {
+          this.ctx.log.debug(`skip event: ${streamEvent.event}`);
+          continue;
+        }
+        const chunk = streamEvent.data.chunk;
+        gathered = gathered !== void 0 ? (0, import_stream.concat)(gathered, chunk) : chunk;
+        if (chunk.content) {
+          this.ctx.res.write(
+            `data: ${JSON.stringify({ type: "content", body: provider.parseResponseChunk(chunk.content) })}
+
+`
+          );
+        }
+        if (chunk.tool_call_chunks) {
+          this.ctx.res.write(`data: ${JSON.stringify({ type: "tool_call_chunks", body: chunk.tool_call_chunks })}
+
+`);
+        }
+        const webSearch = provider.parseWebSearchAction(chunk);
+        if (webSearch == null ? void 0 : webSearch.length) {
+          this.ctx.res.write(`data: ${JSON.stringify({ type: "web_search", body: webSearch })}
+
+`);
+        }
+      }
+    } catch (err) {
+      errMsg = err.message;
+      this.ctx.log.error(err);
+    }
+    this.plugin.aiEmployeesManager.conversationController.delete(this.sessionId);
+    const message = gathered == null ? void 0 : gathered.content;
+    const toolCalls = gathered == null ? void 0 : gathered.tool_calls;
+    const skills = (_a = this.employee.skillSettings) == null ? void 0 : _a.skills;
+    if (!message && !(toolCalls == null ? void 0 : toolCalls.length) && !signal.aborted && !allowEmpty) {
+      this.ctx.res.write(`data: ${JSON.stringify({ type: "error", body: errMsg })}
+
+`);
+      this.ctx.res.end();
+      return;
+    }
+    if (message || (toolCalls == null ? void 0 : toolCalls.length)) {
+      const values = {
+        role: this.employee.username,
+        content: {
+          type: "text",
+          content: message
+        },
+        metadata: {
+          model,
+          provider: service.provider,
+          usage_metadata: {}
+        },
+        toolCalls: null
+      };
+      if (signal.aborted) {
+        values.metadata.interrupted = true;
+      }
+      if (toolCalls == null ? void 0 : toolCalls.length) {
+        values.toolCalls = toolCalls;
+        values.metadata.autoCallTools = toolCalls.filter((tool) => {
+          return skills == null ? void 0 : skills.some((s) => s.name === tool.name && s.autoCall);
+        }).map((tool) => tool.name);
+      }
+      if (gathered == null ? void 0 : gathered.usage_metadata) {
+        values.metadata.usage_metadata = gathered.usage_metadata;
+      }
+      if (gathered == null ? void 0 : gathered.response_metadata) {
+        values.metadata.response_metadata = gathered.response_metadata;
+      }
+      const aiMessage = await this.aiChatConversation.withTransaction(async (conversation, transaction) => {
+        if (messageId) {
+          await conversation.removeMessages({ messageId });
+          await this.aiToolMessagesRepo.destroy({
+            filter: {
+              sessionId: this.sessionId,
+              messageId: {
+                $gte: messageId
+              }
+            },
+            transaction
+          });
+        }
+        const result = await conversation.addMessages(values);
+        if (toolCalls == null ? void 0 : toolCalls.length) {
+          await this.initToolCall(transaction, result.messageId, toolCalls);
+        }
+        return result;
+      });
+      if (toolCalls == null ? void 0 : toolCalls.length) {
+        this.ctx.res.write(`data: ${JSON.stringify({ type: "new_message" })}
+
+`);
+        await this.callTool(aiMessage.messageId, true);
+        return;
+      }
+    }
+    this.ctx.res.end();
+  }
+  async parseUISchema(content) {
+    const regex = /\{\{\$UISchema\.([^}]+)\}\}/g;
+    const uiSchemaRepo = this.db.getRepository("uiSchemas");
+    const matches = [...content.matchAll(regex)];
+    let result = content;
+    for (const match of matches) {
+      const fullMatch = match[0];
+      const uid = match[1];
+      try {
+        const schema = await uiSchemaRepo.getJsonSchema(uid);
+        if (schema) {
+          const s = JSON.stringify(schema);
+          result = result.replace(fullMatch, `UI schema id: ${uid}, UI schema: ${s}`);
+        }
+      } catch (error) {
+        this.ctx.log.error(error, { module: "aiConversations", method: "parseUISchema", uid });
+      }
+    }
+    return result;
+  }
+  getDataSources() {
+    var _a;
+    const dataSourceSettings = this.employee.dataSourceSettings;
+    if (!dataSourceSettings) {
+      return null;
+    }
+    const collections = dataSourceSettings.collections || [];
+    const names = collections.map((collection) => collection.collection);
+    let message = "";
+    for (const name of names) {
+      let [dataSourceName, collectionName] = name.split(":");
+      let db;
+      if (!collectionName) {
+        collectionName = dataSourceName;
+        dataSourceName = "main";
+        db = this.db;
+      } else {
+        const dataSource = this.ctx.app.dataSourceManager.dataSources.get(dataSourceName);
+        db = dataSource == null ? void 0 : dataSource.collectionManager.db;
+      }
+      if (!db) {
+        continue;
+      }
+      const collection = db.getCollection(collectionName);
+      if (!collection || collection.options.hidden) {
+        continue;
+      }
+      message += `
+Database type: ${db.sequelize.getDialect()}, Collection: ${collectionName}, Title: ${collection.options.title}`;
+      const fields = collection.getFields();
+      for (const field of fields) {
+        if (field.options.hidden) {
+          continue;
+        }
+        message += `
+Field: ${field.name}, Title: ${(_a = field.options.uiSchema) == null ? void 0 : _a.title}, Type: ${field.type}, Interface: ${field.options.interface}, Options: ${JSON.stringify(field.options)}`;
+      }
+    }
+    return message;
+  }
+  async getSystemPrompt(aiMessages) {
+    var _a;
+    const userConfig = await this.db.getRepository("usersAiEmployees").findOne({
+      filter: {
+        userId: (_a = this.ctx.auth) == null ? void 0 : _a.user.id,
+        aiEmployee: this.employee.username
+      }
+    });
+    let systemMessage = await (0, import_utils.parseVariables)(this.ctx, this.employee.about);
+    const dataSourceMessage = this.getDataSources();
+    if (dataSourceMessage) {
+      systemMessage = `${systemMessage}
+${dataSourceMessage}`;
+    }
+    let background = "";
+    if (this.systemMessage) {
+      background = await (0, import_utils.parseVariables)(this.ctx, this.systemMessage);
+    }
+    const workContextBackground = await this.plugin.workContextHandler.background(this.ctx, aiMessages);
+    if (workContextBackground == null ? void 0 : workContextBackground.length) {
+      background = `${background}
+${workContextBackground.join("\n")}`;
+    }
+    let knowledgeBase;
+    if (this.isEnabledKnowledgeBase() && this.employee.knowledgeBasePrompt) {
+      const lastUserMessage = await this.aiChatConversation.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
+      });
+    }
+    return (0, import_prompts.getSystemPrompt)({
+      aiEmployee: {
+        nickname: this.employee.nickname,
+        about: this.employee.about
+      },
+      task: {
+        background
+      },
+      personal: userConfig == null ? void 0 : userConfig.prompt,
+      dataSources: dataSourceMessage,
+      environment: {
+        database: this.db.sequelize.getDialect(),
+        locale: this.ctx.getCurrentLocale() || "en-US"
+      },
+      knowledgeBase
+    });
+  }
+  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);
+  }
+  async initToolCall(transaction, messageId, toolCalls) {
+    const nowTime = /* @__PURE__ */ new Date();
+    const tools = await this.withTool(toolCalls);
+    await this.aiToolMessagesRepo.create({
+      values: tools.map((toolCall) => {
+        var _a;
+        return {
+          id: this.plugin.snowflake.generate(),
+          sessionId: this.sessionId,
+          messageId,
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          status: toolCall.toolExist ? null : "error",
+          content: toolCall.toolExist ? null : `Tool ${toolCall.name} not found`,
+          invokeStatus: toolCall.toolExist ? "init" : "done",
+          invokeStartTime: toolCall.toolExist ? null : nowTime,
+          invokeEndTime: toolCall.toolExist ? null : nowTime,
+          auto: toolCall.auto,
+          execution: ((_a = toolCall == null ? void 0 : toolCall.tool) == null ? void 0 : _a.execution) ?? "backend"
+        };
+      }),
+      transaction
+    });
+  }
+  async callTool(messageId, autoCall) {
+    try {
+      const toolCalls = await this.getToolCallList(messageId);
+      const tools = await this.withTool(toolCalls);
+      const backendTools = tools.filter(({ auto }) => auto === autoCall).filter(({ tool }) => tool.execution === "backend");
+      const frontendTools = tools.filter(({ auto }) => auto === autoCall).filter(({ tool }) => tool.execution === "frontend");
+      if (!import_lodash.default.isEmpty(backendTools)) {
+        const parallelToolCall = backendTools.map(async (toolCall) => {
+          const [updated] = await this.aiToolMessagesModel.update(
+            {
+              invokeStatus: "pending",
+              invokeStartTime: /* @__PURE__ */ new Date()
+            },
+            {
+              where: {
+                messageId,
+                toolCallId: toolCall.id,
+                invokeStatus: "init"
+              }
+            }
+          );
+          if (updated === 0) {
+            return;
+          }
+          const result = await toolCall.tool.invoke(this.ctx, toolCall.args);
+          await this.aiToolMessagesModel.update(
+            {
+              invokeStatus: "done",
+              invokeEndTime: /* @__PURE__ */ new Date(),
+              status: result.status,
+              content: result.content
+            },
+            {
+              where: {
+                messageId,
+                toolCallId: toolCall.id,
+                invokeStatus: "pending"
+              }
+            }
+          );
+        });
+        await Promise.all(parallelToolCall);
+      }
+      if (!import_lodash.default.isEmpty(frontendTools)) {
+        const parallelToolCall = frontendTools.map(async (toolCall) => {
+          const [updated] = await this.aiToolMessagesModel.update(
+            {
+              invokeStatus: "pending",
+              invokeStartTime: /* @__PURE__ */ new Date()
+            },
+            {
+              where: {
+                messageId,
+                toolCallId: toolCall.id,
+                invokeStatus: "init"
+              }
+            }
+          );
+          if (updated === 0) {
+            return null;
+          } else {
+            return toolCall;
+          }
+        });
+        const type = "tool_calls";
+        const body = (await Promise.all(parallelToolCall)).filter((x) => !import_lodash.default.isNull(x));
+        if (!import_lodash.default.isEmpty(body)) {
+          this.ctx.res.write(`data: ${JSON.stringify({ type, body })} 
+
+`);
+        }
+        this.ctx.res.end();
+      } else {
+        await this.sendToolMessage(messageId);
+      }
+    } catch (err) {
+      this.ctx.log.error(err);
+      this.sendErrorResponse("Tool call error");
+    }
+  }
+  async confirmToolCall(messageId, toolCallIds = []) {
+    if (!import_lodash.default.isEmpty(toolCallIds)) {
+      const toolCallList = await this.getToolCallList(messageId);
+      const tools = await this.withTool(toolCallList.filter((x) => toolCallIds.includes(x.id)));
+      const frontendTools = tools.filter(({ tool }) => tool.execution === "frontend");
+      if (!import_lodash.default.isEmpty(frontendTools)) {
+        const parallelToolCall = frontendTools.map(async (toolCall) => {
+          const result = await toolCall.tool.invoke(this.ctx, toolCall.args);
+          await this.aiToolMessagesModel.update(
+            {
+              invokeStatus: "done",
+              invokeEndTime: /* @__PURE__ */ new Date(),
+              status: result.status,
+              content: result.content
+            },
+            {
+              where: {
+                messageId,
+                toolCallId: toolCall.id,
+                invokeStatus: "pending"
+              }
+            }
+          );
+        });
+        await Promise.all(parallelToolCall);
+      }
+    }
+    await this.sendToolMessage(messageId);
+  }
+  async cancelToolCall() {
+    var _a;
+    let messageId;
+    const historyMessages = await this.db.getRepository("aiConversations.messages", this.sessionId).find({
+      sort: ["-messageId"]
+    });
+    const [lastMessage] = historyMessages;
+    if (((_a = lastMessage == null ? void 0 : lastMessage.toolCalls) == null ? void 0 : _a.length) ?? 0 > 0) {
+      messageId = lastMessage.messageId;
+    } else {
+      return;
+    }
+    const toolCalls = await this.aiToolMessagesRepo.find({
+      filter: {
+        messageId,
+        invokeStatus: {
+          $ne: "confirmed"
+        }
+      }
+    });
+    if (!toolCalls || import_lodash.default.isEmpty(toolCalls)) {
+      return;
+    }
+    const { model, service } = await this.getLLMService();
+    const toolCallMap = await this.getToolCallMap(messageId);
+    const now = /* @__PURE__ */ new Date();
+    const toolMessageContent = "The user rejected this tool invocation and needs to continue modifying the parameters.";
+    await this.db.sequelize.transaction(async (transaction) => {
+      for (const toolCall of toolCalls) {
+        const [updated] = await this.aiToolMessagesModel.update(
+          {
+            invokeStatus: "done",
+            status: "error",
+            content: toolMessageContent,
+            invokeStartTime: toolCall.invokeStartTime ?? now,
+            invokeEndTime: toolCall.invokeEndTime ?? now
+          },
+          {
+            where: {
+              id: toolCall.id,
+              invokeStatus: toolCall.invokeStatus
+            },
+            transaction
+          }
+        );
+        if (updated === 0) {
+          continue;
+        }
+        await this.db.getRepository("aiConversations.messages", this.sessionId).create({
+          values: toolCalls.map((toolCall2) => ({
+            messageId: this.plugin.snowflake.generate(),
+            role: "tool",
+            content: {
+              type: "text",
+              content: toolMessageContent
+            },
+            metadata: {
+              model,
+              provider: service.provider,
+              toolCall: toolCallMap.get(toolCall2.toolCallId),
+              autoCall: toolCall2.auto
+            },
+            transaction
+          }))
+        });
+        await this.aiToolMessagesRepo.update({
+          filter: {
+            messageId,
+            toolCallId: toolCall.toolCallId
+          },
+          values: {
+            invokeStatus: "confirmed"
+          },
+          transaction
+        });
+      }
+    });
+  }
+  async sendToolMessage(messageId) {
+    const toolCalls = await this.aiToolMessagesRepo.find({ filter: { messageId } });
+    if (import_lodash.default.isEmpty(toolCalls) || !toolCalls.every((item) => item.invokeStatus === "done")) {
+      this.ctx.res.end();
+      return;
+    }
+    const { provider, model, service } = await this.getLLMService();
+    const toolCallMap = await this.getToolCallMap(messageId);
+    await this.aiChatConversation.withTransaction(async (conversation, transaction) => {
+      await conversation.addMessages(
+        toolCalls.map((toolCall) => ({
+          role: "tool",
+          content: {
+            type: "text",
+            content: toolCall.content
+          },
+          metadata: {
+            model,
+            provider: service.provider,
+            toolCall: toolCallMap.get(toolCall.toolCallId),
+            autoCall: toolCall.auto
+          }
+        }))
+      );
+      for (const toolCall of toolCalls) {
+        await this.aiToolMessagesRepo.update({
+          filter: {
+            messageId,
+            toolCallId: toolCall.toolCallId
+          },
+          values: {
+            invokeStatus: "confirmed"
+          },
+          transaction
+        });
+      }
+    });
+    const chatContext = await this.aiChatConversation.getChatContext({
+      workContextHandler: this.plugin.workContextHandler,
+      provider,
+      getSystemPrompt: async (aiMessages) => await this.getSystemPrompt(aiMessages),
+      tools: await this.getTools()
+    });
+    const { stream, signal } = await this.prepareChatStream(chatContext, provider);
+    await this.processChatStream(stream, {
+      signal,
+      model,
+      service,
+      provider,
+      allowEmpty: true
+    });
+  }
+  sendErrorResponse(errorMessage) {
+    this.ctx.res.write(`data: ${JSON.stringify({ type: "error", body: errorMessage })} 
+
+`);
+    this.ctx.res.end();
+  }
+  async processMessages(userMessages, messageId) {
+    try {
+      await this.aiChatConversation.withTransaction(async (conversation) => {
+        if (messageId) {
+          await conversation.removeMessages({ messageId });
+        }
+        await conversation.addMessages(userMessages);
+      });
+      const { provider, model, service } = await this.getLLMService();
+      const chatContext = await this.aiChatConversation.getChatContext({
+        workContextHandler: this.plugin.workContextHandler,
+        provider,
+        getSystemPrompt: async (aiMessages) => await this.getSystemPrompt(aiMessages),
+        tools: await this.getTools()
+      });
+      const { stream, signal } = await this.prepareChatStream(chatContext, provider);
+      await this.processChatStream(stream, {
+        signal,
+        model,
+        provider,
+        service
+      });
+      return true;
+    } catch (err) {
+      this.ctx.log.error(err);
+      this.sendErrorResponse("Chat error warning");
+      return false;
+    }
+  }
+  async resendMessages(messageId) {
+    try {
+      const { provider, model, service } = await this.getLLMService();
+      const chatContext = await this.aiChatConversation.getChatContext({
+        workContextHandler: this.plugin.workContextHandler,
+        provider,
+        getSystemPrompt: async (aiMessages) => await this.getSystemPrompt(aiMessages),
+        messageId,
+        tools: await this.getTools()
+      });
+      const { stream, signal } = await this.prepareChatStream(chatContext, provider);
+      await this.processChatStream(stream, {
+        signal,
+        messageId,
+        model,
+        provider,
+        service
+      });
+      return true;
+    } catch (err) {
+      this.ctx.log.error(err);
+      this.sendErrorResponse(err.message);
+      return false;
+    }
+  }
+  getAutoSkillNames() {
+    const skills = this.getSkills();
+    return skills.filter(({ autoCall }) => autoCall ?? false).map(({ name }) => name);
+  }
+  getSkills() {
+    var _a;
+    return ((_a = this.employee.skillSettings) == null ? void 0 : _a.skills) ?? [];
+  }
+  async getToolCallList(messageId) {
+    const { toolCalls } = await this.aiMessagesRepo.findByTargetKey(messageId);
+    return toolCalls;
+  }
+  async getToolCallMap(messageId) {
+    const result = /* @__PURE__ */ new Map();
+    const { toolCalls } = await this.aiMessagesRepo.findById(messageId);
+    if (!toolCalls) {
+      return result;
+    }
+    for (const toolCall of toolCalls) {
+      result.set(toolCall.id, toolCall);
+    }
+    return result;
+  }
+  async withTool(toolCalls) {
+    const autoSkillNames = this.getAutoSkillNames();
+    const toolMap = await this.getToolMap();
+    return toolCalls.map((toolCall) => ({
+      ...toolCall,
+      toolExist: toolMap.has(toolCall.name),
+      tool: toolMap.get(toolCall.name),
+      auto: autoSkillNames.includes(toolCall.name)
+    }));
+  }
+  async getTools() {
+    var _a;
+    const toolMap = await this.getToolMap();
+    const tools = [];
+    let skills = this.getSkills();
+    const skillFilter = (_a = this.skillSettings) == null ? void 0 : _a.skills;
+    if (skillFilter) {
+      if (skillFilter.length) {
+        skills = skills.filter((skill) => skillFilter.includes(skill.name));
+      } else {
+        skills = [];
+      }
+    }
+    if (skills == null ? void 0 : skills.length) {
+      for (const skill of skills) {
+        const tool = toolMap.get(skill.name);
+        if (tool) {
+          tools.push(tool);
+        }
+      }
+    }
+    return tools;
+  }
+  async getToolMap() {
+    const toolGroupList = await this.plugin.aiManager.toolManager.listTools();
+    const toolList = toolGroupList.flatMap(({ tools }) => tools);
+    return new Map(toolList.map((tool) => [tool.name, tool]));
+  }
+  get aiMessagesRepo() {
+    return this.ctx.db.getRepository("aiMessages");
+  }
+  get aiToolMessagesRepo() {
+    return this.ctx.db.getRepository("aiToolMessages");
+  }
+  get aiToolMessagesModel() {
+    return this.ctx.db.getModel("aiToolMessages");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIEmployee
+});