plugin-ai-api 1.0.24 → 1.0.25

package/dist/server/routes/completions.js

@@ -33,6 +33,7 @@ var import_openai_format = require("../utils/openai-format");
 var import_resolve_service = require("../utils/resolve-service");
 var import_user_permissions = require("../utils/user-permissions");
 var import_streaming = require("../utils/streaming");
+var import_chat_completions = require("./chat-completions");
 var import_usage = require("../usage");
 var import_billing = require("../billing");
 var import_direct_llm_context = require("../utils/direct-llm-context");
@@ -141,6 +142,8 @@ async function handleCompletions(ctx, plugin) {
     ]);
     const completionId = (0, import_openai_format.generateCompletionId)().replace("chatcmpl-", "cmpl-");
     const chatModel = provider.createModel();
+    const providerRequestParameters = (0, import_chat_completions.getProviderRequestParameters)(body);
+    (0, import_chat_completions.applyProviderRequestParameters)(chatModel, providerRequestParameters);
     (0, import_billing.markLlmProviderAttempted)(ctx);
     if (stream) {
       await handleStreamingTextCompletion(
@@ -149,10 +152,18 @@ async function handleCompletions(ctx, plugin) {
         langchainMessages,
         completionId,
         body.model,
-        body.stream_options
+        body.stream_options,
+        providerRequestParameters
       );
     } else {
-      await handleNonStreamingTextCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+      await handleNonStreamingTextCompletion(
+        ctx,
+        chatModel,
+        langchainMessages,
+        completionId,
+        body.model,
+        providerRequestParameters
+      );
     }
   } catch (err) {
     ctx.log.error("AI API completions error:", err);
@@ -170,8 +181,8 @@ async function handleCompletions(ctx, plugin) {
     }
   }
 }
-async function handleNonStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName) {
-  const result = await chatModel.invoke(messages);
+async function handleNonStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName, providerRequestParameters) {
+  const result = await chatModel.invoke(messages, providerRequestParameters);
   let text = "";
   if (typeof result.content === "string") {
     text = result.content;
@@ -179,10 +190,15 @@ async function handleNonStreamingTextCompletion(ctx, chatModel, messages, comple
     const textPart = result.content.find((c) => c.type === "text");
     text = (textPart == null ? void 0 : textPart.text) || JSON.stringify(result.content);
   }
-  const usage = (0, import_usage.setAiApiUsageResult)(ctx, result.usage_metadata, {
-    gatewayResponseId: completionId,
-    providerRequestId: (0, import_usage.extractProviderRequestId)(result)
-  });
+  const usage = (0, import_usage.setAiApiUsageResult)(
+    ctx,
+    result.usage_metadata,
+    {
+      gatewayResponseId: completionId,
+      providerRequestId: (0, import_usage.extractProviderRequestId)(result)
+    },
+    result.response_metadata
+  );
   ctx.status = 200;
   ctx.body = {
     id: completionId,
@@ -198,10 +214,15 @@ async function handleNonStreamingTextCompletion(ctx, chatModel, messages, comple
         finish_reason: "stop"
       }
     ],
-    usage: usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+    usage: usage ? {
+      prompt_tokens: usage.prompt_tokens,
+      completion_tokens: usage.completion_tokens,
+      total_tokens: usage.total_tokens,
+      prompt_tokens_details: { cached_tokens: usage.prompt_cache_tokens ?? null }
+    } : { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, prompt_tokens_details: { cached_tokens: null } }
   };
 }
-async function handleStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName, streamOptions) {
+async function handleStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName, streamOptions, providerRequestParameters) {
   ctx.set({
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
@@ -214,6 +235,7 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
   let providerRequestId;
   try {
     const stream = await chatModel.stream(messages, {
+      ...providerRequestParameters,
       stream_options: { ...streamOptions, include_usage: true },
       signal: requestAbort.signal
     });

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

@@ -0,0 +1,262 @@
+/**
+ * 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 file_processor_exports = {};
+__export(file_processor_exports, {
+  FileProcessorError: () => FileProcessorError,
+  FileProcessorService: () => FileProcessorService,
+  base64FileForwarder: () => base64FileForwarder,
+  fetchFileAsBase64: () => fetchFileAsBase64,
+  httpFileUrlFetcher: () => httpFileUrlFetcher,
+  pdfFileProcessor: () => pdfFileProcessor
+});
+module.exports = __toCommonJS(file_processor_exports);
+var import_path = require("path");
+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 ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+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 getUrlString(value) {
+  if (typeof value === "string") return value;
+  if (isRecord(value) && typeof value.url === "string") return value.url;
+  return void 0;
+}
+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;
+}
+async function fetchFileAsBase64(url, options = {}) {
+  const maxSize = options.maxSizeBytes ?? DEFAULT_MAX_FILE_SIZE;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const allowedProtocols = options.allowedProtocols ? new Set(options.allowedProtocols) : ALLOWED_PROTOCOLS;
+  let protocol;
+  try {
+    protocol = new URL(url).protocol;
+  } catch {
+    throw new FileProcessorError("invalid_url", `File URL '${url}' is not a valid URL.`);
+  }
+  if (!allowedProtocols.has(protocol)) {
+    throw new FileProcessorError("unsupported_protocol", `File URL protocol '${protocol}' is not allowed.`);
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    if (!response.ok) {
+      throw new FileProcessorError(
+        "fetch_failed",
+        `Failed to fetch file from '${url}': ${response.status} ${response.statusText}`
+      );
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && Number(contentLength) > maxSize) {
+      throw new FileProcessorError("file_too_large", `File at '${url}' 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 '${url}' 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(url, 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 context.ctx.db.getRepository("aiApiConfig").findOne();
+    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,
+  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,22 @@ function normalizeUsage(value) {
   return {
     prompt_tokens: prompt,
     completion_tokens: completion,
-    total_tokens: total
+    total_tokens: total,
+    prompt_cache_tokens: extractPromptCacheTokens(source)
   };
 }
-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 +162,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,

package/dist/server/utils/direct-llm-context.js

@@ -27,6 +27,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var direct_llm_context_exports = {};
 __export(direct_llm_context_exports, {
   DirectLlmContextError: () => DirectLlmContextError,
+  parseImageDimensions: () => parseImageDimensions,
   prepareDirectLlmContext: () => prepareDirectLlmContext
 });
 module.exports = __toCommonJS(direct_llm_context_exports);
@@ -45,20 +46,159 @@ function positiveInteger(value) {
   const parsed = Number(value);
   return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
 }
-function hasImageContent(value) {
-  return Array.isArray(value) && value.some(
-    (block) => typeof block === "object" && block !== null && block.type === "image_url"
-  );
-}
 function estimateValueTokens(value) {
   if (value === void 0) return 0;
   return Math.ceil(Buffer.byteLength(JSON.stringify(value), "utf8") / 3);
 }
-function estimateMessagesTokens(messages) {
-  return messages.reduce((total, message) => total + estimateValueTokens(message) + 4, 0);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readBigEndian(buf, offset) {
+  return buf.readUInt32BE(offset);
+}
+function readUInt16BE(buf, offset) {
+  return buf.readUInt16BE(offset);
+}
+function readLittleEndian(buf, offset) {
+  return buf.readUInt16LE(offset);
+}
+function parsePngDimensions(buffer) {
+  if (buffer.length < 24) return void 0;
+  return { width: readBigEndian(buffer, 16), height: readBigEndian(buffer, 20) };
+}
+function parseJpegDimensions(buffer) {
+  let offset = 2;
+  while (offset < buffer.length) {
+    if (buffer[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = buffer[offset + 1];
+    if (marker >= 192 && marker <= 195 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207) {
+      if (offset + 9 <= buffer.length) {
+        return { height: readUInt16BE(buffer, offset + 5), width: readUInt16BE(buffer, offset + 7) };
+      }
+      return void 0;
+    }
+    if (marker === 217 || offset + 4 >= buffer.length) break;
+    const segmentLength = buffer.readUInt16BE(offset + 2);
+    offset += 2 + segmentLength;
+  }
+  return void 0;
+}
+function parseGifDimensions(buffer) {
+  if (buffer.length < 10) return void 0;
+  return { width: readLittleEndian(buffer, 6), height: readLittleEndian(buffer, 8) };
+}
+function parseWebpDimensions(buffer) {
+  if (buffer.length < 30) return void 0;
+  const riff = buffer.toString("ascii", 0, 4);
+  const webp = buffer.toString("ascii", 8, 12);
+  if (riff !== "RIFF" || webp !== "WEBP") return void 0;
+  const chunkType = buffer.toString("ascii", 12, 16);
+  if (chunkType === "VP8 " && buffer.length >= 26) {
+    return { width: readLittleEndian(buffer, 26), height: readLittleEndian(buffer, 28) };
+  }
+  if (chunkType === "VP8L" && buffer.length >= 24) {
+    const bits = buffer.readUInt32LE(21);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >> 14 & 16383) + 1
+    };
+  }
+  if (chunkType === "VP8X" && buffer.length >= 30) {
+    return {
+      width: ((buffer[24] | buffer[25] << 8 | buffer[26] << 16) & 16777215) + 1,
+      height: ((buffer[27] | buffer[28] << 8 | buffer[29] << 16) & 16777215) + 1
+    };
+  }
+  return void 0;
+}
+function parseImageDimensions(buffer) {
+  if (buffer.length < 12) return void 0;
+  const header = buffer.toString("binary", 0, 4);
+  if (header === "\x89PNG") return parsePngDimensions(buffer);
+  if (header === "GIF8") return parseGifDimensions(buffer);
+  if (header === "RIFF") return parseWebpDimensions(buffer);
+  if (buffer[0] === 255 && buffer[1] === 216) return parseJpegDimensions(buffer);
+  return void 0;
 }
-function containsUnsupportedContent(messages) {
-  return messages.some((message) => hasImageContent(message.content));
+const VISION_TILE_SIZE = 512;
+const VISION_LOW_DETAIL_TOKENS = 85;
+const VISION_TILE_TOKENS = 170;
+const VISION_HTTP_URL_ESTIMATE = 1024;
+const FILE_BASE64_FALLBACK_TOKENS = 1024;
+function estimateVisionTokensForDimensions(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return VISION_LOW_DETAIL_TOKENS;
+  }
+  const tilesX = Math.ceil(width / VISION_TILE_SIZE);
+  const tilesY = Math.ceil(height / VISION_TILE_SIZE);
+  return VISION_LOW_DETAIL_TOKENS + tilesX * tilesY * VISION_TILE_TOKENS;
+}
+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 estimateImageUrlTokens(imageUrl) {
+  const url = typeof imageUrl === "string" ? imageUrl : isRecord(imageUrl) ? String(imageUrl.url ?? "") : "";
+  if (!url) return 0;
+  if (url.startsWith("data:")) {
+    const decoded = decodeBase64DataUrl(url);
+    if (!decoded) return FILE_BASE64_FALLBACK_TOKENS;
+    if (!decoded.mimeType.startsWith("image/")) return FILE_BASE64_FALLBACK_TOKENS;
+    const dimensions = parseImageDimensions(decoded.buffer);
+    return dimensions ? estimateVisionTokensForDimensions(dimensions.width, dimensions.height) : VISION_LOW_DETAIL_TOKENS;
+  }
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return VISION_HTTP_URL_ESTIMATE;
+  }
+  return 0;
+}
+function estimateFileBlockTokens(block) {
+  const file = isRecord(block.file) ? block.file : void 0;
+  if (!file) return 0;
+  const fileData = String(file.file_data ?? "");
+  if (fileData.startsWith("data:")) {
+    const decoded = decodeBase64DataUrl(fileData);
+    if (decoded) {
+      return Math.max(1, Math.ceil(decoded.buffer.length / 3));
+    }
+    return FILE_BASE64_FALLBACK_TOKENS;
+  }
+  return FILE_BASE64_FALLBACK_TOKENS;
+}
+function estimateContentBlockTokens(block) {
+  if (!isRecord(block)) return estimateValueTokens(block);
+  const type = typeof block.type === "string" ? block.type : void 0;
+  if (type === "text") {
+    return typeof block.text === "string" ? estimateValueTokens(block.text) + 4 : 4;
+  }
+  if (type === "image_url") {
+    return estimateImageUrlTokens(block.image_url) + 4;
+  }
+  if (type === "file") {
+    return estimateFileBlockTokens(block) + 4;
+  }
+  if (type === "file_url") {
+    return VISION_HTTP_URL_ESTIMATE + 4;
+  }
+  return estimateValueTokens(block) + 4;
+}
+function estimateMessageTokens(message) {
+  if (Array.isArray(message.content)) {
+    return message.content.reduce((total, block) => total + estimateContentBlockTokens(block), 4);
+  }
+  return estimateValueTokens(message) + 4;
+}
+function estimateMessagesTokens(messages) {
+  return messages.reduce((total, message) => total + estimateMessageTokens(message), 0);
 }
 function isInstruction(message) {
   return message.role === "system" || message.role === "developer";
@@ -119,12 +259,6 @@ function resolveReservedOutputTokens(options, metadata) {
   return requested ?? metadata.maxCompletionTokens;
 }
 async function prepareDirectLlmContext(ctx, options) {
-  if (containsUnsupportedContent(options.messages)) {
-    throw new DirectLlmContextError(
-      "context_estimation_unsupported",
-      "Context enforcement does not support image_url content without a model-specific vision token estimator."
-    );
-  }
   const [metadata, behavior] = await Promise.all([
     loadModelMetadata(ctx, options.serviceName, options.modelId),
     resolveOverflowBehavior(ctx)
@@ -180,5 +314,6 @@ async function prepareDirectLlmContext(ctx, options) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DirectLlmContextError,
+  parseImageDimensions,
   prepareDirectLlmContext
 });

package/dist/server/utils/openai-format.js

@@ -99,7 +99,19 @@ function toOpenAIResponse(options) {
         finish_reason: finishReason
       }
     ],
-    usage: usage || { prompt_tokens: null, completion_tokens: null, total_tokens: null }
+    usage: usage ? {
+      prompt_tokens: usage.prompt_tokens ?? null,
+      completion_tokens: usage.completion_tokens ?? null,
+      total_tokens: usage.total_tokens ?? null,
+      prompt_tokens_details: {
+        cached_tokens: usage.prompt_cache_tokens ?? null
+      }
+    } : {
+      prompt_tokens: null,
+      completion_tokens: null,
+      total_tokens: null,
+      prompt_tokens_details: { cached_tokens: null }
+    }
   };
 }
 function toOpenAIStreamChunk(options) {
@@ -129,7 +141,14 @@ function toOpenAIUsageChunk(options) {
     created: Math.floor(Date.now() / 1e3),
     model,
     choices: [],
-    usage
+    usage: {
+      prompt_tokens: usage.prompt_tokens,
+      completion_tokens: usage.completion_tokens,
+      total_tokens: usage.total_tokens,
+      prompt_tokens_details: {
+        cached_tokens: usage.prompt_cache_tokens ?? null
+      }
+    }
   };
 }
 function toOpenAIEmbeddingsResponse(options) {