plugin-ai-api 1.0.20 → 1.0.21

package/src/locale/vi-VN.json

@@ -82,5 +82,24 @@
   "Reset": "Đặt lại",
   "Requests": "Số request",
   "Total cost": "Tổng chi phí",
-  "Usage records": "Chi tiết usage"
+  "Usage records": "Chi tiết usage",
+  "Model metadata": "Metadata model",
+  "Add override": "Thêm override",
+  "Edit override": "Sửa override",
+  "Delete this override?": "Xóa override này?",
+  "Context window": "Context window",
+  "Max completion tokens": "Max completion tokens",
+  "Owned by": "Nhà cung cấp",
+  "Display name": "Tên hiển thị",
+  "Description": "Mô tả",
+  "Leave empty to not override": "Để trống nếu không override",
+  "Total input + output token capacity reported to clients.": "Tổng dung lượng token (input + output) trả về cho client.",
+  "Maximum output tokens reported to clients.": "Số token output tối đa trả về cho client.",
+  "AI API": "AI API",
+  "Allow this role to use the AI API": "Cho phép vai trò này sử dụng AI API",
+  "Allow all AI Employees": "Cho phép tất cả AI Employee",
+  "Select which AI Employees this role may use:": "Chọn AI Employee mà vai trò này được dùng:",
+  "Select allowed AI Employees": "Chọn AI Employee được phép",
+  "Max request body size (MB)": "Giới hạn kích thước request body (MB)",
+  "Raise this to accept inline base64 images. Base64 adds about 33% to the original file size.": "Tăng giá trị này để nhận ảnh base64 gửi trực tiếp. Base64 làm tăng khoảng 33% so với kích thước tệp gốc."
 }

package/src/locale/zh-CN.json

@@ -82,5 +82,24 @@
   "Reset": "重置",
   "Requests": "请求数",
   "Total cost": "总费用",
-  "Usage records": "用量记录"
+  "Usage records": "用量记录",
+  "Model metadata": "模型元数据",
+  "Add override": "添加覆盖",
+  "Edit override": "编辑覆盖",
+  "Delete this override?": "确认删除此覆盖？",
+  "Context window": "上下文窗口",
+  "Max completion tokens": "最大输出 token 数",
+  "Owned by": "所属方",
+  "Display name": "显示名称",
+  "Description": "描述",
+  "Leave empty to not override": "留空则不覆盖",
+  "Total input + output token capacity reported to clients.": "返回给客户端的输入+输出 token 总容量。",
+  "Maximum output tokens reported to clients.": "返回给客户端的最大输出 token 数。",
+  "AI API": "AI API",
+  "Allow this role to use the AI API": "允许此角色使用 AI API",
+  "Allow all AI Employees": "允许所有 AI 员工",
+  "Select which AI Employees this role may use:": "选择此角色可使用的 AI 员工：",
+  "Select allowed AI Employees": "选择允许的 AI 员工",
+  "Max request body size (MB)": "请求体大小上限（MB）",
+  "Raise this to accept inline base64 images. Base64 adds about 33% to the original file size.": "调高此值以接收内联 base64 图片。base64 编码会使体积增加约 33%。"
 }

package/src/server/__tests__/app-observability.test.ts

@@ -0,0 +1,98 @@
+import type { Context } from '@nocobase/actions';
+import {
+  addAiApiUsage,
+  finishAiApiObservation,
+  markAiApiFirstProviderOutput,
+  startAiApiObservation,
+} from '../utils/app-observability';
+
+const CONTRACT_SYMBOL = Symbol.for('nocobase.app-observability.contract');
+
+function createContext(contract?: object): Context {
+  const app = {
+    logger: { warn: vi.fn() },
+    ...(contract ? { [CONTRACT_SYMBOL]: contract } : {}),
+  };
+  return { app, state: {} } as unknown as Context;
+}
+
+describe('AI API app observability bridge', () => {
+  it('is a no-op when observability is absent', () => {
+    const ctx = createContext();
+    expect(() => {
+      startAiApiObservation(ctx, {
+        service: 'llm.chat',
+        operation: '/chat/completions',
+        streaming: true,
+        mode: 'llm',
+      });
+      markAiApiFirstProviderOutput(ctx);
+      addAiApiUsage(ctx, { prompt_tokens: 2, completion_tokens: 3 });
+      finishAiApiObservation(ctx, { status: 'succeeded' });
+    }).not.toThrow();
+  });
+
+  it('records TTFT, normalized usage and finalizes exactly once', () => {
+    const handle = {
+      markFirstByte: vi.fn(),
+      addInputTokens: vi.fn(),
+      addOutputTokens: vi.fn(),
+      finish: vi.fn(),
+    };
+    const start = vi.fn(() => handle);
+    const ctx = createContext({ start });
+
+    startAiApiObservation(ctx, {
+      service: 'llm.agent',
+      operation: '/chat/completions',
+      streaming: true,
+      model: 'service/model',
+      mode: 'agent',
+    });
+    markAiApiFirstProviderOutput(ctx);
+    addAiApiUsage(ctx, { prompt_tokens: 11, completion_tokens: 7 });
+    finishAiApiObservation(ctx, { status: 'succeeded' });
+    finishAiApiObservation(ctx, { status: 'failed' });
+
+    expect(start).toHaveBeenCalledWith(
+      expect.objectContaining({
+        service: 'llm.agent',
+        streaming: true,
+        attributes: expect.objectContaining({ mode: 'agent', model: 'service/model' }),
+      }),
+    );
+    expect(handle.markFirstByte).toHaveBeenCalledTimes(1);
+    expect(handle.addInputTokens).toHaveBeenCalledWith(11);
+    expect(handle.addOutputTokens).toHaveBeenCalledWith(7);
+    expect(handle.finish).toHaveBeenCalledTimes(1);
+    expect(handle.finish).toHaveBeenCalledWith({ status: 'succeeded' });
+  });
+
+  it('fails open when contract callbacks throw', () => {
+    const ctx = createContext({
+      start: () => ({
+        markFirstByte: () => {
+          throw new Error('ttft failed');
+        },
+        addInputTokens: () => {
+          throw new Error('tokens failed');
+        },
+        addOutputTokens: () => {},
+        finish: () => {
+          throw new Error('finish failed');
+        },
+      }),
+    });
+    expect(() => {
+      startAiApiObservation(ctx, {
+        service: 'llm.completion',
+        operation: '/completions',
+        streaming: true,
+        mode: 'llm',
+      });
+      markAiApiFirstProviderOutput(ctx);
+      addAiApiUsage(ctx, { prompt_tokens: 1, completion_tokens: null });
+      finishAiApiObservation(ctx, { status: 'failed', errorCode: 'stream_error' });
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,74 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+import { buildModelObject } from '../routes/models';
+
+const CREATED = 1_700_000_000;
+
+describe('buildModelObject', () => {
+  it('returns the base OpenAI model shape with no override', () => {
+    const model = buildModelObject('svc/gpt-4o', CREATED, 'My Service');
+    expect(model).toEqual({
+      id: 'svc/gpt-4o',
+      object: 'model',
+      created: CREATED,
+      owned_by: 'My Service',
+    });
+    // No override → no context_window / active field is added.
+    expect(model).not.toHaveProperty('context_window');
+    expect(model).not.toHaveProperty('active');
+  });
+
+  it('emits context window under both context_window and context_length', () => {
+    const model = buildModelObject('svc/m', CREATED, 'Svc', { contextWindow: 100_000 });
+    expect(model.context_window).toBe(100_000);
+    expect(model.context_length).toBe(100_000);
+  });
+
+  it('overrides owned_by, display name and description', () => {
+    const model = buildModelObject('svc/m', CREATED, 'Svc', {
+      ownedByOverride: 'Acme',
+      displayName: 'Acme Turbo',
+      description: 'Fast model',
+    });
+    expect(model.owned_by).toBe('Acme');
+    expect(model.display_name).toBe('Acme Turbo');
+    expect(model.name).toBe('Acme Turbo');
+    expect(model.description).toBe('Fast model');
+  });
+
+  it('falls back to the service label when ownedByOverride is empty', () => {
+    const model = buildModelObject('svc/m', CREATED, 'Svc', { ownedByOverride: '' });
+    expect(model.owned_by).toBe('Svc');
+  });
+
+  it('emits max_completion_tokens only when positive', () => {
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { maxCompletionTokens: 4096 }).max_completion_tokens).toBe(4096);
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { maxCompletionTokens: 0 })).not.toHaveProperty(
+      'max_completion_tokens',
+    );
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { maxCompletionTokens: null })).not.toHaveProperty(
+      'max_completion_tokens',
+    );
+  });
+
+  it('ignores non-positive or non-integer context windows', () => {
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { contextWindow: 0 })).not.toHaveProperty('context_window');
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { contextWindow: -5 })).not.toHaveProperty('context_window');
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { contextWindow: null })).not.toHaveProperty('context_window');
+  });
+
+  it('surfaces active flag whenever an override row exists', () => {
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { enabled: true }).active).toBe(true);
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { enabled: false }).active).toBe(false);
+    // Override present with enabled undefined → treated as active.
+    expect(buildModelObject('svc/m', CREATED, 'Svc', { contextWindow: 10 }).active).toBe(true);
+  });
+});

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

@@ -0,0 +1,310 @@
+import http from 'http';
+import type { AddressInfo } from 'net';
+import { MAX_REQUEST_BODY_MB_LIMIT, getRawBody, normalizeMaxRequestBodyMb } from '../routes/router';
+import { findContentBlockProblem, findMessageProblem, normalizeMessageContent } from '../routes/chat-completions';
+
+describe('AI API max request body configuration', () => {
+  it('falls back to 10 MB when the configured value is missing or unusable', () => {
+    expect(normalizeMaxRequestBodyMb(undefined)).toBe(10);
+    expect(normalizeMaxRequestBodyMb(null)).toBe(10);
+    expect(normalizeMaxRequestBodyMb('not a number')).toBe(10);
+    expect(normalizeMaxRequestBodyMb(0)).toBe(10);
+    expect(normalizeMaxRequestBodyMb(-5)).toBe(10);
+    expect(normalizeMaxRequestBodyMb(2.5)).toBe(10);
+  });
+
+  it('accepts a raised limit and clamps anything above the ceiling', () => {
+    expect(normalizeMaxRequestBodyMb(25)).toBe(25);
+    expect(normalizeMaxRequestBodyMb('25')).toBe(25);
+    expect(normalizeMaxRequestBodyMb(MAX_REQUEST_BODY_MB_LIMIT)).toBe(MAX_REQUEST_BODY_MB_LIMIT);
+    expect(normalizeMaxRequestBodyMb(MAX_REQUEST_BODY_MB_LIMIT + 1)).toBe(MAX_REQUEST_BODY_MB_LIMIT);
+    expect(normalizeMaxRequestBodyMb(Number.MAX_SAFE_INTEGER)).toBe(MAX_REQUEST_BODY_MB_LIMIT);
+  });
+});
+
+/**
+ * Drives the real getRawBody over a live socket.
+ *
+ * The point is the transport, not the arithmetic: ctx.req and the response share
+ * one TCP connection, so destroying the request also destroys the reply and the
+ * client sees ECONNRESET instead of our 413 JSON. Only an end-to-end socket test
+ * can catch that regression, so this must call the production helper rather than
+ * a copy of it.
+ */
+describe('AI API oversized request handling', () => {
+  const MAX_BYTES = 1024;
+
+  interface Outcome {
+    status?: number;
+    body: string;
+    clientError?: string;
+  }
+
+  async function reply(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    res.setHeader('Content-Type', 'application/json');
+    try {
+      const raw = await getRawBody({ req } as Parameters<typeof getRawBody>[0], MAX_BYTES);
+      res.statusCode = 200;
+      res.end(JSON.stringify({ received: raw.length }));
+    } catch (err) {
+      const { message, statusCode } = err as Error & { statusCode?: number };
+      res.statusCode = statusCode === 413 ? 413 : 400;
+      res.end(JSON.stringify({ error: { message, type: 'invalid_request_error' } }));
+    }
+  }
+
+  async function post(payloadBytes: number, options: { declareLength?: boolean } = {}): Promise<Outcome> {
+    const server = http.createServer(reply);
+
+    try {
+      await new Promise<void>((resolve) => server.listen(0, resolve));
+      const { port } = server.address() as AddressInfo;
+
+      return await new Promise<Outcome>((resolve) => {
+        const payload = Buffer.alloc(payloadBytes, 'x');
+        const req = http.request(
+          {
+            port,
+            method: 'POST',
+            path: '/api/ai-llm/v1/chat/completions',
+            headers: options.declareLength === false ? {} : { 'Content-Length': String(payload.length) },
+          },
+          (res) => {
+            let body = '';
+            res.on('data', (chunk) => (body += chunk));
+            res.on('end', () => resolve({ status: res.statusCode, body }));
+          },
+        );
+        req.on('error', (err: NodeJS.ErrnoException) => resolve({ body: '', clientError: err.code }));
+        req.end(payload);
+      });
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  }
+
+  it('answers an oversized body with a readable 413 rather than resetting the connection', async () => {
+    const response = await post(200 * 1024);
+
+    expect(response.clientError).toBeUndefined();
+    expect(response.status).toBe(413);
+    expect(JSON.parse(response.body).error.message).toContain('too large');
+  });
+
+  it('reports 413 for a chunked upload that only exceeds the cap mid-stream', async () => {
+    const response = await post(64 * 1024, { declareLength: false });
+
+    expect(response.clientError).toBeUndefined();
+    expect(response.status).toBe(413);
+  });
+
+  it('returns the exact bytes for a body within the limit', async () => {
+    const response = await post(512);
+
+    expect(response.clientError).toBeUndefined();
+    expect(response.status).toBe(200);
+    expect(JSON.parse(response.body).received).toBe(512);
+  });
+
+  it('accepts a body sitting exactly on the cap', async () => {
+    const response = await post(MAX_BYTES);
+
+    expect(response.status).toBe(200);
+    expect(JSON.parse(response.body).received).toBe(MAX_BYTES);
+  });
+});
+
+describe('AI API multimodal content block validation', () => {
+  const wrap = (content: unknown) => [{ role: 'user', content }];
+
+  it('accepts plain string content and well-formed text/image_url blocks', () => {
+    expect(findContentBlockProblem(wrap('Hello'))).toBeUndefined();
+    expect(
+      findContentBlockProblem(
+        wrap([
+          { type: 'text', text: 'What is in this picture?' },
+          { type: 'image_url', image_url: { url: 'data:image/png;base64,iVBORw0KGgo=' } },
+          { type: 'image_url', image_url: { url: 'https://example.com/cat.jpg' } },
+        ]),
+      ),
+    ).toBeUndefined();
+  });
+
+  it('accepts a bare string image_url but rewrites it to the object form every provider converts', () => {
+    const block = { type: 'image_url', image_url: 'https://example.com/a.png' };
+
+    expect(findContentBlockProblem(wrap([block]))).toBeUndefined();
+    // `isOpenAIDataBlock` requires `image_url` to be an object, so the string
+    // form would otherwise reach the provider unconverted.
+    expect(normalizeMessageContent([block])).toEqual([
+      { type: 'image_url', image_url: { url: 'https://example.com/a.png' } },
+    ]);
+  });
+
+  it('leaves the object form and plain text blocks untouched', () => {
+    const blocks = [
+      { type: 'text', text: 'hi' },
+      { type: 'image_url', image_url: { url: 'https://example.com/a.png' } },
+    ];
+
+    expect(normalizeMessageContent(blocks)).toEqual(blocks);
+    expect(normalizeMessageContent('plain')).toBe('plain');
+  });
+
+  it('rejects base64 payloads that match the grammar but cannot be decoded', () => {
+    // Each of these passes LangChain's regex and then throws inside `atob`,
+    // which used to surface as an HTTP 500.
+    for (const payload of ['A===', 'A=', 'AAAAA', 'AAAA=']) {
+      const problem = findContentBlockProblem(
+        wrap([{ type: 'image_url', image_url: { url: `data:image/png;base64,${payload}` } }]),
+      );
+
+      expect(problem, payload).toBeDefined();
+      expect(problem?.reason, payload).toContain('not decodable');
+    }
+  });
+
+  it('still accepts correctly padded base64 payloads', () => {
+    for (const payload of ['QUJD', 'QQ==', 'QUI=', 'iVBORw0KGgo=']) {
+      expect(
+        findContentBlockProblem(wrap([{ type: 'image_url', image_url: { url: `data:image/png;base64,${payload}` } }])),
+        payload,
+      ).toBeUndefined();
+    }
+  });
+
+  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=' } }] },
+    ]);
+
+    expect(problem?.index).toBe(1);
+    expect(problem?.reason).toContain("'file' is not supported");
+  });
+
+  it('rejects a text block with no text payload', () => {
+    expect(findContentBlockProblem(wrap([{ type: 'text' }]))?.reason).toContain("requires a string 'text' field");
+  });
+
+  it('rejects an image_url block with no url', () => {
+    expect(findContentBlockProblem(wrap([{ type: 'image_url' }]))?.reason).toContain(
+      "requires a non-empty 'image_url.url'",
+    );
+    expect(findContentBlockProblem(wrap([{ type: 'image_url', image_url: { url: '' } }]))?.reason).toContain(
+      "requires a non-empty 'image_url.url'",
+    );
+  });
+
+  it('rejects a non-image data URL that the provider would treat as an image', () => {
+    const problem = findContentBlockProblem(
+      wrap([{ type: 'image_url', image_url: { url: 'data:application/pdf;base64,JVBERi0=' } }]),
+    );
+
+    expect(problem?.reason).toContain('application/pdf');
+    expect(problem?.reason).toContain('not an image');
+  });
+
+  it('rejects a malformed base64 data URL instead of letting the adapter throw a 500', () => {
+    for (const url of [
+      'data:image/png;base64,iVBORw0 KGgo=',
+      'data:image/png;base64,iVBORw0-KGgo=',
+      'data:image/png,notbase64',
+      'data:image/svg+xml;base64,PHN2Zz4=',
+    ]) {
+      const problem = findContentBlockProblem(wrap([{ type: 'image_url', image_url: { url } }]));
+      expect(problem, url).toBeDefined();
+    }
+  });
+
+  it('rejects a non-http(s) URL protocol', () => {
+    expect(
+      findContentBlockProblem(wrap([{ type: 'image_url', image_url: { url: 'ftp://example.com/a.png' } }]))?.reason,
+    ).toContain("protocol 'ftp:'");
+    expect(
+      findContentBlockProblem(wrap([{ type: 'image_url', image_url: { url: 'file:///etc/passwd' } }]))?.reason,
+    ).toContain("protocol 'file:'");
+  });
+
+  it('rejects a garbage url string', () => {
+    expect(findContentBlockProblem(wrap([{ type: 'image_url', image_url: { url: 'not a url' } }]))?.reason).toContain(
+      'not a valid URL',
+    );
+  });
+
+  it('rejects a block that is not an object or has no type', () => {
+    expect(findContentBlockProblem(wrap([42]))?.reason).toContain('must be an object');
+    expect(findContentBlockProblem(wrap([{ text: 'no type field' }]))?.reason).toContain("requires a 'type' field");
+  });
+
+  it('ignores messages whose content is not an array', () => {
+    expect(findContentBlockProblem([{ role: 'assistant', content: null }, { role: 'tool' }])).toBeUndefined();
+  });
+});
+
+/**
+ * `findContentBlockProblem` only inspects array content, so these malformed
+ * messages used to reach `messages.some((m) => m.role === ...)` — a TypeError
+ * reported as HTTP 500 — or died inside LangChain with MESSAGE_COERCION_FAILURE.
+ */
+describe('AI API message schema validation', () => {
+  it('rejects a non-object message instead of throwing on m.role', () => {
+    expect(findMessageProblem([null])?.reason).toContain('must be an object');
+    expect(findMessageProblem([null])?.index).toBe(0);
+    expect(findMessageProblem(['hello'])?.reason).toContain('must be an object');
+    expect(findMessageProblem([42])?.reason).toContain('must be an object');
+  });
+
+  it('names the offending index', () => {
+    const problem = findMessageProblem([{ role: 'user', content: 'ok' }, null]);
+
+    expect(problem?.index).toBe(1);
+  });
+
+  it('rejects a missing or unsupported role before LangChain coerces it', () => {
+    expect(findMessageProblem([{ content: 'no role' }])?.reason).toContain("requires a string 'role'");
+    expect(findMessageProblem([{ role: 'function', content: 'x' }])?.reason).toContain(
+      "role 'function' is not supported",
+    );
+    expect(findMessageProblem([{ role: 'moderator', content: 'x' }])?.reason).toContain(
+      "role 'moderator' is not supported",
+    );
+  });
+
+  it('accepts every role LangChain can coerce', () => {
+    for (const role of ['system', 'developer', 'user', 'human', 'assistant', 'ai']) {
+      expect(findMessageProblem([{ role, content: 'hi' }]), role).toBeUndefined();
+    }
+    expect(findMessageProblem([{ role: 'tool', content: 'out', tool_call_id: 'call_1' }])).toBeUndefined();
+  });
+
+  it('requires tool_call_id on a tool message', () => {
+    expect(findMessageProblem([{ role: 'tool', content: 'out' }])?.reason).toContain(
+      "requires a string 'tool_call_id'",
+    );
+  });
+
+  it('requires content unless an assistant turn only carries tool_calls', () => {
+    expect(findMessageProblem([{ role: 'user' }])?.reason).toContain("requires a 'content' field");
+    expect(findMessageProblem([{ role: 'assistant', content: null }])?.reason).toContain("requires a 'content' field");
+    expect(
+      findMessageProblem([{ role: 'assistant', tool_calls: [{ id: 'call_1', type: 'function', function: {} }] }]),
+    ).toBeUndefined();
+  });
+
+  it('rejects a content value that is neither string nor array', () => {
+    expect(findMessageProblem([{ role: 'user', content: 42 }])?.reason).toContain('must be a string or an array');
+    expect(findMessageProblem([{ role: 'user', content: { text: 'x' } }])?.reason).toContain(
+      'must be a string or an array',
+    );
+  });
+
+  it('accepts a well-formed multimodal conversation', () => {
+    expect(
+      findMessageProblem([
+        { role: 'system', content: 'You are helpful.' },
+        { role: 'user', content: [{ type: 'text', text: 'What is this?' }] },
+      ]),
+    ).toBeUndefined();
+  });
+});

package/src/server/__tests__/streaming-observability.test.ts

@@ -0,0 +1,51 @@
+import type { Context } from '@nocobase/actions';
+import { AiApiClientDisconnectedError, createRequestAbortController, isClientDisconnected } from '../utils/streaming';
+
+class ListenerTarget {
+  private listeners = new Map<string, Set<() => void>>();
+  aborted = false;
+  writableEnded = false;
+
+  once(event: string, listener: () => void) {
+    const wrapped = () => {
+      this.off(event, wrapped);
+      listener();
+    };
+    const group = this.listeners.get(event) ?? new Set();
+    group.add(wrapped);
+    this.listeners.set(event, group);
+  }
+
+  off(event: string, listener: () => void) {
+    this.listeners.get(event)?.delete(listener);
+  }
+
+  emit(event: string) {
+    for (const listener of [...(this.listeners.get(event) ?? [])]) listener();
+  }
+}
+
+describe('AI API streaming cancellation classification', () => {
+  it('uses a recognizable client-disconnect abort reason', () => {
+    const req = new ListenerTarget();
+    const res = new ListenerTarget();
+    const ctx = { req, res } as unknown as Context;
+    const controller = createRequestAbortController(ctx);
+
+    req.aborted = true;
+    req.emit('aborted');
+
+    expect(controller.signal.aborted).toBe(true);
+    expect(controller.signal.reason).toBeInstanceOf(AiApiClientDisconnectedError);
+    expect(isClientDisconnected(ctx, controller.signal.reason)).toBe(true);
+    controller.dispose();
+  });
+
+  it('does not treat an unrelated provider abort as client cancellation', () => {
+    const req = new ListenerTarget();
+    const res = new ListenerTarget();
+    const ctx = { req, res } as unknown as Context;
+
+    expect(isClientDisconnected(ctx, new DOMException('Provider timeout', 'AbortError'))).toBe(false);
+  });
+});

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

@@ -41,6 +41,12 @@ export default defineCollection({
       defaultValue: 60,
       comment: 'Max requests per user per minute',
     },
+    {
+      name: 'maxRequestBodyMb',
+      type: 'integer',
+      defaultValue: 10,
+      comment: 'Max request body size in MB. Raise this to accept inline base64 images in vision requests.',
+    },
     {
       name: 'quotaEnabled',
       type: 'boolean',

package/src/server/collections/ai-api-model-metadata.ts

@@ -0,0 +1,72 @@
+/**
+ * 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';
+
+/**
+ * Per-model metadata overrides surfaced through the OpenAI-compatible GET /v1/models
+ * endpoint. Lets an admin correct or supply values that the upstream provider either
+ * reports incorrectly (e.g. an inflated context window) or omits entirely.
+ *
+ * A row is keyed by (llmService, model). All override fields are nullable — a null
+ * value means "do not override this attribute", so an admin can override just the
+ * context window without touching anything else.
+ */
+export default defineCollection({
+  name: 'aiApiModelMetadata',
+  autoGenId: true,
+  fields: [
+    { name: 'llmService', type: 'string', allowNull: false, index: true },
+    { name: 'model', type: 'string', allowNull: false, index: true },
+    {
+      name: 'contextWindow',
+      type: 'integer',
+      allowNull: true,
+      comment:
+        'Override for the model context window (input+output token capacity). Returned as context_window / context_length.',
+    },
+    {
+      name: 'maxCompletionTokens',
+      type: 'integer',
+      allowNull: true,
+      comment: 'Override for the maximum output tokens. Returned as max_completion_tokens.',
+    },
+    {
+      name: 'ownedByOverride',
+      type: 'string',
+      allowNull: true,
+      comment: 'Override for the owned_by field in the OpenAI model object.',
+    },
+    {
+      name: 'displayName',
+      type: 'string',
+      allowNull: true,
+      comment: 'Friendly display name returned as display_name / name in the model object.',
+    },
+    {
+      name: 'description',
+      type: 'text',
+      allowNull: true,
+      comment: 'Human-readable description returned as description in the model object.',
+    },
+    {
+      name: 'enabled',
+      type: 'boolean',
+      defaultValue: true,
+      index: true,
+      comment: 'When false, the model is hidden from /v1/models and reported as active:false.',
+    },
+  ],
+  indexes: [
+    {
+      fields: ['llmService', 'model'],
+      unique: true,
+    },
+  ],
+});