@nocobase/plugin-ai 2.2.0-alpha.7 → 2.2.0-alpha.9

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/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/google-genai.d.ts

@@ -9,7 +9,7 @@
 import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { EmbeddingProvider, LLMProvider, ParsedAttachmentResult } from './provider';
 import { Model } from '@nocobase/database';
-import { AttachmentModel } from '@nocobase/plugin-file-manager';
+import type { AttachmentModel } from '@nocobase/plugin-file-manager';
 import { LLMProviderMeta } from '../manager/ai-manager';
 import { EmbeddingsInterface } from '@langchain/core/embeddings';
 import { Context } from '@nocobase/actions';

package/dist/server/llm-providers/google-genai.js

@@ -34,7 +34,6 @@ module.exports = __toCommonJS(google_genai_exports);
 var import_google_genai = require("@langchain/google-genai");
 var import_provider = require("./provider");
 var import_utils = require("@nocobase/utils");
-var import_utils2 = require("../utils");
 var import_ai_manager = require("../manager/ai-manager");
 const GOOGLE_GEN_AI_URL = "https://generativelanguage.googleapis.com";
 class GoogleGenAIProvider extends import_provider.LLMProvider {
@@ -120,10 +119,8 @@ class GoogleGenAIProvider extends import_provider.LLMProvider {
   }
   async convertToContent(ctx, attachment) {
     var _a;
-    const fileManager = this.app.pm.get("file-manager");
-    const url = await fileManager.getFileURL(attachment);
+    const data = await this.encodeAttachment(ctx, attachment);
     if ((_a = attachment.mimetype) == null ? void 0 : _a.startsWith("image/")) {
-      const data = await (0, import_utils2.encodeFile)(ctx, decodeURIComponent(url));
       return {
         placement: "contentBlocks",
         content: {
@@ -134,7 +131,6 @@ class GoogleGenAIProvider extends import_provider.LLMProvider {
         }
       };
     } else {
-      const data = await (0, import_utils2.encodeFile)(ctx, decodeURIComponent(url));
       return {
         placement: "contentBlocks",
         content: {

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

@@ -8,7 +8,7 @@
  */
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { Model } from '@nocobase/database';
-import { AttachmentModel } from '@nocobase/plugin-file-manager';
+import { type AttachmentModel } from '@nocobase/plugin-file-manager';
 import { Application } from '@nocobase/server';
 import { AIChatContext, AIMessageInput } from '../types/ai-chat-conversation.type';
 import { EmbeddingsInterface } from '@langchain/core/embeddings';
@@ -76,7 +76,8 @@ export declare abstract class LLMProvider {
     parseAttachment(ctx: Context, attachment: AttachmentModel): Promise<ParsedAttachmentResult>;
     protected isApiSupportedAttachment(attachment: AttachmentModel): boolean;
     protected isDocumentLoaderSupportedAttachment(attachment: AttachmentModel): boolean;
-    protected convertToContent(ctx: Context, attachment: any): Promise<ParsedAttachmentResult>;
+    protected encodeAttachment(ctx: Context, attachment: AttachmentModel): Promise<string>;
+    protected convertToContent(ctx: Context, attachment: AttachmentModel): Promise<ParsedAttachmentResult>;
     protected loadDocument(ctx: Context, attachment: any): Promise<any>;
     getStructuredOutputOptions(structuredOutput: AIChatContext['structuredOutput']): any;
     testFlight(): Promise<{

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

@@ -189,6 +189,15 @@ class LLMProvider {
     return (0, import_utils2.stripToolCallTags)(chunk);
   }
   async parseAttachment(ctx, attachment) {
+    var _a;
+    const dataSourceKey = (_a = attachment == null ? void 0 : attachment.source) == null ? void 0 : _a.dataSourceKey;
+    const isExternalAttachment = Boolean(dataSourceKey && dataSourceKey !== "main");
+    if (!(attachment == null ? void 0 : attachment.storageId) && !isExternalAttachment || !(attachment == null ? void 0 : attachment.filename)) {
+      return {
+        placement: "system",
+        content: "The user provided an attachment, but it is unavailable or invalid and cannot be parsed. Do not use this attachment as evidence; tell the user the attachment is unavailable."
+      };
+    }
     if (this.isApiSupportedAttachment(attachment)) {
       return await this.convertToContent(ctx, attachment);
     } else if (this.isDocumentLoaderSupportedAttachment(attachment)) {
@@ -218,10 +227,24 @@ class LLMProvider {
     const ext = import_node_path.default.extname((attachment == null ? void 0 : attachment.filename) ?? "").toLocaleLowerCase();
     return import_document_loader.SUPPORTED_DOCUMENT_EXTNAMES.includes(ext);
   }
-  async convertToContent(ctx, attachment) {
+  async encodeAttachment(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));
+    if (typeof ctx.get !== "function") {
+      const { stream: stream2 } = await fileManager.getFileStream(attachment);
+      return await (0, import_utils2.encodeReadableStream)(stream2);
+    }
+    const { stream } = await fileManager.getFileStream(attachment, {
+      requestOptions: {
+        headers: {
+          Referer: ctx.get("referer") || "",
+          "User-Agent": ctx.get("user-agent") || ""
+        }
+      }
+    });
+    return await (0, import_utils2.encodeReadableStream)(stream);
+  }
+  async convertToContent(ctx, attachment) {
+    const data = await this.encodeAttachment(ctx, attachment);
     if (attachment.mimetype.startsWith("image/")) {
       return {
         placement: "contentBlocks",

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

@@ -60,6 +60,34 @@ function serializeQueryFieldValue(value) {
   }
   return value;
 }
+function getRecordFieldValue(record, field) {
+  return field.split(".").reduce((current, key) => {
+    if (current === null || current === void 0) {
+      return current;
+    }
+    if (typeof current.get === "function") {
+      return current.get(key);
+    }
+    return current[key];
+  }, record);
+}
+function getQueryFieldOptions(collection, field) {
+  const parts = field.split(".");
+  let currentCollection = collection;
+  for (const [index, part] of parts.entries()) {
+    const currentField = currentCollection == null ? void 0 : currentCollection.getField(part);
+    if (!currentField) {
+      return;
+    }
+    if (index === parts.length - 1) {
+      return currentField.options;
+    }
+    if (!currentField.isRelationField()) {
+      return;
+    }
+    currentCollection = currentField.targetCollection();
+  }
+}
 class AIContextDatasourceManager {
   constructor(plugin) {
     this.plugin = plugin;
@@ -149,17 +177,16 @@ class AIContextDatasourceManager {
         }
       });
     }
-    const { fields, filter, sort, offset, limit } = options;
-    const result = await collection.repository.find({ fields, filter, sort, offset: offset ?? 0, limit });
+    const { fields, appends, filter, sort, offset, limit } = options;
+    const result = await collection.repository.find({ fields, appends, filter, sort, offset: offset ?? 0, limit });
     const total = await collection.repository.count({ fields, filter });
     const records = result.map(
       (x) => fields.map((field) => {
-        var _a2;
-        const { name, type } = ((_a2 = collection.getField(field)) == null ? void 0 : _a2.options) || {};
-        const value = serializeQueryFieldValue(x[field]);
+        const { name, type } = getQueryFieldOptions(collection, field) || {};
+        const value = serializeQueryFieldValue(getRecordFieldValue(x, field));
         return {
-          name,
-          type,
+          name: field.includes(".") ? field : name || field,
+          type: type || "unknown",
           value
         };
       })

package/dist/server/plugin.js

@@ -80,6 +80,7 @@ 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");
+var import_attachments = require("./attachments");
 class PluginAIServer extends import_server.Plugin {
   features = new import_ai_feature_manager.AIPluginFeatureManagerImpl();
   aiManager = new import_ai_manager.AIManager(this);
@@ -218,6 +219,19 @@ class PluginAIServer extends import_server.Plugin {
       },
       { before: "createMiddleware" }
     );
+    this.app.resourceManager.use(
+      async (ctx, next) => {
+        const { resourceName, actionName } = ctx.action;
+        if (resourceName === "aiFiles" && actionName === "create") {
+          (0, import_attachments.appendAIFileAttachmentSource)(ctx.action.params.values);
+        }
+        await next();
+        if (resourceName === "aiFiles" && actionName === "create") {
+          (0, import_attachments.appendAIFileAttachmentSource)(ctx.body);
+        }
+      },
+      { after: "createMiddleware" }
+    );
     Object.entries(aiEmployeeActions).forEach(([name, action]) => {
       this.app.resourceManager.registerActionHandler(`aiEmployees:${name}`, action);
     });

package/dist/server/resource/aiConversations.js

@@ -103,6 +103,33 @@ const saveUserMessages = async (ctx, sessionId, messages, messageId) => {
     await conversation.addMessages(userMessages);
   });
 };
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function normalizeIncomingMessageAttachments(ctx, messages) {
+  for (const message of messages) {
+    if (message.attachments == null) {
+      continue;
+    }
+    if (!Array.isArray(message.attachments)) {
+      throw new import_utils.ResourceActionError(400, ctx.t("Invalid attachment"));
+    }
+    message.attachments = message.attachments.map((attachment) => {
+      if (!isRecord(attachment) || !isRecord(attachment.source)) {
+        throw new import_utils.ResourceActionError(400, ctx.t("Invalid attachment"));
+      }
+      const source = { ...attachment.source };
+      delete source.trustworthy;
+      if (typeof source.collectionName !== "string" || !source.collectionName) {
+        throw new import_utils.ResourceActionError(400, ctx.t("Invalid attachment"));
+      }
+      return {
+        ...attachment,
+        source
+      };
+    });
+  }
+}
 var aiConversations_default = {
   name: "aiConversations",
   middlewares: [
@@ -329,6 +356,7 @@ var aiConversations_default = {
         if (!Array.isArray(messages)) {
           throw new import_utils.ResourceActionError(400, ctx.t("messages must be an array"));
         }
+        normalizeIncomingMessageAttachments(ctx, messages);
         const userMessage = messages.find((message) => message.role === "user");
         if (!userMessage) {
           throw new import_utils.ResourceActionError(400, ctx.t("user message is required"));
@@ -633,6 +661,13 @@ var aiConversations_default = {
       if (!message) {
         ctx.throw(400);
       }
+      const messageConversation = await plugin.aiConversationsManager.getConversation({
+        sessionId: message.sessionId,
+        userId
+      });
+      if (!messageConversation) {
+        ctx.throw(400);
+      }
       const toolCalls = message.toolCalls;
       if (!(toolCalls == null ? void 0 : toolCalls.length)) {
         ctx.throw(400);
@@ -730,6 +765,14 @@ var aiConversations_default = {
           sendErrorResponse(ctx, "message not found");
           return next();
         }
+        const messageConversation = await plugin.aiConversationsManager.getConversation({
+          sessionId: message.sessionId,
+          userId
+        });
+        if (!messageConversation) {
+          sendErrorResponse(ctx, "conversation not found");
+          return next();
+        }
         const tools = message.toolCalls;
         if (!(tools == null ? void 0 : tools.length)) {
           sendErrorResponse(ctx, "No tool calls found");
@@ -746,7 +789,7 @@ var aiConversations_default = {
           webSearch,
           model: resolvedModel
         });
-        const userDecisions = await plugin.aiConversationsManager.getUserDecisions(messageId);
+        const userDecisions = await plugin.aiConversationsManager.getUserDecisions(message.messageId);
         await aiEmployee.stream({
           userDecisions
         });

package/dist/server/utils.d.ts

@@ -6,9 +6,11 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+/// <reference types="node" />
 import { Model } from '@nocobase/database';
 import { Context } from '@nocobase/actions';
 import { ToolsEntry } from '@nocobase/ai';
+import type { Readable } from 'stream';
 export declare function sendSSEError(ctx: Context, error: Error | string, errorName?: string): void;
 export declare function stripToolCallTags(content: string): string | null;
 export declare function parseResponseMessage(row: Model): {
@@ -17,8 +19,9 @@ export declare function parseResponseMessage(row: Model): {
     content: any;
     role: any;
 };
-export declare function encodeLocalFile(url: string): Promise<string>;
-export declare function encodeFile(ctx: Context, url: string): Promise<string>;
+export declare function encodeLocalFile(_url: string): Promise<void>;
+export declare function encodeFile(ctx: Context, url: string): Promise<string | void>;
+export declare function encodeReadableStream(stream: Readable): Promise<string>;
 export declare function parseVariables(ctx: Context, value: string): Promise<any>;
 export declare const buildTool: (toolsEntry: ToolsEntry) => import("@langchain/core/dist/tools").DynamicTool<any, unknown>;
 export declare class ResourceActionError extends Error {