@nocobase/plugin-ai 2.2.0-beta.9 → 2.2.1

package/dist/server/utils.js

@@ -7,11 +7,9 @@
  * 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)
@@ -25,14 +23,6 @@ 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 utils_exports = {};
 __export(utils_exports, {
@@ -40,14 +30,13 @@ __export(utils_exports, {
   buildTool: () => buildTool,
   encodeFile: () => encodeFile,
   encodeLocalFile: () => encodeLocalFile,
+  encodeReadableStream: () => encodeReadableStream,
   parseResponseMessage: () => parseResponseMessage,
   parseVariables: () => parseVariables,
   sendSSEError: () => sendSSEError,
   stripToolCallTags: () => stripToolCallTags
 });
 module.exports = __toCommonJS(utils_exports);
-var import_path = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
 var import_utils = require("@nocobase/utils");
 var import_langchain = require("langchain");
 function sendSSEError(ctx, error, errorName) {
@@ -91,13 +80,8 @@ function parseResponseMessage(row) {
     role
   };
 }
-async function encodeLocalFile(url) {
-  if (process.env.APP_PUBLIC_PATH && url.startsWith(process.env.APP_PUBLIC_PATH)) {
-    url = url.slice(process.env.APP_PUBLIC_PATH.length);
-  }
-  url = import_path.default.join(process.cwd(), url);
-  const data = await import_fs.default.promises.readFile(url);
-  return Buffer.from(data).toString("base64");
+async function encodeLocalFile(_url) {
+  throw new Error("Local file path is not allowed");
 }
 async function encodeFile(ctx, url) {
   if (!url.startsWith("http")) {
@@ -117,6 +101,13 @@ async function encodeFile(ctx, url) {
   });
   return Buffer.from(response.data).toString("base64");
 }
+async function encodeReadableStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("base64");
+}
 async function getUser(ctx, fields) {
   const userFields = fields.filter((f) => f && ctx.db.getFieldByPath("users." + f));
   if (!ctx.state.currentUser) {
@@ -193,6 +184,7 @@ class ResourceActionError extends Error {
   buildTool,
   encodeFile,
   encodeLocalFile,
+  encodeReadableStream,
   parseResponseMessage,
   parseVariables,
   sendSSEError,

package/dist/server/workflow/nodes/employee/files.d.ts

@@ -9,7 +9,9 @@
 import { AIEmployeeInstructionFiles } from './types';
 import { Plugin } from '@nocobase/server';
 export declare abstract class Files {
-    static resolvers(plugin: Plugin, attachmentPart: Record<string, any>): {
+    static resolvers(plugin: Plugin, attachmentPart: {
+        attachments?: unknown[];
+    }): {
         resolveAttachments: (files: AIEmployeeInstructionFiles[]) => Promise<void>;
         resolveFileIds: (files: AIEmployeeInstructionFiles[]) => Promise<void>;
         resolveUrls: (files: AIEmployeeInstructionFiles[]) => Promise<void>;

package/dist/server/workflow/nodes/employee/files.js

@@ -45,10 +45,25 @@ var import_node_path = __toESM(require("node:path"));
 var import_lodash = __toESM(require("lodash"));
 var import_axios = __toESM(require("axios"));
 var import_utils = require("../../utils");
+var import_attachments = require("../../../attachments");
+function appendSource(record, source) {
+  if (!record || typeof record !== "object" || Array.isArray(record)) {
+    return record;
+  }
+  return {
+    ...record,
+    source
+  };
+}
 class Files {
   static resolvers(plugin, attachmentPart) {
     const resolveAttachments = async (files) => {
-      const attachments = files.filter((it) => it.type === "attachments").flatMap((it) => import_lodash.default.isArray(it.value) ? it.value : [it.value]);
+      const attachments = files.filter((it) => it.type === "attachments").flatMap((it) => import_lodash.default.isArray(it.value) ? it.value : [it.value]).map(
+        (attachment) => appendSource(attachment, {
+          ...(0, import_attachments.getAttachmentSource)(attachment) ?? {},
+          trustworthy: true
+        })
+      );
       if (attachments.length) {
         attachmentPart.attachments = [...attachmentPart.attachments ?? [], ...attachments];
       }
@@ -78,7 +93,13 @@ class Files {
           }
           attachmentPart.attachments = [
             ...attachmentPart.attachments ?? [],
-            ...attachmentModels.map((it) => it.toJSON())
+            ...attachmentModels.map(
+              (it) => appendSource(it.toJSON(), {
+                dataSourceKey: "main",
+                collectionName: collection,
+                trustworthy: true
+              })
+            )
           ];
         }
       }
@@ -106,14 +127,19 @@ class Files {
                 filePath: tempFilePath,
                 storageName,
                 values: {
-                  ...fileIdentity,
+                  title: fileIdentity.title,
                   mimetype: contentType,
                   meta: {
-                    sourceUrl: url
+                    sourceUrl: url,
+                    originalFilename: fileIdentity.filename
                   }
                 }
               });
-              return created.toJSON();
+              return appendSource(created.toJSON(), {
+                dataSourceKey: "main",
+                collectionName: "aiFiles",
+                trustworthy: true
+              });
             } finally {
               await import_promises.default.rm(tempFilePath, { force: true });
             }

package/dist/swagger/common.d.ts

@@ -0,0 +1,143 @@
+/**
+ * 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.
+ */
+export declare const jsonContent: (schema: Record<string, unknown>) => {
+    'application/json': {
+        schema: Record<string, unknown>;
+    };
+};
+export declare const okResponse: (schema?: Record<string, unknown>) => {
+    200: {
+        content?: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+        description: string;
+    };
+};
+export declare const errorResponses: {
+    400: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+    401: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+    403: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+    404: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+};
+export declare const withErrorResponses: (responses: Record<string | number, unknown>) => {
+    400: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+    401: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+    403: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+    404: {
+        description: string;
+        content: {
+            'application/json': {
+                schema: Record<string, unknown>;
+            };
+        };
+    };
+};
+export declare const filterByTkParameter: {
+    name: string;
+    in: string;
+    required: boolean;
+    description: string;
+    schema: {
+        type: string;
+    };
+};
+export declare const listParameters: ({
+    name: string;
+    in: string;
+    description: string;
+    schema: {
+        type: string;
+        additionalProperties: boolean;
+        items?: undefined;
+        minimum?: undefined;
+    };
+} | {
+    name: string;
+    in: string;
+    description: string;
+    schema: {
+        type: string;
+        items: {
+            type: string;
+        };
+        additionalProperties?: undefined;
+        minimum?: undefined;
+    };
+} | {
+    name: string;
+    in: string;
+    schema: {
+        type: string;
+        minimum: number;
+        additionalProperties?: undefined;
+        items?: undefined;
+    };
+    description?: undefined;
+} | {
+    name: string;
+    in: string;
+    description: string;
+    schema: {
+        type: string;
+        additionalProperties?: undefined;
+        items?: undefined;
+        minimum?: undefined;
+    };
+})[];

package/dist/swagger/common.js

@@ -0,0 +1,144 @@
+/**
+ * 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 common_exports = {};
+__export(common_exports, {
+  errorResponses: () => errorResponses,
+  filterByTkParameter: () => filterByTkParameter,
+  jsonContent: () => jsonContent,
+  listParameters: () => listParameters,
+  okResponse: () => okResponse,
+  withErrorResponses: () => withErrorResponses
+});
+module.exports = __toCommonJS(common_exports);
+const jsonContent = (schema) => ({
+  "application/json": {
+    schema
+  }
+});
+const okResponse = (schema) => ({
+  200: {
+    description: "OK",
+    ...schema ? { content: jsonContent(schema) } : {}
+  }
+});
+const errorResponses = {
+  400: {
+    description: "Bad request",
+    content: jsonContent({ $ref: "#/components/schemas/ErrorResponse" })
+  },
+  401: {
+    description: "Unauthorized",
+    content: jsonContent({ $ref: "#/components/schemas/ErrorResponse" })
+  },
+  403: {
+    description: "Forbidden",
+    content: jsonContent({ $ref: "#/components/schemas/ErrorResponse" })
+  },
+  404: {
+    description: "Not found",
+    content: jsonContent({ $ref: "#/components/schemas/ErrorResponse" })
+  }
+};
+const withErrorResponses = (responses) => ({
+  ...responses,
+  ...errorResponses
+});
+const filterByTkParameter = {
+  name: "filterByTk",
+  in: "query",
+  required: true,
+  description: "Primary key of the target record.",
+  schema: {
+    type: "string"
+  }
+};
+const listParameters = [
+  {
+    name: "filter",
+    in: "query",
+    description: "NocoBase filter object encoded as JSON.",
+    schema: {
+      type: "object",
+      additionalProperties: true
+    }
+  },
+  {
+    name: "fields",
+    in: "query",
+    description: "Fields to include in the response.",
+    schema: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    }
+  },
+  {
+    name: "sort",
+    in: "query",
+    description: "Sort fields. Prefix a field with - for descending order.",
+    schema: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    }
+  },
+  {
+    name: "page",
+    in: "query",
+    schema: {
+      type: "integer",
+      minimum: 1
+    }
+  },
+  {
+    name: "pageSize",
+    in: "query",
+    schema: {
+      type: "integer",
+      minimum: 1
+    }
+  },
+  {
+    name: "paginate",
+    in: "query",
+    description: "Set to false to return an unpaginated array.",
+    schema: {
+      type: "boolean"
+    }
+  }
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errorResponses,
+  filterByTkParameter,
+  jsonContent,
+  listParameters,
+  okResponse,
+  withErrorResponses
+});