plugin-ai-api 1.0.24 → 1.0.25

package/dist/swagger.js

@@ -285,6 +285,11 @@ var swagger_default = {
             maximum: 100,
             default: 10,
             description: "Max request body size in megabytes. Requests above this return 413. The gateway buffers each body in memory, so values above 100 are rejected."
+          },
+          pdfRenderPagesAsImages: {
+            type: "boolean",
+            default: false,
+            description: "When true, PDF file/file_url blocks are rendered to per-page PNG images and sent as image_url blocks. Requires a registered PdfToImageRenderer. When false or no renderer is available, PDFs are forwarded as file blocks."
           }
         }
       },
@@ -299,9 +304,9 @@ var swagger_default = {
       },
       ContentBlock: {
         type: "object",
-        description: "A multimodal content block. Only text and image_url blocks are forwarded to the provider; any other type is rejected with 400 unsupported_content_block.",
+        description: "A multimodal content block. text, image_url, file and file_url blocks are forwarded; file and file_url blocks are first run through the configurable file processor service.",
         properties: {
-          type: { type: "string", enum: ["text", "image_url"] },
+          type: { type: "string", enum: ["text", "image_url", "file", "file_url"] },
           text: { type: "string" },
           image_url: {
             type: "object",
@@ -314,6 +319,34 @@ var swagger_default = {
               detail: { type: "string", enum: ["auto", "low", "high"] }
             },
             required: ["url"]
+          },
+          file: {
+            type: "object",
+            properties: {
+              file_data: {
+                type: "string",
+                description: "A base64 data URL, e.g. data:application/pdf;base64,JVBERi0...",
+                example: "data:application/pdf;base64,JVBERi0..."
+              },
+              filename: { type: "string" },
+              mime_type: {
+                type: "string",
+                description: "MIME type of the file, e.g. application/pdf",
+                example: "application/pdf"
+              }
+            },
+            required: ["file_data"]
+          },
+          file_url: {
+            type: "object",
+            properties: {
+              url: {
+                type: "string",
+                description: "An http(s) URL pointing to a file. The gateway downloads the file and converts it to a file block.",
+                example: "https://example.com/document.pdf"
+              }
+            },
+            required: ["url"]
           }
         },
         required: ["type"]
@@ -374,7 +407,13 @@ var swagger_default = {
             properties: {
               prompt_tokens: { type: "integer" },
               completion_tokens: { type: "integer" },
-              total_tokens: { type: "integer" }
+              total_tokens: { type: "integer" },
+              prompt_tokens_details: {
+                type: "object",
+                properties: {
+                  cached_tokens: { type: "integer" }
+                }
+              }
             }
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-ai-api",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "main": "dist/server/index.js",
   "dependencies": {},
   "peerDependencies": {

package/src/client-v2/pages/UsagePage.tsx

@@ -32,6 +32,7 @@ interface UsageRecord {
   inputTokens?: number;
   outputTokens?: number;
   totalTokens?: number;
+  promptCacheTokens?: number;
   estimatedCost?: string;
   currency?: string;
   costStatus?: string;
@@ -51,6 +52,7 @@ interface UsageSummary {
   inputTokens: number;
   outputTokens: number;
   totalTokens: number;
+  promptCacheTokens: number;
   costsByCurrency: { currency: string; totalCost: string }[];
 }
 
@@ -65,6 +67,7 @@ const emptySummary: UsageSummary = {
   inputTokens: 0,
   outputTokens: 0,
   totalTokens: 0,
+  promptCacheTokens: 0,
   costsByCurrency: [],
 };
 
@@ -153,6 +156,7 @@ export default function UsagePage() {
     { title: t('Input tokens'), dataIndex: 'inputTokens', key: 'inputTokens', width: 110 },
     { title: t('Output tokens'), dataIndex: 'outputTokens', key: 'outputTokens', width: 110 },
     { title: t('Total tokens'), dataIndex: 'totalTokens', key: 'totalTokens', width: 110 },
+    { title: t('Prompt cache tokens'), dataIndex: 'promptCacheTokens', key: 'promptCacheTokens', width: 140 },
     {
       title: t('Cost'),
       key: 'cost',
@@ -234,6 +238,11 @@ export default function UsagePage() {
             <Statistic title={t('Total tokens')} value={summary.totalTokens} />
           </Card>
         </Col>
+        <Col xs={24} sm={12} lg={6}>
+          <Card size="small">
+            <Statistic title={t('Prompt cache tokens')} value={summary.promptCacheTokens} />
+          </Card>
+        </Col>
         <Col xs={24}>
           <Card size="small">
             <Statistic title={t('Total cost')} value={totalCost} />

package/src/locale/en-US.json

@@ -63,6 +63,7 @@
   "Input tokens": "Input tokens",
   "Output tokens": "Output tokens",
   "Total tokens": "Total tokens",
+  "Prompt cache tokens": "Prompt cache tokens",
   "Cost": "Cost",
   "Cost status": "Cost status",
   "Request ID": "Request ID",

package/src/locale/vi-VN.json

@@ -63,6 +63,7 @@
   "Input tokens": "Input token",
   "Output tokens": "Output token",
   "Total tokens": "Tổng token",
+  "Prompt cache tokens": "Prompt cache token",
   "Cost": "Chi phí",
   "Cost status": "Trạng thái chi phí",
   "Request ID": "Request ID",

package/src/locale/zh-CN.json

@@ -63,6 +63,7 @@
   "Input tokens": "输入令牌",
   "Output tokens": "输出令牌",
   "Total tokens": "总令牌",
+  "Prompt cache tokens": "提示缓存令牌",
   "Cost": "费用",
   "Cost status": "费用状态",
   "Request ID": "请求 ID",

package/src/server/__tests__/direct-llm-context.test.ts

@@ -1,6 +1,11 @@
 import type { Context } from '@nocobase/actions';
 import { describe, expect, it, vi } from 'vitest';
-import { DirectLlmContextError, prepareDirectLlmContext, type OpenAIMessage } from '../utils/direct-llm-context';
+import {
+  DirectLlmContextError,
+  prepareDirectLlmContext,
+  type OpenAIMessage,
+  parseImageDimensions,
+} from '../utils/direct-llm-context';
 
 function context({ behavior = 'reject', metadata = { contextWindow: 120, maxCompletionTokens: 40 } } = {}): Context {
   return {
@@ -34,6 +39,25 @@ function request(messages: OpenAIMessage[], tools?: unknown) {
   };
 }
 
+// A 1x1 PNG encoded as a base64 data URL.
+const ONE_PIXEL_PNG =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
+
+// A tiny valid base64 PDF payload (PDF header + minimal content).
+const TINY_PDF_BASE64 = 'data:application/pdf;base64,JVBERi0xLjAKPDwKPiEKZW5kb2JqCmVuZG9iagpl';
+
+// A PNG header with 1280x720 dimensions. The pixel data is truncated/invalid,
+// but the header is valid enough for dimension parsing to succeed.
+const LARGE_PNG_HEADER_BASE64 =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABQAAAALQCAYAAADPfd1WAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoSAA';
+
+// The fixed conservative estimate used for http(s) image URLs.
+const VISION_HTTP_URL_ESTIMATE = 1024;
+
+function largeContext(): Context {
+  return context({ metadata: { contextWindow: 2000, maxCompletionTokens: 40 } });
+}
+
 describe('direct LLM context preparation', () => {
   it('uses reject when the user has no enabled policy', async () => {
     const ctx = context();
@@ -100,15 +124,57 @@ describe('direct LLM context preparation', () => {
     ).rejects.toMatchObject<Partial<DirectLlmContextError>>({ code: 'context_length_exceeded' });
   });
 
-  it('rejects image content until a model-specific estimator is available', async () => {
+  it('estimates vision tokens for a base64 image_url and allows small payloads', async () => {
+    const prepared = await prepareDirectLlmContext(
+      largeContext(),
+      request([{ role: 'user', content: [{ type: 'image_url', image_url: { url: ONE_PIXEL_PNG } }] }]),
+    );
+
+    expect(prepared.estimatedInputTokens).toBeGreaterThan(0);
+    expect(prepared.truncated).toBe(false);
+  });
+
+  it('estimates a fixed conservative token count for http(s) image_url URLs', async () => {
+    const prepared = await prepareDirectLlmContext(
+      largeContext(),
+      request([
+        { role: 'user', content: [{ type: 'image_url', image_url: { url: 'https://example.com/image.png' } }] },
+      ]),
+    );
+
+    expect(prepared.estimatedInputTokens).toBeGreaterThanOrEqual(VISION_HTTP_URL_ESTIMATE);
+    expect(prepared.truncated).toBe(false);
+  });
+
+  it('rejects a base64 image that exceeds the input budget', async () => {
+    // Large header claims 1000x1000, so vision estimate is 85 + 4 * 170 = 765 tokens,
+    // which easily exceeds the 80 token budget of the default test context.
     await expect(
       prepareDirectLlmContext(
         context(),
-        request([
-          { role: 'user', content: [{ type: 'image_url', image_url: { url: 'https://example.test/image.png' } }] },
-        ]),
+        request([{ role: 'user', content: [{ type: 'image_url', image_url: { url: LARGE_PNG_HEADER_BASE64 } }] }]),
       ),
-    ).rejects.toMatchObject<Partial<DirectLlmContextError>>({ code: 'context_estimation_unsupported' });
+    ).rejects.toMatchObject<Partial<DirectLlmContextError>>({ code: 'context_length_exceeded' });
+  });
+
+  it('estimates file block tokens from decoded base64 size', async () => {
+    const prepared = await prepareDirectLlmContext(
+      context(),
+      request([{ role: 'user', content: [{ type: 'file', file: { file_data: TINY_PDF_BASE64, filename: 'x.pdf' } }] }]),
+    );
+
+    expect(prepared.estimatedInputTokens).toBeGreaterThan(0);
+    expect(prepared.truncated).toBe(false);
+  });
+
+  it('rejects a base64 file that exceeds the input budget', async () => {
+    const largeBase64 = `data:application/pdf;base64,${Buffer.alloc(100_000).toString('base64')}`;
+    await expect(
+      prepareDirectLlmContext(
+        context(),
+        request([{ role: 'user', content: [{ type: 'file', file: { file_data: largeBase64, filename: 'x.pdf' } }] }]),
+      ),
+    ).rejects.toMatchObject<Partial<DirectLlmContextError>>({ code: 'context_length_exceeded' });
   });
 
   it('counts tool definitions as fixed input overhead', async () => {
@@ -123,3 +189,18 @@ describe('direct LLM context preparation', () => {
     ).rejects.toMatchObject<Partial<DirectLlmContextError>>({ code: 'context_length_exceeded' });
   });
 });
+
+describe('image dimension parsing', () => {
+  it('parses PNG dimensions', () => {
+    // The shared 1x1 test PNG is a valid PNG with dimensions 1x1.
+    const base64 = ONE_PIXEL_PNG.split(',')[1];
+    const png = Buffer.from(base64, 'base64');
+    expect(parseImageDimensions(png)).toEqual({ width: 1, height: 1 });
+  });
+
+  it('parses JPEG dimensions without reading past width/height', () => {
+    // Minimal JPEG SOF0 segment: height 1024, width 1024.
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xc0, 0x00, 0x0b, 0x08, 0x04, 0x00, 0x04, 0x00, 0x01, 0x22, 0x00]);
+    expect(parseImageDimensions(jpeg)).toEqual({ width: 1024, height: 1024 });
+  });
+});

package/src/server/__tests__/openai-format.test.ts

@@ -86,7 +86,12 @@ describe('AI API OpenAI usage-only streaming chunks', () => {
 
     expect(chunk.object).toBe('chat.completion.chunk');
     expect(chunk.choices).toEqual([]);
-    expect(chunk.usage).toEqual({ prompt_tokens: 8, completion_tokens: 3, total_tokens: 11 });
+    expect(chunk.usage).toEqual({
+      prompt_tokens: 8,
+      completion_tokens: 3,
+      total_tokens: 11,
+      prompt_tokens_details: { cached_tokens: null },
+    });
   });
 
   it('formats a usage-only legacy text completion chunk', () => {
@@ -99,7 +104,12 @@ describe('AI API OpenAI usage-only streaming chunks', () => {
 
     expect(chunk.object).toBe('text_completion');
     expect(chunk.choices).toEqual([]);
-    expect(chunk.usage).toEqual({ prompt_tokens: 2, completion_tokens: 5, total_tokens: 7 });
+    expect(chunk.usage).toEqual({
+      prompt_tokens: 2,
+      completion_tokens: 5,
+      total_tokens: 7,
+      prompt_tokens_details: { cached_tokens: null },
+    });
   });
 });
 

package/src/server/__tests__/request-body.test.ts

@@ -176,11 +176,54 @@ describe('AI API multimodal content block validation', () => {
   it('rejects an unsupported block type and names it', () => {
     const problem = findContentBlockProblem([
       { role: 'system', content: 'You are helpful.' },
-      { role: 'user', content: [{ type: 'file', file: { file_data: 'data:application/pdf;base64,JVBERi0=' } }] },
+      { role: 'user', content: [{ type: 'audio', audio: { url: 'https://example.com/x.mp3' } }] },
     ]);
 
     expect(problem?.index).toBe(1);
-    expect(problem?.reason).toContain("'file' is not supported");
+    expect(problem?.reason).toContain("'audio' is not supported");
+  });
+
+  it('accepts well-formed file and file_url blocks', () => {
+    expect(
+      findContentBlockProblem(wrap([{ type: 'file', file: { file_data: 'data:application/pdf;base64,JVBERi0=' } }])),
+    ).toBeUndefined();
+    expect(
+      findContentBlockProblem(wrap([{ type: 'file_url', file_url: { url: 'https://example.com/doc.pdf' } }])),
+    ).toBeUndefined();
+    // Complex MIME types with hyphens, dots, or '+' used to be rejected by the
+    // image_url grammar even though they are valid file attachments.
+    expect(
+      findContentBlockProblem(
+        wrap([
+          {
+            type: 'file',
+            file: {
+              file_data: 'data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64,JVBERi0=',
+            },
+          },
+        ]),
+      ),
+    ).toBeUndefined();
+    expect(
+      findContentBlockProblem(wrap([{ type: 'file', file: { file_data: 'data:image/svg+xml;base64,JVBERi0=' } }])),
+    ).toBeUndefined();
+  });
+
+  it('rejects a file block with missing or malformed file_data', () => {
+    expect(findContentBlockProblem(wrap([{ type: 'file' }]))?.reason).toContain("object 'file' field");
+    expect(findContentBlockProblem(wrap([{ type: 'file', file: { file_data: 'not-a-data-url' } }]))?.reason).toContain(
+      "'data:'",
+    );
+    expect(
+      findContentBlockProblem(wrap([{ type: 'file', file: { file_data: 'data:application/pdf;base64,!!!' } }]))?.reason,
+    ).toContain('malformed base64');
+  });
+
+  it('rejects a file_url block with missing or unsupported URL', () => {
+    expect(findContentBlockProblem(wrap([{ type: 'file_url' }]))?.reason).toContain("object 'file_url' field");
+    expect(
+      findContentBlockProblem(wrap([{ type: 'file_url', file_url: { url: 'ftp://example.com/doc.pdf' } }]))?.reason,
+    ).toContain("protocol 'ftp:'");
   });
 
   it('rejects a text block with no text payload', () => {

package/src/server/__tests__/usage-route.test.ts

@@ -205,6 +205,7 @@ describe('AI API chat usage collection', () => {
       prompt_tokens: 0,
       completion_tokens: 0,
       total_tokens: 0,
+      prompt_tokens_details: { cached_tokens: null },
     });
     expect(ctx.state.aiApiUsageResult).toMatchObject({
       source: 'unavailable',
@@ -229,6 +230,7 @@ describe('AI API chat usage collection', () => {
       prompt_tokens: 8,
       completion_tokens: 3,
       total_tokens: 11,
+      prompt_tokens_details: { cached_tokens: null },
     });
     expect(ctx.state.aiApiUsageResult).toMatchObject({
       source: 'provider',
@@ -238,6 +240,73 @@ describe('AI API chat usage collection', () => {
     });
   });
 
+  it('extracts cached prompt tokens from OpenAI-style usage metadata', async () => {
+    const { ctx } = createContext({
+      content: 'Hello back',
+      usage_metadata: {
+        input_tokens: 8,
+        output_tokens: 3,
+        total_tokens: 11,
+        prompt_tokens_details: { cached_tokens: 7 },
+      },
+    });
+
+    await handleChatCompletions(ctx, {} as PluginAiApiServer);
+
+    expect((ctx.body as { usage: object }).usage).toEqual({
+      prompt_tokens: 8,
+      completion_tokens: 3,
+      total_tokens: 11,
+      prompt_tokens_details: { cached_tokens: 7 },
+    });
+    expect(ctx.state.aiApiUsageResult).toMatchObject({
+      source: 'provider',
+      usage: { prompt_tokens: 8, completion_tokens: 3, total_tokens: 11, prompt_cache_tokens: 7 },
+    });
+  });
+
+  it('falls back to response_metadata when usage metadata omits cached tokens', async () => {
+    const { ctx } = createContext({
+      content: 'Hello back',
+      usage_metadata: { input_tokens: 8, output_tokens: 3, total_tokens: 11 },
+      response_metadata: { usage: { prompt_tokens_details: { cached_tokens: 5 } } },
+    });
+
+    await handleChatCompletions(ctx, {} as PluginAiApiServer);
+
+    expect((ctx.body as { usage: object }).usage).toEqual({
+      prompt_tokens: 8,
+      completion_tokens: 3,
+      total_tokens: 11,
+      prompt_tokens_details: { cached_tokens: 5 },
+    });
+    expect(ctx.state.aiApiUsageResult).toMatchObject({
+      source: 'provider',
+      usage: { prompt_cache_tokens: 5 },
+    });
+  });
+
+  it('extracts cached prompt tokens from LangChain-style input_token_details', async () => {
+    const { ctx } = createContext({
+      content: 'Hello back',
+      usage_metadata: {
+        input_tokens: 8,
+        output_tokens: 3,
+        total_tokens: 11,
+        input_token_details: { cache_read: 4 },
+      },
+    });
+
+    await handleChatCompletions(ctx, {} as PluginAiApiServer);
+
+    expect((ctx.body as { usage: object }).usage).toEqual({
+      prompt_tokens: 8,
+      completion_tokens: 3,
+      total_tokens: 11,
+      prompt_tokens_details: { cached_tokens: 4 },
+    });
+  });
+
   it('emits a usage-only chunk immediately before [DONE] for streaming chat completions', async () => {
     const { ctx, writes } = createStreamingContext(
       {
@@ -261,7 +330,12 @@ describe('AI API chat usage collection', () => {
 
     expect(finishChunk.choices[0].finish_reason).toBe('stop');
     expect(usageChunk.choices).toEqual([]);
-    expect(usageChunk.usage).toEqual({ prompt_tokens: 5, completion_tokens: 4, total_tokens: 9 });
+    expect(usageChunk.usage).toEqual({
+      prompt_tokens: 5,
+      completion_tokens: 4,
+      total_tokens: 9,
+      prompt_tokens_details: { cached_tokens: null },
+    });
     expect(usageChunk).toHaveProperty('usage.prompt_tokens', 5);
     expect(ctx.state.aiApiUsageResult).toMatchObject({
       source: 'provider',
@@ -287,7 +361,12 @@ describe('AI API chat usage collection', () => {
 
     expect(frames.slice(0, -1).every((frame) => frame.usage === null)).toBe(true);
     expect(usageChunk.choices).toEqual([]);
-    expect(usageChunk.usage).toEqual({ prompt_tokens: 5, completion_tokens: 4, total_tokens: 9 });
+    expect(usageChunk.usage).toEqual({
+      prompt_tokens: 5,
+      completion_tokens: 4,
+      total_tokens: 9,
+      prompt_tokens_details: { cached_tokens: null },
+    });
     expect(model.stream).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
@@ -316,7 +395,12 @@ describe('AI API chat usage collection', () => {
     expect(frames.slice(0, -1).every((frame) => frame.usage === null)).toBe(true);
     expect(usageChunk.object).toBe('text_completion');
     expect(usageChunk.choices).toEqual([]);
-    expect(usageChunk.usage).toEqual({ prompt_tokens: 2, completion_tokens: 5, total_tokens: 7 });
+    expect(usageChunk.usage).toEqual({
+      prompt_tokens: 2,
+      completion_tokens: 5,
+      total_tokens: 7,
+      prompt_tokens_details: { cached_tokens: null },
+    });
     expect(model.stream).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
@@ -366,4 +450,37 @@ describe('AI API chat usage collection', () => {
     expect(precedingChunk.usage).toBeNull();
     expect(ctx.state.aiApiUsageResult).toMatchObject({ source: 'unavailable' });
   });
+
+  it('forwards passthrough provider parameters in legacy non-stream completions', async () => {
+    const { ctx, model } = createContext({
+      content: 'Hello back',
+      usage_metadata: { input_tokens: 2, output_tokens: 5, total_tokens: 7 },
+    });
+    (ctx.request.body as Record<string, unknown>).prompt = 'Hello';
+    (ctx.request.body as Record<string, unknown>).seed = 42;
+    (ctx.request.body as Record<string, unknown>).reasoning_effort = 'medium';
+
+    await handleCompletions(ctx, {} as PluginAiApiServer);
+
+    expect(ctx.status).toBe(200);
+    expect(model.invoke).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ seed: 42, reasoning_effort: 'medium' }),
+    );
+  });
+
+  it('forwards passthrough provider parameters in legacy streaming completions', async () => {
+    const { ctx, model } = createStreamingContext(
+      { content: 'Hi', usage_metadata: { input_tokens: 2, output_tokens: 5, total_tokens: 7 } },
+      { include_usage: false, include_obfuscation: false },
+      { prompt: 'Hello', seed: 42, reasoning_effort: 'medium' },
+    );
+
+    await handleCompletions(ctx, {} as PluginAiApiServer);
+
+    expect(model.stream).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ seed: 42, reasoning_effort: 'medium' }),
+    );
+  });
 });

package/src/server/__tests__/usage.test.ts

@@ -24,6 +24,7 @@ describe('AI API usage normalization', () => {
       prompt_tokens: 12,
       completion_tokens: 5,
       total_tokens: 17,
+      prompt_cache_tokens: null,
     });
   });
 
@@ -32,6 +33,24 @@ describe('AI API usage normalization', () => {
       prompt_tokens: 0,
       completion_tokens: 0,
       total_tokens: 0,
+      prompt_cache_tokens: null,
+    });
+  });
+
+  it('extracts prompt_cache_tokens when present in various provider formats', () => {
+    expect(
+      normalizeUsage({ prompt_tokens: 10, completion_tokens: 5, prompt_tokens_details: { cached_tokens: 8 } }),
+    ).toEqual({
+      prompt_tokens: 10,
+      completion_tokens: 5,
+      total_tokens: 15,
+      prompt_cache_tokens: 8,
+    });
+    expect(normalizeUsage({ input_tokens: 20, output_tokens: 10, input_token_details: { cache_read: 15 } })).toEqual({
+      prompt_tokens: 20,
+      completion_tokens: 10,
+      total_tokens: 30,
+      prompt_cache_tokens: 15,
     });
   });
 

package/src/server/billing.ts

@@ -373,7 +373,12 @@ export async function finalizeLlmBilling(
 
   return {
     usage: numbers
-      ? { prompt_tokens: numbers.input, completion_tokens: numbers.output, total_tokens: numbers.total }
+      ? {
+          prompt_tokens: numbers.input,
+          completion_tokens: numbers.output,
+          total_tokens: numbers.total,
+          prompt_cache_tokens: providerUsage?.prompt_cache_tokens ?? null,
+        }
       : providerUsage,
     estimatedCost: cost,
     currency: billing.price?.currency,

package/src/server/collections/ai-api-config.ts

@@ -47,6 +47,14 @@ export default defineCollection({
       defaultValue: 10,
       comment: 'Max request body size in MB. Raise this to accept inline base64 images in vision requests.',
     },
+    {
+      name: 'pdfRenderPagesAsImages',
+      type: 'boolean',
+      defaultValue: false,
+      comment:
+        'When true, PDF file/file_url blocks are rendered to per-page PNG images and sent as image_url blocks. ' +
+        'Requires a registered PdfToImageRenderer. When false or no renderer is available, PDFs are forwarded as file blocks.',
+    },
     {
       name: 'quotaEnabled',
       type: 'boolean',

package/src/server/collections/ai-api-role-permissions.ts

@@ -1,41 +1,41 @@
-/**
- * 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.
- */
-
-import { defineCollection } from '@nocobase/database';
-
-export default defineCollection({
-  name: 'aiApiRolePermissions',
-  autoGenId: true,
-  fields: [
-    {
-      name: 'roleName',
-      type: 'string',
-      unique: true,
-      comment: 'Role name (links to roles.name)',
-    },
-    {
-      name: 'enabled',
-      type: 'boolean',
-      defaultValue: false,
-      comment: 'Whether this role can use the AI API at all',
-    },
-    {
-      name: 'allowAllEmployees',
-      type: 'boolean',
-      defaultValue: true,
-      comment: 'If true, the role may use any AI Employee. If false, only those in allowedEmployees.',
-    },
-    {
-      name: 'allowedEmployees',
-      type: 'json',
-      defaultValue: [],
-      comment: 'Array of AI Employee usernames this role is allowed to use (when allowAllEmployees=false)',
-    },
-  ],
-});
+/**
+ * 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.
+ */
+
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'aiApiRolePermissions',
+  autoGenId: true,
+  fields: [
+    {
+      name: 'roleName',
+      type: 'string',
+      unique: true,
+      comment: 'Role name (links to roles.name)',
+    },
+    {
+      name: 'enabled',
+      type: 'boolean',
+      defaultValue: false,
+      comment: 'Whether this role can use the AI API at all',
+    },
+    {
+      name: 'allowAllEmployees',
+      type: 'boolean',
+      defaultValue: true,
+      comment: 'If true, the role may use any AI Employee. If false, only those in allowedEmployees.',
+    },
+    {
+      name: 'allowedEmployees',
+      type: 'json',
+      defaultValue: [],
+      comment: 'Array of AI Employee usernames this role is allowed to use (when allowAllEmployees=false)',
+    },
+  ],
+});