@nocobase/plugin-ai 2.1.0-alpha.34 → 2.1.0-alpha.36

package/dist/server/index.d.ts

@@ -11,6 +11,8 @@ export { LLMProvider, LLMProviderOptions } from './llm-providers/provider';
 export { LLMProviderMeta } from './manager/ai-manager';
 export { ToolOptions } from './manager/tool-manager';
 export { DocumentLoader } from './document-loader';
+export { AIEmployee } from './ai-employees/ai-employee';
+export type { AIEmployeeOptions, ModelRef } from './ai-employees/ai-employee';
 export type { ParsedDocumentResult, ParseableFile, DocumentParseMeta } from './document-loader';
 export type * from './features';
 export type * from './types';

package/dist/server/index.js

@@ -36,6 +36,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
+  AIEmployee: () => import_ai_employee.AIEmployee,
   DocumentLoader: () => import_document_loader.DocumentLoader,
   LLMProvider: () => import_provider.LLMProvider,
   LLMProviderMeta: () => import_ai_manager.LLMProviderMeta,
@@ -49,8 +50,10 @@ var import_provider = require("./llm-providers/provider");
 var import_ai_manager = require("./manager/ai-manager");
 var import_tool_manager = require("./manager/tool-manager");
 var import_document_loader = require("./document-loader");
+var import_ai_employee = require("./ai-employees/ai-employee");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AIEmployee,
   DocumentLoader,
   LLMProvider,
   LLMProviderMeta,

package/dist/server/llm-providers/common/reasoning.d.ts

@@ -10,8 +10,10 @@ import { BaseMessage } from '@langchain/core/messages';
 import { ChatOpenAICompletions } from '@langchain/openai';
 import type OpenAI from 'openai';
 export declare const REASONING_MAP_KEY = "__nb_reasoning_map";
+export declare const MODEL_KWARGS_KEY = "__nb_model_kwargs";
 export declare const collectReasoningMap: (messages: BaseMessage[]) => Map<string, string>;
 export declare const patchRequestMessagesReasoning: (request: any, reasoningMap?: Map<string, string>) => void;
+export declare const patchRequestModelKwargs: (request: any, modelKwargs?: Record<string, any>) => void;
 export declare class ReasoningChatOpenAI extends ChatOpenAICompletions {
     _generate(messages: BaseMessage[], options: any, runManager?: any): Promise<import("@langchain/core/dist/outputs").ChatResult>;
     _streamResponseChunks(messages: BaseMessage[], options: any, runManager?: any): AsyncGenerator<import("@langchain/core/dist/outputs").ChatGenerationChunk, void, unknown>;

package/dist/server/llm-providers/common/reasoning.js

@@ -26,15 +26,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var reasoning_exports = {};
 __export(reasoning_exports, {
+  MODEL_KWARGS_KEY: () => MODEL_KWARGS_KEY,
   REASONING_MAP_KEY: () => REASONING_MAP_KEY,
   ReasoningChatOpenAI: () => ReasoningChatOpenAI,
   collectReasoningMap: () => collectReasoningMap,
-  patchRequestMessagesReasoning: () => patchRequestMessagesReasoning
+  patchRequestMessagesReasoning: () => patchRequestMessagesReasoning,
+  patchRequestModelKwargs: () => patchRequestModelKwargs
 });
 module.exports = __toCommonJS(reasoning_exports);
 var import_messages = require("@langchain/core/messages");
 var import_openai = require("@langchain/openai");
 const REASONING_MAP_KEY = "__nb_reasoning_map";
+const MODEL_KWARGS_KEY = "__nb_model_kwargs";
 const collectReasoningMap = (messages) => {
   var _a;
   const reasoningMap = /* @__PURE__ */ new Map();
@@ -69,6 +72,12 @@ const patchRequestMessagesReasoning = (request, reasoningMap) => {
     }
   }
 };
+const patchRequestModelKwargs = (request, modelKwargs) => {
+  if (!modelKwargs || typeof modelKwargs !== "object") {
+    return;
+  }
+  Object.assign(request, modelKwargs);
+};
 class ReasoningChatOpenAI extends import_openai.ChatOpenAICompletions {
   async _generate(messages, options, runManager) {
     const reasoningMap = collectReasoningMap(messages);
@@ -108,7 +117,9 @@ class ReasoningChatOpenAI extends import_openai.ChatOpenAICompletions {
   }
   async completionWithRetry(request, requestOptions) {
     const reasoningMap = requestOptions == null ? void 0 : requestOptions[REASONING_MAP_KEY];
+    const modelKwargs = requestOptions == null ? void 0 : requestOptions[MODEL_KWARGS_KEY];
     patchRequestMessagesReasoning(request, reasoningMap);
+    patchRequestModelKwargs(request, modelKwargs);
     if (request.stream) {
       return super.completionWithRetry(request, requestOptions);
     }
@@ -117,8 +128,10 @@ class ReasoningChatOpenAI extends import_openai.ChatOpenAICompletions {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MODEL_KWARGS_KEY,
   REASONING_MAP_KEY,
   ReasoningChatOpenAI,
   collectReasoningMap,
-  patchRequestMessagesReasoning
+  patchRequestMessagesReasoning,
+  patchRequestModelKwargs
 });

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

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

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

@@ -41,6 +41,7 @@ __export(dashscope_exports, {
   dashscopeProviderOptions: () => dashscopeProviderOptions
 });
 module.exports = __toCommonJS(dashscope_exports);
+var import_messages = require("@langchain/core/messages");
 var import_openai = require("@langchain/openai");
 var import_provider = require("./provider");
 var import_ai_manager = require("../manager/ai-manager");
@@ -94,6 +95,44 @@ class DashscopeProvider extends import_provider.LLMProvider {
       return toolDefinitions;
     }
   }
+  getModelRequestBuilder(model) {
+    if (!/^qwen-mt-/i.test(model || "")) {
+      return null;
+    }
+    return ({ context, options }) => {
+      var _a, _b;
+      const { sourceText, sourceLang, targetLang, terms } = (options == null ? void 0 : options.modelRequestParams) || {};
+      if (!sourceText || !sourceLang || !targetLang) {
+        return {
+          context,
+          options
+        };
+      }
+      (_b = this.app.logger) == null ? void 0 : _b.debug("Dashscope Qwen-MT model request builder matched", {
+        model: (_a = this.modelOptions) == null ? void 0 : _a.model,
+        sourceTextLength: (sourceText == null ? void 0 : sourceText.length) ?? 0,
+        sourceLang,
+        targetLang,
+        terms: Array.isArray(terms) ? terms.length : 0
+      });
+      return {
+        context: {
+          messages: [new import_messages.HumanMessage(sourceText)]
+        },
+        options: {
+          ...options,
+          modelKwargs: {
+            ...(options == null ? void 0 : options.modelKwargs) || {},
+            translation_options: {
+              source_lang: sourceLang,
+              target_lang: targetLang,
+              ...Array.isArray(terms) && terms.length ? { terms } : {}
+            }
+          }
+        }
+      };
+    };
+  }
   parseResponseMessage(message) {
     var _a;
     const result = super.parseResponseMessage(message);

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

@@ -64,7 +64,9 @@ class ReasoningDeepSeek extends import_deepseek.ChatDeepSeek {
   }
   async completionWithRetry(request, requestOptions) {
     const reasoningMap = requestOptions == null ? void 0 : requestOptions[import_reasoning.REASONING_MAP_KEY];
+    const modelKwargs = requestOptions == null ? void 0 : requestOptions[import_reasoning.MODEL_KWARGS_KEY];
     (0, import_reasoning.patchRequestMessagesReasoning)(request, reasoningMap);
+    (0, import_reasoning.patchRequestModelKwargs)(request, modelKwargs);
     if (request.stream) {
       return super.completionWithRetry(request, requestOptions);
     }

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

@@ -22,6 +22,19 @@ export type ParsedAttachmentResult = {
     placement: string;
     content: any;
 };
+export type LLMProviderInvokeOptions = {
+    modelKwargs?: Record<string, any>;
+    modelRequestParams?: Record<string, any>;
+    [key: string]: any;
+};
+export type LLMModelRequestBuilderResult = {
+    context: AIChatContext;
+    options?: LLMProviderInvokeOptions;
+};
+export type LLMModelRequestBuilder = (input: {
+    context: AIChatContext;
+    options?: LLMProviderInvokeOptions;
+}) => LLMModelRequestBuilderResult;
 export interface LLMProviderOptions {
     app: Application;
     serviceOptions?: Record<string, any>;
@@ -35,8 +48,9 @@ export declare abstract class LLMProvider {
     abstract createModel(): BaseChatModel | any;
     get baseURL(): string | null;
     constructor(opts: LLMProviderOptions);
+    protected getModelRequestBuilder(_model?: string): LLMModelRequestBuilder | null;
     prepareChain(context: AIChatContext): any;
-    invoke(context: AIChatContext, options?: any): Promise<any>;
+    invoke(context: AIChatContext, options?: LLMProviderInvokeOptions): Promise<any>;
     stream(context: AIChatContext, options?: any): Promise<any>;
     listModels(): Promise<{
         models?: {

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

@@ -45,6 +45,7 @@ var import_utils = require("../utils");
 var import_stream = require("@langchain/core/utils/stream");
 var import_document_loader = require("../document-loader");
 var import_node_path = __toESM(require("node:path"));
+var import_reasoning = require("./common/reasoning");
 class LLMProvider {
   app;
   serviceOptions;
@@ -62,6 +63,9 @@ class LLMProvider {
       this.chatModel = this.createModel();
     }
   }
+  getModelRequestBuilder(_model) {
+    return null;
+  }
   prepareChain(context) {
     var _a, _b, _c, _d;
     let chain = this.chatModel;
@@ -84,8 +88,23 @@ class LLMProvider {
     return chain;
   }
   async invoke(context, options) {
-    const chain = this.prepareChain(context);
-    return chain.invoke(context.messages, options);
+    var _a;
+    const builder = this.getModelRequestBuilder((_a = this.modelOptions) == null ? void 0 : _a.model);
+    const request = (builder == null ? void 0 : builder({ context, options })) || { context, options };
+    const chain = this.prepareChain(request.context);
+    const { modelKwargs, modelRequestParams, options: requestOptions, ...restOptions } = request.options || {};
+    const invokeOptions = modelKwargs ? {
+      ...restOptions,
+      [import_reasoning.MODEL_KWARGS_KEY]: modelKwargs,
+      options: {
+        ...requestOptions || {},
+        [import_reasoning.MODEL_KWARGS_KEY]: modelKwargs
+      }
+    } : {
+      ...restOptions,
+      ...requestOptions ? { options: requestOptions } : {}
+    };
+    return chain.invoke(request.context.messages, invokeOptions);
   }
   async stream(context, options) {
     const chain = this.prepareChain(context);

package/dist/server/manager/ai-chat-conversation.js

@@ -138,11 +138,10 @@ class AIChatConversationImpl {
       formatMessages
     } = options ?? {};
     let messages = userMessages ? await (formatMessages == null ? void 0 : formatMessages(userMessages)) ?? [] : void 0;
-    const additionSystemPrompt = messages == null ? void 0 : messages.filter((it) => it.role === "system").map((it) => it.content).join("\n");
+    const additionSystemPrompt = messages == null ? void 0 : messages.filter((it) => it.role === "system").map((it) => it.content).filter(Boolean).join("\n");
     messages = messages == null ? void 0 : messages.filter((it) => it.role !== "system");
-    const systemPrompt = `${await (getSystemPrompt == null ? void 0 : getSystemPrompt(userMessages ?? [])) ?? ""}
-
-${additionSystemPrompt}`;
+    const baseSystemPrompt = await (getSystemPrompt == null ? void 0 : getSystemPrompt(userMessages ?? []));
+    const systemPrompt = [baseSystemPrompt, additionSystemPrompt].filter(Boolean).join("\n\n") || void 0;
     const chatContext = {
       systemPrompt,
       messages,

package/dist/server/manager/ai-manager.d.ts

@@ -26,6 +26,19 @@ export type LLMModelOptions = {
     model: string;
     webSearch?: boolean;
 };
+export type EnabledLLMModel = {
+    label: string;
+    value: string;
+};
+export type EnabledLLMService = {
+    llmService: string;
+    llmServiceTitle: string;
+    provider: string;
+    providerTitle?: string;
+    enabledModels: EnabledLLMModel[];
+    supportWebSearch: boolean;
+    isToolConflict: boolean;
+};
 export declare class AIManager {
     protected plugin: PluginAIServer;
     llmProviders: Map<string, LLMProviderMeta>;
@@ -39,6 +52,10 @@ export declare class AIManager {
         supportWebSearch: boolean;
     }[];
     getSupportedProvider(model: SupportedModel): string[];
+    listAllEnabledModels(): Promise<EnabledLLMService[]>;
+    resolveModel(model?: LLMModelOptions | null): Promise<LLMModelOptions>;
+    private toEnabledLLMService;
+    private getEnabledModels;
     getLLMService(options: LLMModelOptions): Promise<{
         provider: LLMProvider;
         model: string;

package/dist/server/manager/ai-manager.js

@@ -31,6 +31,7 @@ __export(ai_manager_exports, {
 });
 module.exports = __toCommonJS(ai_manager_exports);
 var import_tool_manager = require("./tool-manager");
+var import_recommended_models = require("../../common/recommended-models");
 var SupportedModel = /* @__PURE__ */ ((SupportedModel2) => {
   SupportedModel2["LLM"] = "LLM";
   SupportedModel2["EMBEDDING"] = "EMBEDDING";
@@ -57,6 +58,70 @@ class AIManager {
   getSupportedProvider(model) {
     return Array.from(this.llmProviders.entries()).filter(([_2, { supportedModel }]) => supportedModel && supportedModel.includes(model)).map(([name]) => name);
   }
+  async listAllEnabledModels() {
+    const services = await this.plugin.db.getRepository("llmServices").find({ sort: "sort" });
+    return services.filter((service) => service.enabled !== false).map((service) => this.toEnabledLLMService(service)).filter(Boolean);
+  }
+  async resolveModel(model) {
+    var _a;
+    if ((model == null ? void 0 : model.llmService) && (model == null ? void 0 : model.model)) {
+      return model;
+    }
+    const services = await this.listAllEnabledModels();
+    const service = services.find((service2) => service2.enabledModels.length);
+    const firstModel = (_a = service == null ? void 0 : service.enabledModels[0]) == null ? void 0 : _a.value;
+    if ((service == null ? void 0 : service.llmService) && firstModel) {
+      return {
+        llmService: service.llmService,
+        model: firstModel
+      };
+    }
+    throw new Error("LLM service not configured");
+  }
+  toEnabledLLMService(service) {
+    var _a, _b, _c;
+    const provider = ((_a = service.get) == null ? void 0 : _a.call(service, "provider")) || service.provider;
+    const providerMeta = this.llmProviders.get(provider);
+    if (!providerMeta) {
+      return null;
+    }
+    const enabledModels = this.getEnabledModels(service);
+    if (!enabledModels.length) {
+      return null;
+    }
+    const Provider = providerMeta.provider;
+    const providerClient = new Provider({ app: this.plugin.app });
+    return {
+      llmService: ((_b = service.get) == null ? void 0 : _b.call(service, "name")) || service.name,
+      llmServiceTitle: ((_c = service.get) == null ? void 0 : _c.call(service, "title")) || service.title,
+      provider,
+      providerTitle: providerMeta.title,
+      enabledModels,
+      supportWebSearch: providerMeta.supportWebSearch ?? false,
+      isToolConflict: providerClient.isToolConflict()
+    };
+  }
+  getEnabledModels(service) {
+    var _a, _b;
+    const provider = ((_a = service.get) == null ? void 0 : _a.call(service, "provider")) || service.provider;
+    const raw = ((_b = service.get) == null ? void 0 : _b.call(service, "enabledModels")) || service.enabledModels;
+    if (raw && typeof raw === "object" && !Array.isArray(raw) && raw.mode) {
+      if (raw.mode === "recommended") {
+        return (0, import_recommended_models.getRecommendedModels)(provider);
+      }
+      return (raw.models || []).filter((model) => model.value).map((model) => ({
+        label: model.label || model.value,
+        value: model.value
+      }));
+    }
+    if (Array.isArray(raw)) {
+      if (!raw.length) {
+        return (0, import_recommended_models.getRecommendedModels)(provider);
+      }
+      return raw.map((id) => ({ label: id, value: id }));
+    }
+    return (0, import_recommended_models.getRecommendedModels)(provider);
+  }
   async getLLMService(options) {
     const { llmService, model, webSearch } = options ?? {};
     if (!llmService || !model) {

package/dist/server/manager/llm-stream-manager.d.ts

@@ -7,6 +7,11 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import PluginAIServer from '../plugin';
+type LLMStreamOptions = {
+    pollInterval?: number;
+    initialWaitTimeout?: number;
+    signal?: AbortSignal;
+};
 export declare class LLMStreamCachedManager {
     private readonly plugin;
     private cachePromise?;
@@ -14,14 +19,10 @@ export declare class LLMStreamCachedManager {
     getCached(sessionId: string): LLMStreamCached;
     clear(sessionId: string): Promise<void>;
     append(sessionId: string, chunk: string): Promise<void>;
-    stream(sessionId: string, options?: {
-        pollInterval?: number;
-        initialWaitTimeout?: number;
-    }): AsyncGenerator<string, void, void>;
+    stream(sessionId: string, options?: LLMStreamOptions): AsyncGenerator<string, void, void>;
     private getChunks;
     private getCache;
-    private withLock;
-    private getLockKey;
+    private get store();
 }
 export declare class LLMStreamCached {
     private readonly sessionId;
@@ -30,8 +31,13 @@ export declare class LLMStreamCached {
     clear(): Promise<void>;
     append(chunk: string): Promise<void>;
     skipped(): Promise<void>;
-    stream(options?: {
-        pollInterval?: number;
-        initialWaitTimeout?: number;
-    }): AsyncGenerator<string, void, void>;
+    stream(options?: LLMStreamOptions): AsyncGenerator<string, void, void>;
 }
+export declare class BufferedLLMStreamCached extends LLMStreamCached {
+    private buffer;
+    private interval;
+    clear(): Promise<void>;
+    append(chunk: string): Promise<void>;
+    private flush;
+}
+export {};

package/dist/server/manager/llm-stream-manager.js

@@ -26,54 +26,59 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var llm_stream_manager_exports = {};
 __export(llm_stream_manager_exports, {
+  BufferedLLMStreamCached: () => BufferedLLMStreamCached,
   LLMStreamCached: () => LLMStreamCached,
   LLMStreamCachedManager: () => LLMStreamCachedManager
 });
 module.exports = __toCommonJS(llm_stream_manager_exports);
-var import_utils = require("@nocobase/utils");
 const CACHE_NAME = "ai-llm-stream-cache";
-const LOCK_KEY_PREFIX = "ai-llm-stream-lock";
-const WRITE_LOCK_TTL = 3e3;
 const CACHE_TTL = 10 * 60 * 1e3;
 const STREAM_END_MARK = '"type":"stream_end"';
 const SKIPPED_MARK = "__skipped__";
-const DEFAULT_POLL_INTERVAL = 50;
-const DEFAULT_INITIAL_WAIT_TIMEOUT = 1e3;
+const DEFAULT_INITIAL_WAIT_TIMEOUT = 1e4;
 class LLMStreamCachedManager {
   constructor(plugin) {
     this.plugin = plugin;
   }
   cachePromise;
   getCached(sessionId) {
+    if (this.store !== "memory") {
+      return new BufferedLLMStreamCached(sessionId, this);
+    }
     return new LLMStreamCached(sessionId, this);
   }
   async clear(sessionId) {
-    await this.withLock(sessionId, async () => {
-      const cache = await this.getCache();
-      await cache.del(sessionId);
-    });
+    const cache = await this.getCache();
+    await cache.del(sessionId);
   }
   async append(sessionId, chunk) {
-    await this.withLock(sessionId, async () => {
-      const cache = await this.getCache();
-      const chunks = await cache.get(sessionId) ?? [];
-      chunks.push(chunk);
-      await cache.set(sessionId, chunks, CACHE_TTL);
-    });
+    const cache = await this.getCache();
+    const chunks = await cache.get(sessionId) ?? [];
+    chunks.push(chunk);
+    await cache.set(sessionId, chunks, CACHE_TTL);
   }
   async *stream(sessionId, options) {
-    const pollInterval = (options == null ? void 0 : options.pollInterval) ?? DEFAULT_POLL_INTERVAL;
+    const pollInterval = (options == null ? void 0 : options.pollInterval) ?? (this.store !== "memory" ? 1e3 : 100);
     const initialWaitTimeout = (options == null ? void 0 : options.initialWaitTimeout) ?? DEFAULT_INITIAL_WAIT_TIMEOUT;
+    const signal = options == null ? void 0 : options.signal;
     let offset = 0;
     let waited = 0;
     let completed = false;
     while (!completed) {
+      if (signal == null ? void 0 : signal.aborted) {
+        return;
+      }
       const chunks = await this.getChunks(sessionId);
       const lastSkippedIndex = chunks.lastIndexOf(SKIPPED_MARK);
+      let hasNewChunks = false;
       if (lastSkippedIndex >= offset) {
         offset = lastSkippedIndex + 1;
       }
       while (offset < chunks.length) {
+        if (signal == null ? void 0 : signal.aborted) {
+          return;
+        }
+        hasNewChunks = true;
         const chunk = chunks[offset++];
         yield chunk;
         waited = 0;
@@ -85,16 +90,15 @@ class LLMStreamCachedManager {
       if (completed) {
         return;
       }
-      if (!chunks.length) {
-        if (offset > 0) {
-          return;
-        }
+      if (!hasNewChunks) {
         if (waited >= initialWaitTimeout) {
           return;
         }
         waited += pollInterval;
       }
-      await (0, import_utils.sleep)(pollInterval);
+      if (await abortableSleep(pollInterval, signal)) {
+        return;
+      }
     }
   }
   async getChunks(sessionId) {
@@ -104,15 +108,13 @@ class LLMStreamCachedManager {
   async getCache() {
     this.cachePromise ??= this.plugin.app.cacheManager.createCache({
       name: CACHE_NAME,
-      store: this.plugin.app.cacheManager.defaultStore
+      store: this.store
     });
     return this.cachePromise;
   }
-  async withLock(sessionId, fn) {
-    return await this.plugin.app.lockManager.runExclusive(this.getLockKey(sessionId), fn, WRITE_LOCK_TTL);
-  }
-  getLockKey(sessionId) {
-    return `${LOCK_KEY_PREFIX}:${sessionId}`;
+  get store() {
+    var _a;
+    return ((_a = this.plugin.app.options.cacheManager) == null ? void 0 : _a.defaultStore) ?? "memory";
   }
 }
 class LLMStreamCached {
@@ -135,8 +137,100 @@ class LLMStreamCached {
     }
   }
 }
+class BufferedLLMStreamCached extends LLMStreamCached {
+  buffer = new ChunksBuffer();
+  interval;
+  async clear() {
+    clearInterval(this.interval);
+    delete this.interval;
+    await this.flush();
+    await super.clear();
+  }
+  async append(chunk) {
+    if (!this.interval) {
+      this.interval = setInterval(() => {
+        void this.flush();
+      }, 1e3);
+    }
+    this.buffer.append(chunk);
+  }
+  async flush() {
+    if (this.buffer.isEmpty()) {
+      return;
+    }
+    const chunks = this.buffer.compact();
+    this.buffer.clear();
+    const appendChunks = async () => {
+      for (const chunk of chunks) {
+        await super.append(chunk);
+      }
+    };
+    await appendChunks();
+  }
+}
+class ChunksBuffer {
+  _size = 0;
+  _chunks = [];
+  append(chunk) {
+    this._size += chunk.length;
+    this._chunks.push(chunk);
+  }
+  clear() {
+    this._size = 0;
+    this._chunks = [];
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  get size() {
+    return this._size;
+  }
+  get chunks() {
+    return this._chunks;
+  }
+  compact() {
+    const chunks = [];
+    let buffer = "";
+    for (const chunk of this._chunks) {
+      if (chunk === SKIPPED_MARK) {
+        if (buffer) {
+          chunks.push(buffer);
+          buffer = "";
+        }
+        chunks.push(SKIPPED_MARK);
+      } else {
+        buffer += chunk;
+      }
+    }
+    if (buffer) {
+      chunks.push(buffer);
+    }
+    return chunks;
+  }
+}
+function abortableSleep(ms, signal) {
+  if (signal == null ? void 0 : signal.aborted) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve(false);
+    }, ms);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      signal == null ? void 0 : signal.removeEventListener("abort", abort);
+    };
+    const abort = () => {
+      cleanup();
+      resolve(true);
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", abort, { once: true });
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BufferedLLMStreamCached,
   LLMStreamCached,
   LLMStreamCachedManager
 });

package/dist/server/migrations/20260407170416-ai-employee-knowledge-base-add-key.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}