plugin-custom-llm 1.2.0 → 1.2.2

package/dist/externalVersion.js

@@ -8,13 +8,15 @@
  */
 
 module.exports = {
-  "@nocobase/client": "2.0.20",
-  "@nocobase/plugin-ai": "2.0.20",
+  "@nocobase/client": "2.0.32",
+  "@nocobase/plugin-ai": "2.0.32",
   "react-i18next": "11.18.6",
-  "@nocobase/server": "2.0.20",
-  "@nocobase/flow-engine": "2.0.20",
-  "@nocobase/database": "2.0.20",
-  "react": "18.2.0",
-  "@nocobase/utils": "2.0.20",
+  "@nocobase/server": "2.0.32",
+  "@nocobase/flow-engine": "2.0.32",
+  "@nocobase/database": "2.0.32",
+  "axios": "1.14.0",
+  "@nocobase/actions": "2.0.32",
+  "react": "18.3.1",
+  "@nocobase/utils": "2.0.32",
   "antd": "5.24.2"
 };

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

@@ -42,6 +42,8 @@ __export(custom_llm_exports, {
 module.exports = __toCommonJS(custom_llm_exports);
 var import_plugin_ai = require("@nocobase/plugin-ai");
 var import_node_path = __toESM(require("node:path"));
+var import_promises = __toESM(require("node:fs/promises"));
+var import_axios = __toESM(require("axios"));
 const KEEPALIVE_PREFIX = "\u200B\u200B\u200B";
 function requireFromApp(moduleName) {
   const appNodeModules = process.env.NODE_MODULES_PATH || import_node_path.default.join(process.cwd(), "node_modules");
@@ -100,11 +102,41 @@ function extractTextContent(content, contentPath) {
   }
   return "";
 }
-function safeParseJSON(str) {
+function isTextMimetype(mimetype) {
+  if (!mimetype) return false;
+  if (mimetype.startsWith("text/")) return true;
+  const TEXT_APPLICATION_TYPES = /* @__PURE__ */ new Set([
+    "application/json",
+    "application/xml",
+    "application/xhtml+xml",
+    "application/atom+xml",
+    "application/rss+xml",
+    "application/csv",
+    "application/javascript",
+    "application/typescript",
+    "application/x-javascript",
+    "application/x-typescript",
+    "application/x-yaml",
+    "application/yaml",
+    "application/x-json",
+    "application/geo+json",
+    "application/ld+json",
+    "application/manifest+json",
+    "application/graphql",
+    "application/x-www-form-urlencoded",
+    "application/toml",
+    "application/x-sh",
+    "application/x-shellscript",
+    "application/sql"
+  ]);
+  return TEXT_APPLICATION_TYPES.has(mimetype);
+}
+function safeParseJSON(str, fieldName) {
   if (!str || typeof str !== "string") return {};
   try {
     return JSON.parse(str);
-  } catch {
+  } catch (e) {
+    console.warn(`[CustomLLM] Failed to parse ${fieldName || "JSON config"}: ${e.message}`);
     return {};
   }
 }
@@ -170,13 +202,13 @@ function createMappingFetch(responseMapping) {
 
 `));
                     } else {
-                      controller.enqueue(encoder.encode(line + "\n"));
+                      controller.enqueue(encoder.encode(line + "\n\n"));
                     }
                   } catch {
-                    controller.enqueue(encoder.encode(line + "\n"));
+                    controller.enqueue(encoder.encode(line + "\n\n"));
                   }
                 } else {
-                  controller.enqueue(encoder.encode(line + "\n"));
+                  controller.enqueue(encoder.encode(line + "\n\n"));
                 }
               }
             }
@@ -391,11 +423,11 @@ class CustomLLMProvider extends import_plugin_ai.LLMProvider {
   }
   get requestConfig() {
     var _a;
-    return safeParseJSON((_a = this.serviceOptions) == null ? void 0 : _a.requestConfig);
+    return safeParseJSON((_a = this.serviceOptions) == null ? void 0 : _a.requestConfig, "requestConfig");
   }
   get responseConfig() {
     var _a;
-    return safeParseJSON((_a = this.serviceOptions) == null ? void 0 : _a.responseConfig);
+    return safeParseJSON((_a = this.serviceOptions) == null ? void 0 : _a.responseConfig, "responseConfig");
   }
   createModel() {
     var _a;
@@ -528,6 +560,231 @@ class CustomLLMProvider extends import_plugin_ai.LLMProvider {
   parseResponseError(err) {
     return (err == null ? void 0 : err.message) ?? "Unexpected LLM service error";
   }
+  /**
+   * Self-contained file reading that correctly handles the APP_PUBLIC_PATH prefix.
+   *
+   * plugin-ai's encodeLocalFile does path.join(cwd, url) without stripping
+   * APP_PUBLIC_PATH, so when the app is deployed under a sub-path (e.g. /my-app)
+   * the resolved path becomes '{cwd}/my-app/storage/uploads/…' which does not exist.
+   * We cannot fix that in plugin-ai (core), so we re-implement file reading here
+   * with the prefix stripped before the cwd join.
+   */
+  /**
+   * Reads the attachment and returns its base64-encoded content plus, when the
+   * file lives on the local filesystem, the resolved absolute path so callers
+   * can hand that path directly to tools like DocPixie and avoid a second
+   * write-to-disk round-trip.
+   */
+  async readFileData(ctx, attachment) {
+    const fileManager = this.app.pm.get("file-manager");
+    const rawUrl = await fileManager.getFileURL(attachment);
+    const url = decodeURIComponent(rawUrl);
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      const referer = ctx.get("referer") || "";
+      const ua = ctx.get("user-agent") || "";
+      const response = await import_axios.default.get(url, {
+        responseType: "arraybuffer",
+        timeout: 3e4,
+        headers: { referer, "User-Agent": ua }
+      });
+      return { base64: Buffer.from(response.data).toString("base64") };
+    }
+    if (url.includes("/api/attachments:stream")) {
+      const { stream } = await fileManager.getFileStream(attachment);
+      const chunks = [];
+      for await (const chunk of stream) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+      }
+      return { base64: Buffer.concat(chunks).toString("base64") };
+    }
+    let localPath = url;
+    const appPublicPath = (process.env.APP_PUBLIC_PATH || "/").replace(/\/+$/, "");
+    if (appPublicPath && localPath.startsWith(appPublicPath + "/")) {
+      localPath = localPath.slice(appPublicPath.length);
+    }
+    const storageRoot = import_node_path.default.resolve(process.cwd());
+    const absPath = import_node_path.default.resolve(storageRoot, localPath.replace(/^\//, ""));
+    if (!absPath.startsWith(storageRoot + import_node_path.default.sep) && absPath !== storageRoot) {
+      throw new Error(`Attachment path escapes storage root: ${localPath}`);
+    }
+    const data = await import_promises.default.readFile(absPath);
+    return { base64: Buffer.from(data).toString("base64"), absPath };
+  }
+  /**
+   * Override parseAttachment to convert all attachments into formats that
+   * generic OpenAI-compatible endpoints actually support:
+   *
+   *   - Images     → image_url block with base64 data URI (vision models)
+   *   - Text files → text block with decoded UTF-8 content
+   *   - Binary     → text block with base64 data URI (multi-modal or fallback)
+   *
+   * The base-class implementation returns a LangChain ContentBlock.Multimodal.File
+   * (`type: 'file'`) for non-image attachments. LangChain serialises this as the
+   * newer OpenAI Files API format which most custom/local endpoints do NOT understand,
+   * causing file content to be silently dropped.
+   *
+   * This method is entirely self-contained — it does not call super — so it is
+   * safe to use without modifying plugin-ai core.
+   */
+  /**
+   * Try to extract text from an attachment using DocPixie (if available and
+   * the file type is supported). Returns null if DocPixie is unavailable,
+   * not ready, or the file type is not supported.
+   */
+  /**
+   * Check whether the DocPixie skill (`docpixie.query.document`) is configured
+   * on the AI employee that initiated this request.
+   *
+   * Reads `ctx.action.params.values.aiEmployee` (the employee username set by the
+   * `sendMessages` action handler), then looks up the employee's `skillSettings`
+   * from DB. Result is cached on `ctx.state._docPixieActive` for the request lifetime.
+   */
+  async hasDocPixieSkill(ctx) {
+    var _a, _b, _c, _d, _e;
+    if (ctx.state._docPixieActive !== void 0) return ctx.state._docPixieActive;
+    try {
+      const employeeUsername = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.aiEmployee;
+      if (!employeeUsername) {
+        ctx.state._docPixieActive = false;
+        return false;
+      }
+      const employee = await ctx.db.getRepository("aiEmployees").findOne({
+        filter: { username: String(employeeUsername) },
+        fields: ["skillSettings"]
+      });
+      const skills = ((_e = (_d = employee == null ? void 0 : employee.get) == null ? void 0 : _d.call(employee, "skillSettings")) == null ? void 0 : _e.skills) ?? [];
+      const has = skills.some((s) => s.name === "docpixie.query.document");
+      ctx.state._docPixieActive = has;
+      return has;
+    } catch {
+      ctx.state._docPixieActive = false;
+      return false;
+    }
+  }
+  /**
+   * Run the full DocPixie ingestion pipeline (extract pages → generate summary → index).
+   * Returns a formatted `<processed_document>` context block the LLM can use immediately,
+   * plus a clear instruction to call the RAG tool with the returned documentId for details.
+   *
+   * Prefers passing `absPath` directly for local-storage files to avoid a second
+   * write-to-disk round-trip. Falls back to Buffer for remote / S3 files.
+   *
+   * Returns null if DocPixie is unavailable, not configured, or processing fails.
+   */
+  async tryDocPixieFullProcess(fileData, filename, ctx) {
+    var _a, _b, _c, _d;
+    try {
+      const docpixie = this.app.pm.get("docpixie");
+      if (!((_b = (_a = docpixie == null ? void 0 : docpixie.service) == null ? void 0 : _a.isReady) == null ? void 0 : _b.call(_a))) return null;
+      const userId = (_d = (_c = ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id;
+      let result;
+      if (fileData.absPath) {
+        result = await docpixie.service.processDocumentFromPath(fileData.absPath, filename, { userId });
+      } else {
+        const buffer = Buffer.from(fileData.base64, "base64");
+        result = await docpixie.service.processDocumentFromBuffer(buffer, filename, { userId });
+      }
+      const { documentId, summary, pageCount } = result;
+      const summaryText = (summary == null ? void 0 : summary.trim()) || "No summary available.";
+      return `<processed_document id="${documentId}" filename="${filename}" pages="${pageCount}">
+<summary>
+${summaryText}
+</summary>
+<rag_instruction>This document is fully indexed. Call docpixie.query.document with documentId=${documentId} to retrieve specific details.</rag_instruction>
+</processed_document>`;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Try to extract text from an attachment using DocPixie (transient — no DB indexing).
+   * When `absPath` is provided (local-storage file), DocPixie reads the file
+   * directly — no Buffer decode/re-encode or extra temp-file write.
+   * Falls back to `extractTextFromBuffer` for remote/S3 files.
+   * Returns null if DocPixie is unavailable, not ready, or file type unsupported.
+   */
+  async tryDocPixieExtract(fileData, filename) {
+    try {
+      const docpixie = this.app.pm.get("docpixie");
+      if (!(docpixie == null ? void 0 : docpixie.service)) return null;
+      let text;
+      if (fileData.absPath) {
+        text = await docpixie.service.extractTextFromPath(fileData.absPath, filename);
+      } else {
+        const buffer = Buffer.from(fileData.base64, "base64");
+        text = await docpixie.service.extractTextFromBuffer(buffer, filename);
+      }
+      return text || null;
+    } catch {
+      return null;
+    }
+  }
+  async parseAttachment(ctx, attachment) {
+    const mimetype = attachment.mimetype || "application/octet-stream";
+    const filename = attachment.filename || attachment.name || "file";
+    const fileData = await this.readFileData(ctx, attachment);
+    const { base64: data } = fileData;
+    const isDocPixieSupported = mimetype === "application/pdf" || mimetype.startsWith("image/");
+    if (isDocPixieSupported && await this.hasDocPixieSkill(ctx)) {
+      const contextBlock = await this.tryDocPixieFullProcess(fileData, filename, ctx);
+      if (contextBlock) {
+        return {
+          placement: "contentBlocks",
+          content: { type: "text", text: contextBlock }
+        };
+      }
+    }
+    if (mimetype === "application/pdf") {
+      const extracted = await this.tryDocPixieExtract(fileData, filename);
+      if (extracted) {
+        return {
+          placement: "contentBlocks",
+          content: {
+            type: "text",
+            text: `<attachment filename="${filename}" type="${mimetype}">
+${extracted}
+</attachment>`
+          }
+        };
+      }
+    }
+    if (mimetype.startsWith("image/")) {
+      const extracted = await this.tryDocPixieExtract(fileData, filename);
+      if (extracted) {
+        return {
+          placement: "contentBlocks",
+          content: {
+            type: "text",
+            text: `<attachment filename="${filename}" type="${mimetype}">
+${extracted}
+</attachment>`
+          }
+        };
+      }
+      return {
+        placement: "contentBlocks",
+        content: {
+          type: "image_url",
+          image_url: { url: `data:${mimetype};base64,${data}` }
+        }
+      };
+    }
+    let textContent;
+    if (isTextMimetype(mimetype)) {
+      const decoded = Buffer.from(data, "base64").toString("utf-8");
+      textContent = `<attachment filename="${filename}" type="${mimetype}">
+${decoded}
+</attachment>`;
+    } else {
+      textContent = `<attachment filename="${filename}" type="${mimetype}">
+data:${mimetype};base64,${data}
+</attachment>`;
+    }
+    return {
+      placement: "contentBlocks",
+      content: { type: "text", text: textContent }
+    };
+  }
 }
 const customLLMProviderOptions = {
   title: "Custom LLM (OpenAI Compatible)",

package/dist/swagger.js

@@ -0,0 +1,39 @@
+/**
+ * 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 swagger_exports = {};
+__export(swagger_exports, {
+  default: () => swagger_default
+});
+module.exports = __toCommonJS(swagger_exports);
+var swagger_default = {
+  info: {
+    title: "NocoBase API - Custom LLM Plugin",
+    description: "Registers a custom OpenAI-compatible LLM provider with the AI plugin. This plugin has no direct HTTP endpoints \u2014 all API access is through the AI API plugin gateway (`/api/ai-llm/v1/*`) using models registered under the `custom-llm` service."
+  },
+  tags: [{ name: "custom-llm", description: "Custom LLM provider (no direct endpoints)" }],
+  paths: {}
+};

package/package.json

@@ -3,8 +3,16 @@
   "displayName": "AI LLM: Custom (OpenAI Compatible)",
   "displayName.zh-CN": "AI LLM：自定义（OpenAI 兼容）",
   "description": "OpenAI-compatible LLM provider with auto response format detection for external LLM services.",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "main": "dist/server/index.js",
+  "files": [
+    "dist",
+    "client.js",
+    "client.d.ts",
+    "server.js",
+    "server.d.ts",
+    "src"
+  ],
   "nocobase": {
     "supportedVersions": [
       "2.x"

package/src/client/client.d.ts

@@ -0,0 +1,249 @@
+/**
+ * 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.
+ */
+
+// CSS modules
+type CSSModuleClasses = { readonly [key: string]: string };
+
+declare module '*.module.css' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+declare module '*.module.less' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+declare module '*.module.styl' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+declare module '*.module.stylus' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+declare module '*.module.pcss' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+declare module '*.module.sss' {
+  const classes: CSSModuleClasses;
+  export default classes;
+}
+
+// CSS
+declare module '*.css' { }
+declare module '*.scss' { }
+declare module '*.sass' { }
+declare module '*.less' { }
+declare module '*.styl' { }
+declare module '*.stylus' { }
+declare module '*.pcss' { }
+declare module '*.sss' { }
+
+// Built-in asset types
+// see `src/node/constants.ts`
+
+// images
+declare module '*.apng' {
+  const src: string;
+  export default src;
+}
+declare module '*.png' {
+  const src: string;
+  export default src;
+}
+declare module '*.jpg' {
+  const src: string;
+  export default src;
+}
+declare module '*.jpeg' {
+  const src: string;
+  export default src;
+}
+declare module '*.jfif' {
+  const src: string;
+  export default src;
+}
+declare module '*.pjpeg' {
+  const src: string;
+  export default src;
+}
+declare module '*.pjp' {
+  const src: string;
+  export default src;
+}
+declare module '*.gif' {
+  const src: string;
+  export default src;
+}
+declare module '*.svg' {
+  const src: string;
+  export default src;
+}
+declare module '*.ico' {
+  const src: string;
+  export default src;
+}
+declare module '*.webp' {
+  const src: string;
+  export default src;
+}
+declare module '*.avif' {
+  const src: string;
+  export default src;
+}
+
+// media
+declare module '*.mp4' {
+  const src: string;
+  export default src;
+}
+declare module '*.webm' {
+  const src: string;
+  export default src;
+}
+declare module '*.ogg' {
+  const src: string;
+  export default src;
+}
+declare module '*.mp3' {
+  const src: string;
+  export default src;
+}
+declare module '*.wav' {
+  const src: string;
+  export default src;
+}
+declare module '*.flac' {
+  const src: string;
+  export default src;
+}
+declare module '*.aac' {
+  const src: string;
+  export default src;
+}
+declare module '*.opus' {
+  const src: string;
+  export default src;
+}
+declare module '*.mov' {
+  const src: string;
+  export default src;
+}
+declare module '*.m4a' {
+  const src: string;
+  export default src;
+}
+declare module '*.vtt' {
+  const src: string;
+  export default src;
+}
+
+// fonts
+declare module '*.woff' {
+  const src: string;
+  export default src;
+}
+declare module '*.woff2' {
+  const src: string;
+  export default src;
+}
+declare module '*.eot' {
+  const src: string;
+  export default src;
+}
+declare module '*.ttf' {
+  const src: string;
+  export default src;
+}
+declare module '*.otf' {
+  const src: string;
+  export default src;
+}
+
+// other
+declare module '*.webmanifest' {
+  const src: string;
+  export default src;
+}
+declare module '*.pdf' {
+  const src: string;
+  export default src;
+}
+declare module '*.txt' {
+  const src: string;
+  export default src;
+}
+
+// wasm?init
+declare module '*.wasm?init' {
+  const initWasm: (options?: WebAssembly.Imports) => Promise<WebAssembly.Instance>;
+  export default initWasm;
+}
+
+// web worker
+declare module '*?worker' {
+  const workerConstructor: {
+    new(options?: { name?: string }): Worker;
+  };
+  export default workerConstructor;
+}
+
+declare module '*?worker&inline' {
+  const workerConstructor: {
+    new(options?: { name?: string }): Worker;
+  };
+  export default workerConstructor;
+}
+
+declare module '*?worker&url' {
+  const src: string;
+  export default src;
+}
+
+declare module '*?sharedworker' {
+  const sharedWorkerConstructor: {
+    new(options?: { name?: string }): SharedWorker;
+  };
+  export default sharedWorkerConstructor;
+}
+
+declare module '*?sharedworker&inline' {
+  const sharedWorkerConstructor: {
+    new(options?: { name?: string }): SharedWorker;
+  };
+  export default sharedWorkerConstructor;
+}
+
+declare module '*?sharedworker&url' {
+  const src: string;
+  export default src;
+}
+
+declare module '*?raw' {
+  const src: string;
+  export default src;
+}
+
+declare module '*?url' {
+  const src: string;
+  export default src;
+}
+
+declare module '*?inline' {
+  const src: string;
+  export default src;
+}

package/src/client/index.tsx

@@ -0,0 +1,19 @@
+import { Plugin } from '@nocobase/client';
+import PluginAIClient from '@nocobase/plugin-ai/client';
+import { customLLMProviderOptions } from './llm-providers/custom-llm';
+
+export class PluginCustomLLMClient extends Plugin {
+  async afterAdd() {}
+
+  async beforeLoad() {}
+
+  async load() {
+    this.aiPlugin.aiManager.registerLLMProvider('custom-llm', customLLMProviderOptions);
+  }
+
+  private get aiPlugin(): PluginAIClient {
+    return this.app.pm.get('ai');
+  }
+}
+
+export default PluginCustomLLMClient;