plugin-docpixie 1.0.0

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

@@ -0,0 +1,253 @@
+/**
+ * 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 __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)
+    __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 __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 llm_adapter_exports = {};
+__export(llm_adapter_exports, {
+  NocoBaseLLMAdapter: () => NocoBaseLLMAdapter
+});
+module.exports = __toCommonJS(llm_adapter_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_messages = require("@langchain/core/messages");
+var import_exceptions = require("../exceptions");
+const MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".pdf": "application/pdf"
+};
+class NocoBaseLLMAdapter {
+  textModel;
+  visionModel;
+  totalCost = 0;
+  /**
+   * @param textModel - LangChain BaseChatModel for text-only calls
+   * @param visionModel - LangChain BaseChatModel for vision/multimodal calls (can be same as textModel)
+   */
+  constructor(textModel, visionModel) {
+    this.textModel = textModel;
+    this.visionModel = visionModel || textModel;
+  }
+  // ═══════════════════════════════════════════
+  // ILLMProvider Implementation
+  // ═══════════════════════════════════════════
+  /**
+   * Process text-only messages using the text model.
+   */
+  async processTextMessages(messages, maxTokens = 500, temperature = 0.3) {
+    try {
+      const langchainMessages = this.convertToLangChainMessages(messages);
+      const model = this.textModel.bind({
+        max_tokens: maxTokens,
+        temperature
+      });
+      const result = await model.invoke(langchainMessages);
+      this.trackCost(result);
+      return this.extractContent(result);
+    } catch (err) {
+      throw new import_exceptions.ProviderError(
+        `Text LLM call failed: ${err.message}`,
+        "nocobase-llm"
+      );
+    }
+  }
+  /**
+   * Process multimodal messages (text + images) using the vision model.
+   * Automatically converts `image_path` content items to base64 `image_url`.
+   */
+  async processMultimodalMessages(messages, maxTokens = 500, temperature = 0.3) {
+    try {
+      const prepared = this.prepareMessages(messages);
+      const langchainMessages = this.convertToLangChainMessages(prepared);
+      const model = this.visionModel.bind({
+        max_tokens: maxTokens,
+        temperature
+      });
+      const result = await model.invoke(langchainMessages);
+      this.trackCost(result);
+      return this.extractContent(result);
+    } catch (err) {
+      throw new import_exceptions.ProviderError(
+        `Vision LLM call failed: ${err.message}`,
+        "nocobase-llm"
+      );
+    }
+  }
+  /** Accumulated cost of all API calls (USD) */
+  getTotalCost() {
+    return this.totalCost;
+  }
+  /** Reset cost counter */
+  resetCost() {
+    this.totalCost = 0;
+  }
+  // ═══════════════════════════════════════════
+  // Message Conversion
+  // ═══════════════════════════════════════════
+  /**
+   * Convert DocPixie's {role, content} messages to LangChain message objects.
+   */
+  convertToLangChainMessages(messages) {
+    return messages.map((msg) => {
+      switch (msg.role) {
+        case "system":
+          return new import_messages.SystemMessage(msg.content);
+        case "assistant":
+          return new import_messages.AIMessage(typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content));
+        case "user":
+        default:
+          return new import_messages.HumanMessage({ content: msg.content });
+      }
+    });
+  }
+  // ═══════════════════════════════════════════
+  // Image Processing (ported from OpenAICompatibleProvider)
+  // ═══════════════════════════════════════════
+  /**
+   * Walk through messages and convert `image_path` content items
+   * to OpenAI-compatible `image_url` with base64 data URLs.
+   *
+   * Input format (DocPixie internal):
+   * ```json
+   * { "type": "image_path", "image_path": "/path/to/img.jpg", "detail": "high" }
+   * ```
+   *
+   * Output format (OpenAI API):
+   * ```json
+   * { "type": "image_url", "image_url": { "url": "data:image/jpeg;base64,...", "detail": "high" } }
+   * ```
+   */
+  prepareMessages(messages) {
+    const prepared = [];
+    for (const message of messages) {
+      if (message.role === "system") {
+        prepared.push(message);
+      } else if (message.role === "user" && Array.isArray(message.content)) {
+        const processedContent = [];
+        for (const item of message.content) {
+          if (item.type === "text") {
+            processedContent.push(item);
+          } else if (item.type === "image_path") {
+            const imagePath = item.image_path;
+            if (this.validateImagePath(imagePath)) {
+              const dataUrl = this.createImageDataUrl(imagePath);
+              processedContent.push({
+                type: "image_url",
+                image_url: {
+                  url: dataUrl,
+                  detail: item.detail || "high"
+                }
+              });
+            }
+          } else {
+            processedContent.push(item);
+          }
+        }
+        prepared.push({ role: message.role, content: processedContent });
+      } else {
+        prepared.push(message);
+      }
+    }
+    return prepared;
+  }
+  // ═══════════════════════════════════════════
+  // Image Helpers
+  // ═══════════════════════════════════════════
+  /** Encode an image file to base64 string */
+  encodeImage(imagePath) {
+    try {
+      const buffer = fs.readFileSync(imagePath);
+      return buffer.toString("base64");
+    } catch (err) {
+      throw new import_exceptions.ProviderError(
+        `Failed to encode image ${imagePath}: ${err.message}`,
+        "nocobase-llm"
+      );
+    }
+  }
+  /** Create a data URL for an image (data:image/jpeg;base64,...) */
+  createImageDataUrl(imagePath) {
+    const ext = path.extname(imagePath).toLowerCase();
+    const mime = MIME_TYPES[ext] || "image/jpeg";
+    const encoded = this.encodeImage(imagePath);
+    return `data:${mime};base64,${encoded}`;
+  }
+  /** Validate that an image path exists and is readable */
+  validateImagePath(imagePath) {
+    try {
+      fs.accessSync(imagePath, fs.constants.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ═══════════════════════════════════════════
+  // Response Helpers
+  // ═══════════════════════════════════════════
+  /** Extract text content from a LangChain response */
+  extractContent(result) {
+    if (typeof result === "string") return result.trim();
+    if (result == null ? void 0 : result.content) {
+      if (typeof result.content === "string") return result.content.trim();
+      if (Array.isArray(result.content)) {
+        return result.content.filter((block) => block.type === "text").map((block) => block.text || "").join("").trim();
+      }
+    }
+    if (result == null ? void 0 : result.text) return result.text.trim();
+    throw new import_exceptions.ProviderError(
+      `Unexpected LLM response format: ${JSON.stringify(result).substring(0, 200)}`,
+      "nocobase-llm"
+    );
+  }
+  /** Track cost from LangChain response metadata */
+  trackCost(result) {
+    const usage = result == null ? void 0 : result.usage_metadata;
+    if (usage) {
+      if (typeof usage.cost === "number") {
+        this.totalCost += usage.cost;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NocoBaseLLMAdapter
+});