plugin-ai-api 1.0.23 → 1.0.25

package/dist/server/routes/chat-completions.js

@@ -41,8 +41,11 @@ var import_role_permission = require("../middleware/role-permission");
 var import_user_permissions = require("../utils/user-permissions");
 var import_usage = require("../usage");
 var import_billing = require("../billing");
+var import_direct_llm_context = require("../utils/direct-llm-context");
 var import_app_observability = require("../utils/app-observability");
+var import_file_processor = require("../services/file-processor");
 async function handleChatCompletions(ctx, plugin) {
+  var _a;
   const body = ctx.request.body;
   if (!(body == null ? void 0 : body.model)) {
     ctx.status = 400;
@@ -126,7 +129,6 @@ async function handleChatCompletions(ctx, plugin) {
       ctx.body = (0, import_openai_format.toOpenAIError)(500, `Provider '${service.provider}' not registered`, "server_error");
       return;
     }
-    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
     const providerRequestParameters = getProviderRequestParameters(body);
     if (stream) {
       const streamOptions = isRecord(body.stream_options) ? body.stream_options : {};
@@ -146,12 +148,6 @@ async function handleChatCompletions(ctx, plugin) {
     if (body.frequency_penalty !== void 0) modelOptions.frequencyPenalty = body.frequency_penalty;
     if (body.presence_penalty !== void 0) modelOptions.presencePenalty = body.presence_penalty;
     if (body.stop !== void 0) modelOptions.stop = body.stop;
-    const Provider = providerMeta.provider;
-    const provider = new Provider({
-      app: ctx.app,
-      serviceOptions: service.options,
-      modelOptions
-    });
     let systemPrompt = "";
     if (config == null ? void 0 : config.defaultAiEmployee) {
       if (!(0, import_role_permission.checkEmployeeAccess)(ctx, config.defaultAiEmployee)) {
@@ -171,11 +167,33 @@ async function handleChatCompletions(ctx, plugin) {
         systemPrompt = employee.about || employee.defaultPrompt || "";
       }
     }
-    const messages = [...body.messages];
+    let messages = [...body.messages];
     const hasSystemMessage = messages.some((m) => m.role === "system");
     if (systemPrompt && !hasSystemMessage) {
       messages.unshift({ role: "system", content: systemPrompt });
     }
+    messages = await Promise.all(
+      messages.map(async (msg) => ({
+        ...msg,
+        content: await processMessageContentFileBlocks(msg.content, ctx, plugin)
+      }))
+    );
+    const preparedContext = await (0, import_direct_llm_context.prepareDirectLlmContext)(ctx, {
+      serviceName: service.name,
+      modelId,
+      messages,
+      tools: body.tools,
+      maxCompletionTokens: body.max_completion_tokens,
+      maxTokens: body.max_tokens
+    });
+    messages = preparedContext.messages;
+    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
+    const Provider = providerMeta.provider;
+    const provider = new Provider({
+      app: ctx.app,
+      serviceOptions: service.options,
+      modelOptions
+    });
     const langchainMessages = messages.map((msg) => {
       const role = msg.role === "assistant" ? "ai" : msg.role;
       const content = normalizeMessageContent(msg.content);
@@ -218,15 +236,17 @@ async function handleChatCompletions(ctx, plugin) {
     }
   } catch (err) {
     ctx.log.error("AI API chat completions error:", err);
-    if (!ctx.res.headersSent) {
+    if (!((_a = ctx.res) == null ? void 0 : _a.headersSent)) {
       const isQuotaError = err instanceof import_billing.AiApiQuotaError;
-      ctx.status = isQuotaError ? 429 : 500;
+      const isContextError = err instanceof import_direct_llm_context.DirectLlmContextError;
+      const isFileError = err instanceof import_file_processor.FileProcessorError;
+      ctx.status = isQuotaError ? 429 : isContextError || isFileError ? 400 : 500;
       if (isQuotaError) ctx.set("X-RateLimit-Reason", err.code);
       ctx.body = (0, import_openai_format.toOpenAIError)(
         ctx.status,
         getErrorMessage(err, "Internal server error"),
-        isQuotaError ? "quota_error" : "server_error",
-        isQuotaError ? err.code : void 0
+        isQuotaError ? "quota_error" : isContextError || isFileError ? "invalid_request_error" : "server_error",
+        isQuotaError || isContextError || isFileError ? err.code : void 0
       );
     }
   }
@@ -240,10 +260,15 @@ async function handleNonStreamingCompletion(ctx, chatModel, messages, completion
     const textPart = result.content.find((c) => c.type === "text");
     content = (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;
   const toolCalls = normalizeToolCalls(result.tool_calls);
   ctx.body = (0, import_openai_format.toOpenAIResponse)({
@@ -375,8 +400,9 @@ async function handleStreamingCompletion(ctx, chatModel, messages, completionId,
 function getErrorMessage(error, fallback) {
   return error instanceof Error && error.message ? error.message : fallback;
 }
-const SUPPORTED_CONTENT_BLOCK_TYPES = /* @__PURE__ */ new Set(["text", "image_url"]);
+const SUPPORTED_CONTENT_BLOCK_TYPES = /* @__PURE__ */ new Set(["text", "image_url", "file", "file_url"]);
 const BASE64_DATA_URL_PATTERN = /^data:(\w+\/\w+);base64,([A-Za-z0-9+/]+=*)$/;
+const FILE_BASE64_DATA_URL_PATTERN = /^data:([^;\s]+);base64,([A-Za-z0-9+/]+=*)$/;
 function isDecodableBase64(payload) {
   try {
     return Buffer.from(payload, "base64").toString("base64") === payload;
@@ -428,13 +454,50 @@ function describeContentBlockProblem(block) {
   const type = typeof block.type === "string" ? block.type : void 0;
   if (!type) return "each content block requires a 'type' field";
   if (!SUPPORTED_CONTENT_BLOCK_TYPES.has(type)) {
-    return `content block type '${type}' is not supported \u2014 this gateway forwards 'text' and 'image_url' only. Send documents as text, or inline them as an 'image_url' data URL if the model reads images`;
+    return `content block type '${type}' is not supported \u2014 this gateway forwards 'text', 'image_url', 'file', and 'file_url' only. Send documents as text, or inline them as a 'file' / 'file_url' block`;
   }
   if (type === "text") {
     return typeof block.text === "string" ? void 0 : "a 'text' block requires a string 'text' field";
   }
+  if (type === "file") {
+    return describeFileProblem(block.file);
+  }
+  if (type === "file_url") {
+    return describeFileUrlProblem(block.file_url);
+  }
   return describeImageUrlProblem(block.image_url);
 }
+function describeFileProblem(file) {
+  if (!isRecord(file)) return "a 'file' block requires an object 'file' field";
+  const fileData = typeof file.file_data === "string" ? file.file_data : void 0;
+  if (!fileData) return "a 'file' block requires a string 'file.file_data' field";
+  if (!fileData.startsWith("data:")) {
+    return "a 'file' block's 'file_data' must be a base64 data URL starting with 'data:'";
+  }
+  const match = FILE_BASE64_DATA_URL_PATTERN.exec(fileData);
+  if (!match || !match[1].includes("/")) {
+    return `malformed base64 data URL. Expected 'data:<mime-type>;base64,<base64>' with a valid type/subtype and standard base64 (no whitespace or URL-safe characters)`;
+  }
+  if (!isDecodableBase64(match[2])) {
+    return `base64 payload is not decodable. Check the padding and length \u2014 the data must be a multiple of 4 characters with at most two trailing '='`;
+  }
+  return void 0;
+}
+function describeFileUrlProblem(fileUrl) {
+  if (!isRecord(fileUrl)) return "a 'file_url' block requires an object 'file_url' field";
+  const url = typeof fileUrl.url === "string" ? fileUrl.url : void 0;
+  if (!url) return "a 'file_url' block requires a string 'file_url.url' field";
+  let protocol;
+  try {
+    protocol = new URL(url).protocol;
+  } catch {
+    return `'${url}' is not a valid URL. Use an http(s) URL`;
+  }
+  if (protocol !== "http:" && protocol !== "https:") {
+    return `URL protocol '${protocol}' is not supported. Use an http(s) URL`;
+  }
+  return void 0;
+}
 function describeImageUrlProblem(imageUrl) {
   const url = typeof imageUrl === "string" ? imageUrl : isRecord(imageUrl) ? imageUrl.url : void 0;
   if (typeof url !== "string" || url === "") {
@@ -480,7 +543,35 @@ function normalizeMessageContent(content) {
   if (content === null || content === void 0) return "";
   return JSON.stringify(content);
 }
-const GATEWAY_MANAGED_PARAMETERS = /* @__PURE__ */ new Set(["model", "messages", "tools", "tool_choice", "stream", "n"]);
+async function processMessageContentFileBlocks(content, ctx, plugin) {
+  if (!Array.isArray(content)) return content;
+  const processed = [];
+  for (const block of content) {
+    processed.push(...await processFileBlockChain(block, ctx, plugin, 0));
+  }
+  return processed;
+}
+const MAX_FILE_PROCESSOR_CHAIN_DEPTH = 3;
+async function processFileBlockChain(block, ctx, plugin, depth) {
+  if (!isRecord(block) || block.type !== "file" && block.type !== "file_url") {
+    return [block];
+  }
+  if (depth > MAX_FILE_PROCESSOR_CHAIN_DEPTH) {
+    return [block];
+  }
+  const result = await plugin.fileProcessorService.process(block, { ctx });
+  const results = Array.isArray(result) ? result : [result];
+  const next = [];
+  for (const item of results) {
+    if (isRecord(item) && (item.type === "file" || item.type === "file_url")) {
+      next.push(...await processFileBlockChain(item, ctx, plugin, depth + 1));
+    } else {
+      next.push(item);
+    }
+  }
+  return next;
+}
+const GATEWAY_MANAGED_PARAMETERS = /* @__PURE__ */ new Set(["model", "messages", "prompt", "tools", "tool_choice", "stream", "n"]);
 function getProviderRequestParameters(body) {
   return Object.fromEntries(
     Object.entries(body).filter(([name, value]) => !GATEWAY_MANAGED_PARAMETERS.has(name) && value !== void 0)

package/dist/server/routes/completions.js

@@ -33,10 +33,13 @@ 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");
 var import_app_observability = require("../utils/app-observability");
 async function handleCompletions(ctx, plugin) {
+  var _a;
   const body = ctx.request.body;
   if (!(body == null ? void 0 : body.model)) {
     ctx.status = 400;
@@ -98,7 +101,6 @@ async function handleCompletions(ctx, plugin) {
       ctx.body = (0, import_openai_format.toOpenAIError)(500, `Provider '${service.provider}' not registered`, "server_error");
       return;
     }
-    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
     const modelOptions = {
       model: modelId,
       llmService: service.name
@@ -107,14 +109,8 @@ async function handleCompletions(ctx, plugin) {
     if (body.top_p !== void 0) modelOptions.topP = body.top_p;
     if (body.max_tokens !== void 0) modelOptions.maxTokens = body.max_tokens;
     if (body.stop !== void 0) modelOptions.stop = body.stop;
-    const Provider = providerMeta.provider;
-    const provider = new Provider({
-      app: ctx.app,
-      serviceOptions: service.options,
-      modelOptions
-    });
     const prompt = typeof body.prompt === "string" ? body.prompt : Array.isArray(body.prompt) ? body.prompt.join("\n") : String(body.prompt);
-    const langchainMessages = [];
+    const messages = [];
     if (config == null ? void 0 : config.defaultAiEmployee) {
       const employee = await ctx.db.getRepository("aiEmployees").findOne({
         filter: { username: config.defaultAiEmployee }
@@ -122,13 +118,32 @@ async function handleCompletions(ctx, plugin) {
       if (employee) {
         const systemPrompt = employee.about || employee.defaultPrompt || "";
         if (systemPrompt) {
-          langchainMessages.push(["system", systemPrompt]);
+          messages.push({ role: "system", content: systemPrompt });
         }
       }
     }
-    langchainMessages.push(["human", prompt]);
+    messages.push({ role: "user", content: prompt });
+    const preparedContext = await (0, import_direct_llm_context.prepareDirectLlmContext)(ctx, {
+      serviceName: service.name,
+      modelId,
+      messages,
+      maxTokens: body.max_tokens
+    });
+    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
+    const Provider = providerMeta.provider;
+    const provider = new Provider({
+      app: ctx.app,
+      serviceOptions: service.options,
+      modelOptions
+    });
+    const langchainMessages = preparedContext.messages.map((message) => [
+      message.role === "user" ? "human" : message.role,
+      String(message.content ?? "")
+    ]);
     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(
@@ -137,28 +152,37 @@ 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);
-    if (!ctx.res.headersSent) {
+    if (!((_a = ctx.res) == null ? void 0 : _a.headersSent)) {
       const isQuotaError = err instanceof import_billing.AiApiQuotaError;
-      ctx.status = isQuotaError ? 429 : 500;
+      const isContextError = err instanceof import_direct_llm_context.DirectLlmContextError;
+      ctx.status = isQuotaError ? 429 : isContextError ? 400 : 500;
       if (isQuotaError) ctx.set("X-RateLimit-Reason", err.code);
       ctx.body = (0, import_openai_format.toOpenAIError)(
         ctx.status,
         getErrorMessage(err, "Internal server error"),
-        isQuotaError ? "quota_error" : "server_error",
-        isQuotaError ? err.code : void 0
+        isQuotaError ? "quota_error" : isContextError ? "invalid_request_error" : "server_error",
+        isQuotaError || isContextError ? err.code : void 0
       );
     }
   }
 }
-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;
@@ -166,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,
@@ -185,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",
@@ -201,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
+});