plugin-ai-api 1.0.24 → 1.0.28

package/dist/server/services/file-processor.js

@@ -0,0 +1,426 @@
+/**
+ * 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 file_processor_exports = {};
+__export(file_processor_exports, {
+  FileProcessorError: () => FileProcessorError,
+  FileProcessorService: () => FileProcessorService,
+  base64FileForwarder: () => base64FileForwarder,
+  fetchFileAsBase64: () => fetchFileAsBase64,
+  httpFileUrlFetcher: () => httpFileUrlFetcher,
+  isBlockedAddress: () => isBlockedAddress,
+  pdfFileProcessor: () => pdfFileProcessor
+});
+module.exports = __toCommonJS(file_processor_exports);
+var import_dns = __toESM(require("dns"));
+var import_net = require("net");
+var import_path = require("path");
+var import_request_cache = require("../utils/request-cache");
+class FileProcessorError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FileProcessorError";
+  }
+}
+const DEFAULT_MAX_FILE_SIZE = 50 * 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_REDIRECTS = 5;
+const ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+class FileProcessorService {
+  processors = [];
+  pdfRenderer = null;
+  register(processor) {
+    this.unregister(processor.name);
+    this.processors.push(processor);
+  }
+  unregister(name) {
+    this.processors = this.processors.filter((p) => p.name !== name);
+  }
+  async process(block, context) {
+    const processor = [...this.processors].reverse().find((p) => p.canHandle(block));
+    if (!processor) {
+      return block;
+    }
+    return processor.process(block, context);
+  }
+  list() {
+    return [...this.processors];
+  }
+  /**
+   * Register a renderer used to convert PDF pages into PNG images when
+   * `pdfRenderPagesAsImages` is enabled in the AI API config.
+   */
+  registerPdfRenderer(renderer) {
+    this.pdfRenderer = renderer;
+  }
+  unregisterPdfRenderer() {
+    this.pdfRenderer = null;
+  }
+  getPdfRenderer() {
+    return this.pdfRenderer;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractFilename(url, contentDisposition) {
+  if (contentDisposition) {
+    const match = contentDisposition.match(/filename="?([^"]+)"?/);
+    if (match) return match[1];
+  }
+  try {
+    const pathname = new URL(url).pathname;
+    if (pathname) return (0, import_path.basename)(pathname);
+  } catch {
+  }
+  return void 0;
+}
+function parseIpv4Octets(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return void 0;
+  const octets = [];
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return void 0;
+    const value = Number(part);
+    if (value > 255) return void 0;
+    octets.push(value);
+  }
+  return octets;
+}
+function isBlockedIpv4(ip) {
+  const octets = parseIpv4Octets(ip);
+  if (!octets) return true;
+  const [a, b] = octets;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 0) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function parseHexGroup(group) {
+  if (group.length < 1 || group.length > 4 || !/^[0-9a-fA-F]+$/.test(group)) return void 0;
+  return parseInt(group, 16);
+}
+function expandIpv6(input) {
+  let address = input;
+  const zoneIndex = address.indexOf("%");
+  if (zoneIndex !== -1) address = address.slice(0, zoneIndex);
+  if (!address) return void 0;
+  const lastColon = address.lastIndexOf(":");
+  if (lastColon !== -1 && address.includes(".", lastColon)) {
+    const octets = parseIpv4Octets(address.slice(lastColon + 1));
+    if (!octets) return void 0;
+    const high = (octets[0] << 8 | octets[1]).toString(16);
+    const low = (octets[2] << 8 | octets[3]).toString(16);
+    address = `${address.slice(0, lastColon + 1)}${high}:${low}`;
+  }
+  const groups = [];
+  const doubleColonIndex = address.indexOf("::");
+  if (doubleColonIndex !== -1) {
+    if (address.indexOf("::", doubleColonIndex + 1) !== -1) return void 0;
+    const head = address.slice(0, doubleColonIndex);
+    const tail = address.slice(doubleColonIndex + 2);
+    const headGroups = head === "" ? [] : head.split(":");
+    const tailGroups = tail === "" ? [] : tail.split(":");
+    const fillCount = 8 - headGroups.length - tailGroups.length;
+    if (fillCount < 1) return void 0;
+    const allGroups = [...headGroups];
+    for (let i = 0; i < fillCount; i += 1) allGroups.push("0");
+    allGroups.push(...tailGroups);
+    for (const group of allGroups) {
+      const parsed = parseHexGroup(group);
+      if (parsed === void 0) return void 0;
+      groups.push(parsed);
+    }
+  } else {
+    for (const group of address.split(":")) {
+      const parsed = parseHexGroup(group);
+      if (parsed === void 0) return void 0;
+      groups.push(parsed);
+    }
+  }
+  return groups.length === 8 ? groups : void 0;
+}
+function isBlockedIpv6(ip) {
+  const groups = expandIpv6(ip);
+  if (!groups) return true;
+  const [g0, g1, g2, g3, g4, g5, g6, g7] = groups;
+  if (groups.every((group) => group === 0)) return true;
+  if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0 && g6 === 0 && g7 === 1) {
+    return true;
+  }
+  const isIpv4Mapped = g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 65535;
+  const isIpv4Compatible = g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0;
+  const isNat64 = g0 === 100 && g1 === 65435 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0;
+  if (isIpv4Mapped || isIpv4Compatible || isNat64) {
+    const embedded = `${g6 >> 8 & 255}.${g6 & 255}.${g7 >> 8 & 255}.${g7 & 255}`;
+    return isBlockedIpv4(embedded);
+  }
+  if ((g0 & 65024) === 64512) return true;
+  if ((g0 & 65472) === 65152) return true;
+  if ((g0 & 65280) === 65280) return true;
+  return false;
+}
+function isBlockedAddress(ip) {
+  const version = (0, import_net.isIP)(ip);
+  if (version === 4) return isBlockedIpv4(ip);
+  if (version === 6) return isBlockedIpv6(ip);
+  return true;
+}
+async function assertHostAllowed(hostname) {
+  if ((0, import_net.isIP)(hostname) !== 0) {
+    if (isBlockedAddress(hostname)) {
+      throw new FileProcessorError("blocked_host", `Host '${hostname}' is a blocked address.`);
+    }
+    return;
+  }
+  let addresses;
+  try {
+    addresses = await import_dns.default.promises.lookup(hostname, { all: true });
+  } catch (error) {
+    const message = error instanceof Error && error.message ? error.message : String(error);
+    throw new FileProcessorError("fetch_failed", `Could not resolve host '${hostname}': ${message}`);
+  }
+  if (!addresses.length) {
+    throw new FileProcessorError("fetch_failed", `Could not resolve host '${hostname}'.`);
+  }
+  for (const { address } of addresses) {
+    if (isBlockedAddress(address)) {
+      throw new FileProcessorError("blocked_host", `Host '${hostname}' resolves to blocked address '${address}'.`);
+    }
+  }
+}
+async function fetchWithSsrfGuard(initialUrl, options) {
+  let currentUrl = initialUrl;
+  for (let hop = 0; ; hop += 1) {
+    let parsed;
+    try {
+      parsed = new URL(currentUrl);
+    } catch {
+      throw new FileProcessorError("invalid_url", `File URL '${currentUrl}' is not a valid URL.`);
+    }
+    if (!options.allowedProtocols.has(parsed.protocol)) {
+      throw new FileProcessorError("unsupported_protocol", `File URL protocol '${parsed.protocol}' is not allowed.`);
+    }
+    const hostname = parsed.hostname.startsWith("[") && parsed.hostname.endsWith("]") ? parsed.hostname.slice(1, -1) : parsed.hostname;
+    await assertHostAllowed(hostname);
+    const response = await fetch(currentUrl, { signal: options.signal, redirect: "manual" });
+    if (!REDIRECT_STATUSES.has(response.status)) {
+      return { response, finalUrl: currentUrl };
+    }
+    if (hop >= options.maxRedirects) {
+      throw new FileProcessorError(
+        "too_many_redirects",
+        `File URL '${initialUrl}' exceeded the limit of ${options.maxRedirects} redirects.`
+      );
+    }
+    const location = response.headers.get("location");
+    if (!location) {
+      throw new FileProcessorError("fetch_failed", `Redirect from '${currentUrl}' is missing a Location header.`);
+    }
+    try {
+      currentUrl = new URL(location, currentUrl).toString();
+    } catch {
+      throw new FileProcessorError(
+        "invalid_url",
+        `Redirect Location '${location}' from '${currentUrl}' is not a valid URL.`
+      );
+    }
+  }
+}
+async function fetchFileAsBase64(url, options = {}) {
+  const maxSize = options.maxSizeBytes ?? DEFAULT_MAX_FILE_SIZE;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+  const allowedProtocols = options.allowedProtocols ? new Set(options.allowedProtocols) : ALLOWED_PROTOCOLS;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const { response, finalUrl } = await fetchWithSsrfGuard(url, {
+      allowedProtocols,
+      maxRedirects,
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new FileProcessorError(
+        "fetch_failed",
+        `Failed to fetch file from '${finalUrl}': ${response.status} ${response.statusText}`
+      );
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && Number(contentLength) > maxSize) {
+      throw new FileProcessorError("file_too_large", `File at '${finalUrl}' exceeds maximum allowed size.`);
+    }
+    const contentType = response.headers.get("content-type") || void 0;
+    if (options.allowedContentTypes && contentType && !options.allowedContentTypes.some((type) => contentType.includes(type))) {
+      throw new FileProcessorError("content_type_not_allowed", `File content type '${contentType}' is not allowed.`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length > maxSize) {
+      throw new FileProcessorError("file_too_large", `File at '${finalUrl}' exceeds maximum allowed size.`);
+    }
+    const mimeType = (contentType == null ? void 0 : contentType.split(";")[0].trim()) ?? "application/octet-stream";
+    const contentDisposition = response.headers.get("content-disposition");
+    const filename = extractFilename(finalUrl, contentDisposition) ?? "file";
+    return {
+      fileData: `data:${mimeType};base64,${buffer.toString("base64")}`,
+      mimeType,
+      filename
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+const base64FileForwarder = {
+  name: "base64FileForwarder",
+  canHandle(block) {
+    if (block.type !== "file") return false;
+    const file = isRecord(block.file) ? block.file : void 0;
+    if (!file) return false;
+    const fileData = String(file.file_data ?? "");
+    return fileData.startsWith("data:") && fileData.includes(";base64,");
+  },
+  async process(block) {
+    return block;
+  }
+};
+const httpFileUrlFetcher = {
+  name: "httpFileUrlFetcher",
+  canHandle(block) {
+    if (block.type !== "file_url") return false;
+    const fileUrl = isRecord(block.file_url) ? block.file_url : void 0;
+    if (!fileUrl) return false;
+    const url = String(fileUrl.url ?? "");
+    return url.startsWith("http://") || url.startsWith("https://");
+  },
+  async process(block) {
+    const fileUrl = isRecord(block.file_url) ? block.file_url : void 0;
+    const url = String((fileUrl == null ? void 0 : fileUrl.url) ?? "");
+    if (!url) {
+      throw new FileProcessorError("missing_url", "file_url block requires a 'url' property.");
+    }
+    const { fileData, mimeType, filename } = await fetchFileAsBase64(url);
+    return {
+      type: "file",
+      file: {
+        file_data: fileData,
+        mime_type: mimeType,
+        filename: filename || "file"
+      }
+    };
+  }
+};
+function decodeBase64DataUrl(url) {
+  const match = /^data:([^;]+);base64,([A-Za-z0-9+/]+=*)$/.exec(url);
+  if (!match) return void 0;
+  try {
+    const buffer = Buffer.from(match[2], "base64");
+    return { mimeType: match[1].toLowerCase(), buffer };
+  } catch {
+    return void 0;
+  }
+}
+function isPdfBuffer(buffer) {
+  return buffer.length >= 4 && buffer.toString("binary", 0, 4) === "%PDF";
+}
+function isPdfFileBlock(block) {
+  if (block.type !== "file") return false;
+  const file = isRecord(block.file) ? block.file : void 0;
+  if (!file) return false;
+  const fileData = String(file.file_data ?? "");
+  if (!fileData.startsWith("data:")) return false;
+  const mimeType = String(file.mime_type ?? "").toLowerCase();
+  if (mimeType === "application/pdf") return true;
+  if (fileData.startsWith("data:application/pdf")) return true;
+  const decoded = decodeBase64DataUrl(fileData);
+  if (decoded && isPdfBuffer(decoded.buffer)) return true;
+  return false;
+}
+function getPluginFromContext(context) {
+  var _a, _b, _c;
+  return (_c = (_b = (_a = context.ctx.app) == null ? void 0 : _a.pm) == null ? void 0 : _b.get) == null ? void 0 : _c.call(_b, "plugin-ai-api");
+}
+const pdfFileProcessor = {
+  name: "pdfFileProcessor",
+  canHandle(block) {
+    return isPdfFileBlock(block);
+  },
+  async process(block, context) {
+    var _a, _b, _c, _d;
+    const config = await (0, import_request_cache.getAiApiConfig)(context.ctx);
+    if (!(config == null ? void 0 : config.pdfRenderPagesAsImages)) {
+      return block;
+    }
+    const plugin = getPluginFromContext(context);
+    const renderer = (_b = (_a = plugin == null ? void 0 : plugin.fileProcessorService) == null ? void 0 : _a.getPdfRenderer) == null ? void 0 : _b.call(_a);
+    if (!renderer) {
+      (_d = (_c = context.ctx.log) == null ? void 0 : _c.warn) == null ? void 0 : _d.call(
+        _c,
+        "[pdfFileProcessor] pdfRenderPagesAsImages is enabled but no PdfToImageRenderer is registered. Forwarding PDF as a file block."
+      );
+      return block;
+    }
+    const file = isRecord(block.file) ? block.file : void 0;
+    const fileData = String((file == null ? void 0 : file.file_data) ?? "");
+    const decoded = decodeBase64DataUrl(fileData);
+    if (!decoded) {
+      return block;
+    }
+    const pages = await renderer.render(decoded.buffer);
+    return pages.map((buffer) => ({
+      type: "image_url",
+      image_url: { url: `data:image/png;base64,${buffer.toString("base64")}` }
+    }));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileProcessorError,
+  FileProcessorService,
+  base64FileForwarder,
+  fetchFileAsBase64,
+  httpFileUrlFetcher,
+  isBlockedAddress,
+  pdfFileProcessor
+});

package/dist/server/usage.js

@@ -42,6 +42,24 @@ function getAiApiState(ctx) {
 function normalizeTokenCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
+function extractPromptCacheTokens(source) {
+  const inputDetails = source.input_token_details;
+  if (inputDetails && typeof inputDetails === "object") {
+    const cacheRead = inputDetails.cache_read;
+    if (typeof cacheRead === "number") return cacheRead;
+    const cachedTokens = inputDetails.cached_tokens;
+    if (typeof cachedTokens === "number") return cachedTokens;
+  }
+  const promptDetails = source.prompt_tokens_details;
+  if (promptDetails && typeof promptDetails === "object") {
+    const cachedTokens = promptDetails.cached_tokens;
+    if (typeof cachedTokens === "number") return cachedTokens;
+  }
+  if (typeof source.cached_tokens === "number") return source.cached_tokens;
+  if (typeof source.cache_read_tokens === "number") return source.cache_read_tokens;
+  if (typeof source.cache_read === "number") return source.cache_read;
+  return null;
+}
 function normalizeUsage(value) {
   if (!value || typeof value !== "object") return void 0;
   const source = value;
@@ -55,11 +73,25 @@ function normalizeUsage(value) {
   return {
     prompt_tokens: prompt,
     completion_tokens: completion,
-    total_tokens: total
+    total_tokens: total,
+    // Keep normalizeUsage idempotent: streaming routes normalize the chunk
+    // usage once and hand the result to setAiApiUsageResult, which normalizes
+    // again — an already-extracted prompt_cache_tokens must survive that pass.
+    prompt_cache_tokens: extractPromptCacheTokens(source) ?? normalizeTokenCount(source.prompt_cache_tokens)
   };
 }
-function setAiApiUsageResult(ctx, value, metadata = {}) {
-  const usage = normalizeUsage(value);
+function setAiApiUsageResult(ctx, value, metadata = {}, responseMetadata) {
+  let usage = normalizeUsage(value);
+  if ((usage == null ? void 0 : usage.prompt_cache_tokens) === null && responseMetadata && typeof responseMetadata === "object") {
+    const responseMetaRecord = responseMetadata;
+    let cacheTokens = extractPromptCacheTokens(responseMetaRecord);
+    if (cacheTokens === null && responseMetaRecord.usage && typeof responseMetaRecord.usage === "object") {
+      cacheTokens = extractPromptCacheTokens(responseMetaRecord.usage);
+    }
+    if (cacheTokens !== null) {
+      usage = { ...usage, prompt_cache_tokens: cacheTokens };
+    }
+  }
   getAiApiState(ctx).aiApiUsageResult = usage ? { source: "provider", usage, ...metadata } : { source: "unavailable", ...metadata };
   (0, import_app_observability.addAiApiUsage)(ctx, usage);
   return usage;
@@ -133,6 +165,7 @@ async function finishUsageRecord(ctx, id, startedAt, status) {
     inputTokens: (usage == null ? void 0 : usage.prompt_tokens) ?? null,
     outputTokens: (usage == null ? void 0 : usage.completion_tokens) ?? null,
     totalTokens: (usage == null ? void 0 : usage.total_tokens) ?? null,
+    promptCacheTokens: (usage == null ? void 0 : usage.prompt_cache_tokens) ?? null,
     resolvedService: ((_c = (_b = state.aiApiLlmBilling) == null ? void 0 : _b.resolution) == null ? void 0 : _c.service) ?? null,
     resolvedProvider: ((_e = (_d = state.aiApiLlmBilling) == null ? void 0 : _d.resolution) == null ? void 0 : _e.provider) ?? null,
     resolvedModel: ((_g = (_f = state.aiApiLlmBilling) == null ? void 0 : _f.resolution) == null ? void 0 : _g.model) ?? null,
@@ -141,6 +174,7 @@ async function finishUsageRecord(ctx, id, startedAt, status) {
     costStatus: billing.costStatus ?? null,
     modelPriceId: billing.modelPriceId ?? null,
     quotaPolicyId: billing.quotaPolicyId ?? null,
+    groupId: billing.groupId ?? null,
     inputPricePerMillionTokens: billing.inputPricePerMillionTokens ?? null,
     outputPricePerMillionTokens: billing.outputPricePerMillionTokens ?? null,
     fixedCostPerRequest: billing.fixedCostPerRequest ?? null,