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

package/dist/server/attachments.js

@@ -0,0 +1,204 @@
+/**
+ * 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 attachments_exports = {};
+__export(attachments_exports, {
+  appendAIFileAttachmentSource: () => appendAIFileAttachmentSource,
+  findMessageAttachments: () => findMessageAttachments,
+  getAttachmentId: () => getAttachmentId,
+  getAttachmentSource: () => getAttachmentSource,
+  getMessageAttachmentLookupKey: () => getMessageAttachmentLookupKey,
+  shouldSkipAttachmentSourceLookup: () => shouldSkipAttachmentSourceLookup
+});
+module.exports = __toCommonJS(attachments_exports);
+const AI_FILES_ATTACHMENT_SOURCE = {
+  dataSourceKey: "main",
+  collectionName: "aiFiles"
+};
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function appendSourceToAttachmentRecord(record) {
+  if (!isRecord(record)) {
+    return;
+  }
+  const meta = {
+    ...isRecord(record.meta) ? record.meta : {},
+    source: AI_FILES_ATTACHMENT_SOURCE
+  };
+  if (typeof record.set === "function") {
+    const model = record;
+    model.set("meta", meta);
+    model.dataValues.meta = meta;
+    return;
+  }
+  record.meta = meta;
+}
+function appendAIFileAttachmentSource(body) {
+  if (!isRecord(body)) {
+    return;
+  }
+  if (body.data) {
+    appendSourceToAttachmentRecord(body.data);
+    return;
+  }
+  appendSourceToAttachmentRecord(body);
+}
+function getAttachmentId(attachment) {
+  if (!isRecord(attachment)) {
+    return null;
+  }
+  const id = attachment.id ?? attachment.filterByTk;
+  if (typeof id === "string" || typeof id === "number") {
+    return id;
+  }
+  return null;
+}
+function shouldSkipAttachmentSourceLookup(source) {
+  return (source == null ? void 0 : source.trustworthy) === true;
+}
+function getAttachmentSource(attachment) {
+  if (!isRecord(attachment) || !isRecord(attachment.source)) {
+    return null;
+  }
+  const { dataSourceKey, collectionName, field, documentCache, trustworthy } = attachment.source;
+  const source = {
+    dataSourceKey: typeof dataSourceKey === "string" && dataSourceKey ? dataSourceKey : "main",
+    ...typeof collectionName === "string" && collectionName ? { collectionName } : {},
+    ...typeof field === "string" ? { field } : {},
+    ...typeof documentCache === "boolean" ? { documentCache } : {},
+    ...trustworthy === true ? { trustworthy } : {}
+  };
+  if (!source.trustworthy && !source.collectionName) {
+    return null;
+  }
+  return source;
+}
+function getSourceDatabase(ctx, dataSourceKey) {
+  var _a, _b, _c;
+  if (!dataSourceKey || dataSourceKey === "main") {
+    return ctx.db;
+  }
+  const dataSource = (_b = (_a = ctx.app.dataSourceManager) == null ? void 0 : _a.dataSources) == null ? void 0 : _b.get(dataSourceKey);
+  return ((_c = dataSource == null ? void 0 : dataSource.collectionManager) == null ? void 0 : _c.db) ?? null;
+}
+function getLookupKey(lookup) {
+  const dataSourceKey = lookup.source.dataSourceKey || "main";
+  const collectionName = lookup.source.collectionName;
+  return `${dataSourceKey}:${collectionName}:${lookup.id}`;
+}
+function isValidFileCollectionSource(db, lookup) {
+  var _a, _b, _c;
+  const collectionName = lookup.source.collectionName;
+  const collection = db.getCollection(collectionName);
+  if (((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.template) !== "file") {
+    return false;
+  }
+  if (collectionName === "aiFiles") {
+    return true;
+  }
+  if (!lookup.source.field) {
+    return false;
+  }
+  return ((_c = (_b = db.getFieldByPath(lookup.source.field)) == null ? void 0 : _b.options) == null ? void 0 : _c.target) === collectionName;
+}
+async function findSourceAttachments(ctx, lookups) {
+  var _a;
+  const attachmentsByLookup = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  for (const lookup of lookups) {
+    const dataSourceKey = lookup.source.dataSourceKey || "main";
+    const collectionName = lookup.source.collectionName;
+    const groupKey = `${dataSourceKey}:${collectionName}`;
+    groups.set(groupKey, [...groups.get(groupKey) ?? [], lookup]);
+  }
+  for (const [groupKey, groupLookups] of groups.entries()) {
+    const [dataSourceKey, collectionName] = groupKey.split(":");
+    const db = getSourceDatabase(ctx, dataSourceKey);
+    if (!db) {
+      continue;
+    }
+    const validLookups = groupLookups.filter((lookup) => isValidFileCollectionSource(db, lookup));
+    if (!validLookups.length) {
+      continue;
+    }
+    const filter = {
+      id: {
+        $in: [...new Set(validLookups.map((lookup) => lookup.id))]
+      }
+    };
+    if (collectionName === "aiFiles") {
+      filter.createdById = (_a = ctx.auth) == null ? void 0 : _a.user.id;
+    }
+    const records = await db.getRepository(collectionName).find({ filter });
+    for (const record of records) {
+      const attachment = record.toJSON();
+      attachmentsByLookup.set(`${dataSourceKey}:${collectionName}:${attachment.id}`, attachment);
+    }
+  }
+  return attachmentsByLookup;
+}
+async function findMessageAttachments(ctx, attachments) {
+  const lookups = [];
+  for (const attachment of attachments) {
+    const source = getAttachmentSource(attachment);
+    if (!source || shouldSkipAttachmentSourceLookup(source)) {
+      continue;
+    }
+    const id = getAttachmentId(attachment);
+    if (id == null) {
+      continue;
+    }
+    lookups.push({
+      id,
+      source
+    });
+  }
+  return findSourceAttachments(ctx, lookups);
+}
+function getMessageAttachmentLookupKey(attachment) {
+  const source = getAttachmentSource(attachment);
+  if (!source || shouldSkipAttachmentSourceLookup(source)) {
+    return null;
+  }
+  const id = getAttachmentId(attachment);
+  if (id == null) {
+    return null;
+  }
+  return getLookupKey({
+    id,
+    source
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendAIFileAttachmentSource,
+  findMessageAttachments,
+  getAttachmentId,
+  getAttachmentSource,
+  getMessageAttachmentLookupKey,
+  shouldSkipAttachmentSourceLookup
+});

package/dist/server/collections/ai-usage-events.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+declare const _default: import("@nocobase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/ai-usage-events.js

@@ -0,0 +1,183 @@
+/**
+ * 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_usage_events_exports = {};
+__export(ai_usage_events_exports, {
+  default: () => ai_usage_events_default
+});
+module.exports = __toCommonJS(ai_usage_events_exports);
+var import_database = require("@nocobase/database");
+var ai_usage_events_default = (0, import_database.defineCollection)({
+  migrationRules: ["schema-only"],
+  name: "aiUsageEvents",
+  dataCategory: "business",
+  timestamps: false,
+  createdAt: false,
+  updatedAt: false,
+  createdBy: false,
+  updatedBy: false,
+  fields: [
+    {
+      name: "occurredAt",
+      type: "unixTimestamp",
+      accuracy: "millisecond",
+      allowNull: false
+    },
+    {
+      name: "sessionId",
+      type: "uuid",
+      allowNull: false
+    },
+    {
+      name: "messageId",
+      type: "bigInt",
+      allowNull: false
+    },
+    {
+      name: "user",
+      type: "belongsTo",
+      target: "users",
+      targetKey: "id",
+      foreignKey: "userId"
+    },
+    {
+      name: "aiEmployee",
+      type: "belongsTo",
+      target: "aiEmployees",
+      targetKey: "username",
+      foreignKey: "aiEmployeeUsername"
+    },
+    {
+      name: "from",
+      type: "string",
+      allowNull: false,
+      defaultValue: "main-agent"
+    },
+    {
+      name: "category",
+      type: "string",
+      allowNull: false,
+      defaultValue: "chat"
+    },
+    {
+      name: "eventType",
+      type: "string",
+      allowNull: false,
+      defaultValue: "llm_message"
+    },
+    {
+      name: "role",
+      type: "string",
+      allowNull: false
+    },
+    {
+      name: "provider",
+      type: "string"
+    },
+    {
+      name: "llmService",
+      type: "string"
+    },
+    {
+      name: "model",
+      type: "string"
+    },
+    {
+      name: "inputTokens",
+      type: "bigInt",
+      allowNull: false,
+      defaultValue: 0
+    },
+    {
+      name: "outputTokens",
+      type: "bigInt",
+      allowNull: false,
+      defaultValue: 0
+    },
+    {
+      name: "totalTokens",
+      type: "bigInt",
+      allowNull: false,
+      defaultValue: 0
+    },
+    {
+      name: "cachedTokens",
+      type: "bigInt",
+      allowNull: false,
+      defaultValue: 0
+    },
+    {
+      name: "reasoningTokens",
+      type: "bigInt",
+      allowNull: false,
+      defaultValue: 0
+    },
+    {
+      name: "toolCallCount",
+      type: "integer",
+      allowNull: false,
+      defaultValue: 0
+    },
+    {
+      name: "autoToolCallCount",
+      type: "integer",
+      allowNull: false,
+      defaultValue: 0
+    },
+    {
+      name: "status",
+      type: "string",
+      allowNull: false,
+      defaultValue: "success"
+    },
+    {
+      name: "rawUsageMetadata",
+      type: "jsonb"
+    },
+    {
+      name: "rawResponseMetadata",
+      type: "jsonb"
+    }
+  ],
+  indexes: [
+    {
+      fields: ["messageId", "eventType"],
+      unique: true
+    },
+    {
+      fields: ["occurredAt"]
+    },
+    {
+      fields: ["userId", "occurredAt"]
+    },
+    {
+      fields: ["aiEmployeeUsername", "occurredAt"]
+    },
+    {
+      fields: ["sessionId"]
+    }
+  ]
+});

package/dist/server/document-loader/cached.d.ts

@@ -16,6 +16,7 @@ export type CachedDocumentLoaderOptions = {
     parsedFileExtname: string;
     supports: (file: ParseableFile) => boolean;
 };
+export declare function getDocumentCacheKey(sourceFile: ParseableFile): string | null;
 export declare class CachedDocumentLoader {
     private readonly plugin;
     private readonly options;

package/dist/server/document-loader/cached.js

@@ -36,7 +36,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var cached_exports = {};
 __export(cached_exports, {
-  CachedDocumentLoader: () => CachedDocumentLoader
+  CachedDocumentLoader: () => CachedDocumentLoader,
+  getDocumentCacheKey: () => getDocumentCacheKey
 });
 module.exports = __toCommonJS(cached_exports);
 var import_promises = __toESM(require("node:fs/promises"));
@@ -44,6 +45,19 @@ var import_node_os = __toESM(require("node:os"));
 var import_node_path = __toESM(require("node:path"));
 var import_documents = require("@langchain/core/documents");
 var import_utils = require("./utils");
+function getDocumentCacheKey(sourceFile) {
+  var _a;
+  if (!sourceFile) {
+    return null;
+  }
+  if (((_a = sourceFile.source) == null ? void 0 : _a.documentCache) === false) {
+    return null;
+  }
+  if (!sourceFile.id || !sourceFile.storageId) {
+    return null;
+  }
+  return `${sourceFile.id}@${sourceFile.storageId}`;
+}
 class CachedDocumentLoader {
   constructor(plugin, options) {
     this.plugin = plugin;
@@ -151,16 +165,11 @@ class CachedDocumentLoader {
     return this._cache;
   }
   getCacheKey(sourceFile) {
-    if (!sourceFile) {
-      return null;
-    }
-    if (!sourceFile.id || !sourceFile.storageId) {
-      return null;
-    }
-    return `${sourceFile.id}@${sourceFile.storageId}`;
+    return getDocumentCacheKey(sourceFile);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CachedDocumentLoader
+  CachedDocumentLoader,
+  getDocumentCacheKey
 });

package/dist/server/document-loader/loader.d.ts

@@ -13,5 +13,4 @@ export declare class DocumentLoader {
     private readonly fileManager;
     constructor(fileManager: PluginFileManagerServer);
     load(file: ParseableFile, options?: any): Promise<Document[]>;
-    private streamToBlob;
 }

package/dist/server/document-loader/loader.js

@@ -7,9 +7,11 @@
  * 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)
@@ -23,6 +25,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 loader_exports = {};
 __export(loader_exports, {
@@ -32,6 +42,11 @@ module.exports = __toCommonJS(loader_exports);
 var import_constants = require("./constants");
 var import_utils = require("./utils");
 var import_ai = require("@nocobase/ai");
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_promises2 = require("node:stream/promises");
 class DocumentLoader {
   constructor(fileManager) {
     this.fileManager = fileManager;
@@ -42,15 +57,17 @@ class DocumentLoader {
       return [];
     }
     const { stream, contentType } = await this.fileManager.getFileStream(file, options);
-    const blob = await this.streamToBlob(stream, contentType ?? file.mimetype);
-    return await (0, import_ai.loadByWorker)(extname, blob);
-  }
-  async streamToBlob(stream, mimeType = "application/octet-stream") {
-    const chunks = [];
-    for await (const chunk of stream) {
-      chunks.push(chunk);
+    const tempDir = await (0, import_promises.mkdtemp)(import_node_path.default.join(import_node_os.default.tmpdir(), "nocobase-document-loader-"));
+    const tempFilePath = import_node_path.default.join(tempDir, `source${extname}`);
+    try {
+      await (0, import_promises2.pipeline)(stream, (0, import_node_fs.createWriteStream)(tempFilePath));
+      return await (0, import_ai.loadByWorker)(extname, {
+        filePath: tempFilePath,
+        mimeType: contentType ?? file.mimetype
+      });
+    } finally {
+      await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
     }
-    return new Blob(chunks, { type: mimeType });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/document-loader/types.d.ts

@@ -31,6 +31,13 @@ export type ParseableFile = {
     storageId?: number;
     meta?: Record<string, any>;
     size?: number;
+    source?: {
+        dataSourceKey?: string;
+        collectionName?: string;
+        field?: string;
+        documentCache?: boolean;
+        trustworthy?: boolean;
+    };
 };
 export type DocumentLoaderLike = {
     load(file: ParseableFile, options?: any): Promise<Document[]>;

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

@@ -8,6 +8,7 @@
  */
 import { LLMProvider, ParsedAttachmentResult } from './provider';
 import { ChatAnthropic } from '@langchain/anthropic';
+import type { AttachmentModel } from '@nocobase/plugin-file-manager';
 import { Model } from '@nocobase/database';
 import { LLMProviderMeta } from '../manager/ai-manager';
 import { Context } from '@nocobase/actions';
@@ -36,7 +37,7 @@ export declare class AnthropicProvider extends LLMProvider {
         type: string;
         query: string;
     }[];
-    protected convertToContent(ctx: Context, attachment: any): Promise<ParsedAttachmentResult>;
+    protected convertToContent(ctx: Context, attachment: AttachmentModel): Promise<ParsedAttachmentResult>;
     private setMaxTokens;
 }
 export declare const anthropicProviderOptions: LLMProviderMeta;

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

@@ -186,9 +186,7 @@ class AnthropicProvider extends import_provider.LLMProvider {
     });
   }
   async convertToContent(ctx, attachment) {
-    const fileManager = this.app.pm.get("file-manager");
-    const url = await fileManager.getFileURL(attachment);
-    const data = await (0, import_utils2.encodeFile)(ctx, decodeURIComponent(url));
+    const data = await this.encodeAttachment(ctx, attachment);
     if (attachment.mimetype.startsWith("image/")) {
       return {
         placement: "contentBlocks",

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, LLMProvider, ReasoningOptions, ResolvedReasoningOptions } 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 resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     parseResponseMessage(message: Model): {
         key: any;
         createdAt: any;

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

@@ -56,6 +56,7 @@ class DashscopeProvider extends import_provider.LLMProvider {
     const { apiKey } = this.serviceOptions || {};
     const { responseFormat, structuredOutput } = this.modelOptions || {};
     const { name, schema } = structuredOutput || {};
+    const reasoningOptions = this.resolveReasoningOptions(this.modelReasoningOptions);
     const modelKwargs = {};
     if (responseFormat) {
       const responseFormatOptions = {
@@ -76,7 +77,11 @@ class DashscopeProvider extends import_provider.LLMProvider {
       topP: 0.8,
       temperature: 0.7,
       ...this.modelOptions,
-      modelKwargs,
+      ...reasoningOptions.modelRequestParams || {},
+      modelKwargs: {
+        ...modelKwargs,
+        ...reasoningOptions.modelKwargs || {}
+      },
       configuration: {
         baseURL: this.getResolvedBaseURL()
       },
@@ -94,6 +99,16 @@ class DashscopeProvider extends import_provider.LLMProvider {
       return toolDefinitions;
     }
   }
+  resolveReasoningOptions(reasoning) {
+    if ((reasoning == null ? void 0 : reasoning.mode) !== "off") {
+      return {};
+    }
+    return {
+      modelKwargs: {
+        enable_thinking: false
+      }
+    };
+  }
   parseResponseMessage(message) {
     var _a;
     const result = super.parseResponseMessage(message);

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

@@ -8,7 +8,7 @@
  */
 import { ChatDeepSeek } from '@langchain/deepseek';
 import { AIMessageChunk, BaseMessage } from '@langchain/core/messages';
-import { LLMProvider } from './provider';
+import { LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from './provider';
 import { LLMProviderMeta } from '../manager/ai-manager';
 import { Model } from '@nocobase/database';
 import type OpenAI from 'openai';
@@ -33,6 +33,7 @@ export declare class DeepSeekProvider extends LLMProvider {
         status: string;
         content: string;
     };
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     protected isApiSupportedAttachment(attachment: AttachmentModel): boolean;
 }
 export declare const deepseekProviderOptions: LLMProviderMeta;