@nocobase/plugin-ai 2.1.0-alpha.33 → 2.1.0-alpha.35

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

@@ -0,0 +1,236 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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);
+const CACHE_NAME = "ai-llm-stream-cache";
+const CACHE_TTL = 10 * 60 * 1e3;
+const STREAM_END_MARK = '"type":"stream_end"';
+const SKIPPED_MARK = "__skipped__";
+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) {
+    const cache = await this.getCache();
+    await cache.del(sessionId);
+  }
+  async append(sessionId, chunk) {
+    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) ?? (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;
+        if (chunk.includes(STREAM_END_MARK)) {
+          completed = true;
+          break;
+        }
+      }
+      if (completed) {
+        return;
+      }
+      if (!hasNewChunks) {
+        if (waited >= initialWaitTimeout) {
+          return;
+        }
+        waited += pollInterval;
+      }
+      if (await abortableSleep(pollInterval, signal)) {
+        return;
+      }
+    }
+  }
+  async getChunks(sessionId) {
+    const cache = await this.getCache();
+    return await cache.get(sessionId) ?? [];
+  }
+  async getCache() {
+    this.cachePromise ??= this.plugin.app.cacheManager.createCache({
+      name: CACHE_NAME,
+      store: this.store
+    });
+    return this.cachePromise;
+  }
+  get store() {
+    var _a;
+    return ((_a = this.plugin.app.options.cacheManager) == null ? void 0 : _a.defaultStore) ?? "memory";
+  }
+}
+class LLMStreamCached {
+  constructor(sessionId, manager) {
+    this.sessionId = sessionId;
+    this.manager = manager;
+  }
+  async clear() {
+    await this.manager.clear(this.sessionId);
+  }
+  async append(chunk) {
+    await this.manager.append(this.sessionId, chunk);
+  }
+  async skipped() {
+    await this.append(SKIPPED_MARK);
+  }
+  async *stream(options) {
+    for await (const chunk of this.manager.stream(this.sessionId, options)) {
+      yield chunk;
+    }
+  }
+}
+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>;
+}

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

@@ -0,0 +1,61 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_employee_knowledge_base_add_key_exports = {};
+__export(ai_employee_knowledge_base_add_key_exports, {
+  default: () => ai_employee_knowledge_base_add_key_default
+});
+module.exports = __toCommonJS(ai_employee_knowledge_base_add_key_exports);
+var import_server = require("@nocobase/server");
+class ai_employee_knowledge_base_add_key_default extends import_server.Migration {
+  on = "afterSync";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<2.1.0";
+  async up() {
+    var _a, _b, _c, _d;
+    const aiEmployeesRepo = this.app.db.getRepository("aiEmployees");
+    const aiEmployeeList = await aiEmployeesRepo.find();
+    for (const item of aiEmployeeList) {
+      if (!((_b = (_a = item.knowledgeBase) == null ? void 0 : _a.knowledgeBaseIds) == null ? void 0 : _b.length)) {
+        continue;
+      }
+      if ((_d = (_c = item.knowledgeBase) == null ? void 0 : _c.knowledgeBaseKeys) == null ? void 0 : _d.length) {
+        continue;
+      }
+      await aiEmployeesRepo.update({
+        values: {
+          knowledgeBase: {
+            ...item.knowledgeBase,
+            knowledgeBaseKeys: item.knowledgeBase.knowledgeBaseIds.map((it) => String(it))
+          }
+        },
+        filter: {
+          username: item.username
+        }
+      });
+    }
+  }
+}

package/dist/server/plugin.d.ts

@@ -20,11 +20,13 @@ import { DocumentLoaders } from './document-loader';
 import type PluginFileManagerServer from '@nocobase/plugin-file-manager';
 import { SubAgentsDispatcher } from './ai-employees/sub-agents';
 import { KnowledgeBaseManager } from './ai-employees/ai-knowledge-base';
+import { LLMStreamCachedManager } from './manager/llm-stream-manager';
 export declare class PluginAIServer extends Plugin {
     features: AIPluginFeatureManagerImpl;
     aiManager: AIManager;
     aiEmployeesManager: AIEmployeesManager;
     aiConversationsManager: AIConversationsManager;
+    llmStreamCachedManager: LLMStreamCachedManager;
     builtInManager: BuiltInManager;
     aiContextDatasourceManager: AIContextDatasourceManager;
     aiCodingManager: AICodingManager;

package/dist/server/plugin.js

@@ -77,11 +77,13 @@ var import_mimo = require("./llm-providers/mimo");
 var import_sub_agents = require("./ai-employees/sub-agents");
 var import_employee = require("./workflow/nodes/employee");
 var import_ai_knowledge_base = require("./ai-employees/ai-knowledge-base");
+var import_llm_stream_manager = require("./manager/llm-stream-manager");
 class PluginAIServer extends import_server.Plugin {
   features = new import_ai_feature_manager.AIPluginFeatureManagerImpl();
   aiManager = new import_ai_manager.AIManager(this);
   aiEmployeesManager = new import_ai_employees_manager.AIEmployeesManager(this);
   aiConversationsManager = new import_ai_conversations.AIConversationsManager(this);
+  llmStreamCachedManager = new import_llm_stream_manager.LLMStreamCachedManager(this);
   builtInManager = new import_built_in_manager.BuiltInManager(this);
   aiContextDatasourceManager = new import_ai_context_datasource_manager.AIContextDatasourceManager(this);
   aiCodingManager = new import_ai_coding_manager.AICodingManager(this);
@@ -135,6 +137,7 @@ class PluginAIServer extends import_server.Plugin {
     this.registerWorkflow();
     this.registerWorkContextResolveStrategy();
     (0, import_employee.registerAIEmployeeTaskNotification)(this);
+    (0, import_ai_conversations.registerAIConversationReadNotification)(this);
     (0, import_employee.registerOnJobAbortedHandler)(this);
   }
   registerLLMProviders() {

package/dist/server/resource/ai.js

@@ -40,7 +40,6 @@ __export(ai_exports, {
 });
 module.exports = __toCommonJS(ai_exports);
 var import_lodash = __toESM(require("lodash"));
-var import_recommended_models = require("../../common/recommended-models");
 const aiResource = {
   name: "ai",
   actions: {
@@ -157,46 +156,7 @@ const aiResource = {
     },
     listAllEnabledModels: async (ctx, next) => {
       const plugin = ctx.app.pm.get("ai");
-      const services = await ctx.db.getRepository("llmServices").find({ sort: "sort" });
-      const llmServices = services.filter((service) => service.enabled !== false).map((service) => {
-        const raw = service.enabledModels;
-        let enabledModels;
-        if (raw && typeof raw === "object" && !Array.isArray(raw) && raw.mode) {
-          if (raw.mode === "recommended") {
-            enabledModels = (0, import_recommended_models.getRecommendedModels)(service.provider);
-          } else {
-            enabledModels = (raw.models || []).filter((m) => m.value).map((m) => ({
-              label: m.label || m.value,
-              value: m.value
-            }));
-          }
-        } else if (Array.isArray(raw)) {
-          if (raw.length === 0) {
-            enabledModels = (0, import_recommended_models.getRecommendedModels)(service.provider);
-          } else {
-            enabledModels = raw.map((id) => ({ label: id, value: id }));
-          }
-        } else {
-          enabledModels = (0, import_recommended_models.getRecommendedModels)(service.provider);
-        }
-        if (enabledModels.length === 0) {
-          return null;
-        }
-        const providerMeta = plugin.aiManager.llmProviders.get(service.provider);
-        const P = providerMeta.provider;
-        const p = new P({ app: ctx.app });
-        const isToolConflict = p.isToolConflict();
-        return {
-          llmService: service.name,
-          llmServiceTitle: service.title,
-          provider: service.provider,
-          providerTitle: providerMeta == null ? void 0 : providerMeta.title,
-          enabledModels,
-          supportWebSearch: (providerMeta == null ? void 0 : providerMeta.supportWebSearch) ?? false,
-          isToolConflict
-        };
-      }).filter(Boolean);
-      ctx.body = llmServices;
+      ctx.body = await plugin.aiManager.listAllEnabledModels();
       await next();
     }
   }

package/dist/server/resource/aiConversations.d.ts

@@ -7,20 +7,27 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Context, Next } from '@nocobase/actions';
+declare function loginInCheck(ctx: Context, next: Next): Promise<never>;
 declare const _default: {
     name: string;
+    middlewares: {
+        handler: typeof loginInCheck;
+    }[];
     actions: {
         list(ctx: Context, next: Next): Promise<void>;
-        create(ctx: Context, next: Next): Promise<never>;
-        update(ctx: Context, next: Next): Promise<never>;
+        unreadCount(ctx: Context, next: Next): Promise<void>;
+        unreadCounts(ctx: Context, next: Next): Promise<void>;
+        create(ctx: Context, next: Next): Promise<void>;
+        update(ctx: Context, next: Next): Promise<void>;
         updateOptions(ctx: Context, next: Next): Promise<never>;
         destroy(ctx: Context, next: Next): Promise<void>;
-        getMessages(ctx: Context, next: Next): Promise<never>;
+        getMessages(ctx: Context, next: Next): Promise<void>;
         updateToolArgs(ctx: Context, next: Next): Promise<any>;
-        sendMessages(ctx: Context, next: Next): Promise<any>;
-        abort(ctx: Context, next: Next): Promise<never>;
-        resendMessages(ctx: Context, next: Next): Promise<any>;
-        updateUserDecision(ctx: Context, next: Next): Promise<never>;
+        sendMessages(ctx: Context, next: Next): Promise<void>;
+        abort(ctx: Context, next: Next): Promise<void>;
+        resumeStream(ctx: Context, next: Next): Promise<void>;
+        resendMessages(ctx: Context, next: Next): Promise<void>;
+        updateUserDecision(ctx: Context, next: Next): Promise<void>;
         resumeToolCall(ctx: Context, next: Next): Promise<any>;
     };
 };