plugin-ai-api 1.0.21 → 1.0.23

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

@@ -2,6 +2,7 @@ import type { Context } from '@nocobase/actions';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type PluginAiApiServer from '../plugin';
 import { handleChatCompletions } from '../routes/chat-completions';
+import { handleCompletions } from '../routes/completions';
 import { resolveModelString } from '../utils/resolve-service';
 
 vi.mock('../utils/resolve-service', () => ({
@@ -51,6 +52,114 @@ function createContext(result: ModelResult): Context {
   } as unknown as Context;
 }
 
+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();
+  }
+}
+
+function createStreamingContext(
+  result: ModelResult,
+  streamOptions?: Record<string, unknown>,
+  requestBody?: Record<string, unknown>,
+) {
+  const req = new ListenerTarget();
+  const res = new ListenerTarget();
+  const writes: string[] = [];
+
+  res.write = vi.fn((data: unknown) => {
+    writes.push(String(data));
+    return true;
+  });
+  res.end = vi.fn(() => {
+    res.writableEnded = true;
+  });
+
+  const contentChunks = (typeof result.content === 'string' ? [result.content] : []).filter(Boolean);
+  const chunks = [
+    ...contentChunks.map((content) => ({ content })),
+    { content: '', usage_metadata: result.usage_metadata, response_metadata: result.response_metadata },
+  ];
+
+  const model = {
+    invoke: vi.fn().mockResolvedValue({
+      content: result.content,
+      usage_metadata: result.usage_metadata,
+    }),
+    stream: vi.fn().mockResolvedValue({
+      [Symbol.asyncIterator]() {
+        let index = 0;
+        return {
+          async next() {
+            if (index >= chunks.length) return { done: true, value: undefined };
+            return { done: false, value: chunks[index++] };
+          },
+          async return() {
+            index = chunks.length;
+            return { done: true, value: undefined };
+          },
+        };
+      },
+    }),
+    modelKwargs: {},
+  };
+
+  class TestProvider {
+    createModel() {
+      return model;
+    }
+  }
+
+  const ctx = {
+    app: {
+      pm: {
+        get: vi.fn().mockReturnValue({
+          aiManager: {
+            llmProviders: new Map([['test-provider', { provider: TestProvider }]]),
+          },
+        }),
+      },
+    },
+    db: {
+      getRepository: vi.fn().mockReturnValue({ findOne: vi.fn().mockResolvedValue(null) }),
+    },
+    log: { error: vi.fn() },
+    req,
+    res,
+    request: {
+      body: {
+        model: 'test-service/test-model',
+        messages: [{ role: 'user', content: 'Hello' }],
+        stream: true,
+        stream_options: streamOptions,
+        ...requestBody,
+      },
+    },
+    state: {} as Record<string, unknown>,
+    set: vi.fn(),
+  } as unknown as Context;
+
+  return { ctx, model, writes };
+}
+
 describe('AI API chat usage collection', () => {
   beforeEach(() => {
     vi.mocked(resolveModelString).mockResolvedValue({
@@ -106,4 +215,108 @@ describe('AI API chat usage collection', () => {
       usage: { prompt_tokens: 8, completion_tokens: 3, total_tokens: 11 },
     });
   });
+
+  it('emits a usage-only chunk immediately before [DONE] for streaming chat completions', async () => {
+    const { ctx, writes } = createStreamingContext(
+      {
+        content: 'Hi',
+        response_metadata: { request_id: 'provider-request-stream-1' },
+        usage_metadata: { input_tokens: 5, output_tokens: 4, total_tokens: 9 },
+      },
+      { include_usage: true },
+    );
+
+    await handleChatCompletions(ctx, {} as PluginAiApiServer);
+
+    const dataLines = writes.filter((line) => line.startsWith('data: '));
+    const doneFrame = dataLines.find((line) => line.includes('[DONE]'));
+    expect(doneFrame).toBeDefined();
+    const frames = dataLines.filter((line) => !line.includes('[DONE]')).map((line) => JSON.parse(line.slice(6)));
+    const doneIndex = frames.length;
+
+    const finishChunk = frames[doneIndex - 2];
+    const usageChunk = frames[doneIndex - 1];
+
+    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).toHaveProperty('usage.prompt_tokens', 5);
+    expect(ctx.state.aiApiUsageResult).toMatchObject({
+      source: 'provider',
+      providerRequestId: 'provider-request-stream-1',
+    });
+  });
+
+  it('always emits chat usage and forces provider collection when include_usage is false', async () => {
+    const { ctx, model, writes } = createStreamingContext(
+      {
+        content: 'Hi',
+        usage_metadata: { input_tokens: 5, output_tokens: 4, total_tokens: 9 },
+      },
+      { include_usage: false, include_obfuscation: false },
+    );
+
+    await handleChatCompletions(ctx, {} as PluginAiApiServer);
+
+    const frames = writes
+      .filter((line) => line.startsWith('data: ') && !line.includes('[DONE]'))
+      .map((line) => JSON.parse(line.slice(6)));
+    const usageChunk = frames[frames.length - 1];
+
+    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(model.stream).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        stream_options: { include_usage: true, include_obfuscation: false },
+      }),
+    );
+  });
+
+  it('always emits legacy completion usage and forwards all stream options', async () => {
+    const { ctx, model, writes } = createStreamingContext(
+      {
+        content: 'Hi',
+        usage_metadata: { input_tokens: 2, output_tokens: 5, total_tokens: 7 },
+      },
+      { include_usage: false, include_obfuscation: false },
+      { prompt: 'Hello' },
+    );
+
+    await handleCompletions(ctx, {} as PluginAiApiServer);
+
+    const frames = writes
+      .filter((line) => line.startsWith('data: ') && !line.includes('[DONE]'))
+      .map((line) => JSON.parse(line.slice(6)));
+    const usageChunk = frames[frames.length - 1];
+
+    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(model.stream).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        stream_options: { include_usage: true, include_obfuscation: false },
+      }),
+    );
+  });
+
+  it('does not emit a usage-only chunk when the provider omits usage metadata', async () => {
+    const { ctx, writes } = createStreamingContext({ content: 'Silent' }, { include_usage: true });
+
+    await handleChatCompletions(ctx, {} as PluginAiApiServer);
+
+    const dataLines = writes.filter((line) => line.startsWith('data: '));
+    const doneFrame = dataLines.find((line) => line.includes('[DONE]'));
+    expect(doneFrame).toBeDefined();
+    const frames = dataLines.filter((line) => !line.includes('[DONE]')).map((line) => JSON.parse(line.slice(6)));
+    const doneIndex = frames.length;
+
+    const precedingChunk = frames[doneIndex - 1];
+    expect(precedingChunk.choices[0].finish_reason).toBe('stop');
+    expect(precedingChunk.usage).toBeNull();
+    expect(ctx.state.aiApiUsageResult).toMatchObject({ source: 'unavailable' });
+  });
 });

package/src/server/__tests__/user-permissions-resource.test.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 type { Context, Next } from '@nocobase/actions';
+import { describe, expect, it, vi } from 'vitest';
+import aiApiUserPermissionsResource from '../resource/ai-api-user-permissions';
+
+type ActionHandler = (ctx: Context, next: Next) => Promise<void>;
+
+const listUsers = aiApiUserPermissionsResource.actions?.listUsers as ActionHandler;
+
+function model(values: Record<string, unknown>) {
+  return { get: (key: string) => values[key] };
+}
+
+describe('aiApiUserPermissions:listUsers', () => {
+  it('returns the canonical rows shape for NocoBase data wrapping', async () => {
+    const user = model({
+      id: 7,
+      nickname: 'Ada',
+      username: 'ada',
+      email: 'ada@example.com',
+      password: 'must-not-leak',
+    });
+    const findAndCount = vi.fn(async () => [[user], 1] as const);
+    const ctx = {
+      action: { params: {} },
+      db: { getRepository: () => ({ findAndCount }) },
+    } as unknown as Context;
+
+    await listUsers(ctx, async () => undefined);
+
+    expect(ctx.body).toEqual({
+      rows: [{ id: 7, nickname: 'Ada', username: 'ada', email: 'ada@example.com' }],
+      count: 1,
+      page: 1,
+      pageSize: 50,
+    });
+    expect(findAndCount).toHaveBeenCalledWith(
+      expect.objectContaining({ fields: ['id', 'nickname', 'username', 'email'] }),
+    );
+  });
+
+  it('excludes users that already hold a grant when requested', async () => {
+    const findAndCount = vi.fn(async () => [[], 0] as const);
+    const ctx = {
+      action: { params: { excludeGranted: true } },
+      db: {
+        getRepository: (name: string) =>
+          name === 'aiApiUserPermissions'
+            ? { find: vi.fn(async () => [model({ userId: 3 }), model({ userId: 8 })]) }
+            : { findAndCount },
+      },
+    } as unknown as Context;
+
+    await listUsers(ctx, async () => undefined);
+
+    expect(findAndCount).toHaveBeenCalledWith(expect.objectContaining({ filter: { id: { $notIn: [3, 8] } } }));
+  });
+});

package/src/server/__tests__/user-permissions.test.ts

@@ -0,0 +1,284 @@
+/**
+ * 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 { Context } from '@nocobase/actions';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  buildAccessScope,
+  enforceModelAccess,
+  invalidateUserPermissionCache,
+  isModelAllowed,
+  isServiceAllowed,
+  resolveUserAccessScope,
+} from '../utils/user-permissions';
+
+const OPENAI = { name: 'openai', title: 'OpenAI' };
+const ANTHROPIC = { name: 'anthropic', title: 'Anthropic' };
+
+/** Sequelize instances only expose columns via .get(); rows must be shaped that way. */
+function row(values: Record<string, unknown>) {
+  return { get: (key: string) => values[key] };
+}
+
+function mockContext(options: { userId?: number | null; row?: unknown; throws?: boolean; appName?: string } = {}) {
+  const findOne = vi.fn(async () => {
+    if (options.throws) throw new Error('collection unavailable');
+    return options.row ?? null;
+  });
+  const ctx = {
+    state: { currentUser: options.userId === null ? undefined : { id: options.userId ?? 1 } },
+    db: { getRepository: () => ({ findOne }) },
+    app: { name: options.appName ?? 'main' },
+    log: { warn: vi.fn(), error: vi.fn() },
+    status: 200,
+    body: undefined,
+  } as unknown as Context;
+  return { ctx, findOne };
+}
+
+beforeEach(() => {
+  invalidateUserPermissionCache();
+});
+
+describe('buildAccessScope', () => {
+  it('treats a missing row as "no user-level narrowing"', () => {
+    const scope = buildAccessScope(null);
+    expect(scope.hasUserRecord).toBe(false);
+    expect(scope.denyAll).toBe(false);
+    expect(scope.allowedServices).toBeNull();
+  });
+
+  it('marks a disabled row as deny-all', () => {
+    const scope = buildAccessScope(row({ enabled: false, allowedLlmServices: ['openai'] }));
+    expect(scope.denyAll).toBe(true);
+    expect(scope.allowedServices).toEqual([]);
+  });
+
+  it('reads columns through .get() rather than plain property access', () => {
+    const scope = buildAccessScope(
+      row({ allowedLlmServices: ['openai'], allowAllModels: false, allowedModels: ['openai/gpt-4o'] }),
+    );
+    expect(scope.allowedServices).toEqual(['openai']);
+    expect(scope.allowAllModels).toBe(false);
+    expect(scope.allowedModels.has('openai/gpt-4o')).toBe(true);
+  });
+
+  it('defaults allowAllModels to true when the column is unset', () => {
+    expect(buildAccessScope(row({ allowedLlmServices: [] })).allowAllModels).toBe(true);
+  });
+
+  it('discards non-string entries in the json arrays', () => {
+    const scope = buildAccessScope(
+      row({ allowedLlmServices: ['openai', null, 42, ''], allowedModels: [{}, 'openai/gpt-4o'] }),
+    );
+    expect(scope.allowedServices).toEqual(['openai']);
+    expect([...scope.allowedModels]).toEqual(['openai/gpt-4o']);
+  });
+});
+
+describe('isServiceAllowed', () => {
+  const noRecord = buildAccessScope(null);
+
+  it('leaves behaviour unchanged for a user with no record', () => {
+    expect(isServiceAllowed(noRecord, ['openai'], OPENAI)).toBe(true);
+    expect(isServiceAllowed(noRecord, ['openai'], ANTHROPIC)).toBe(false);
+    expect(isServiceAllowed(noRecord, [], ANTHROPIC)).toBe(true);
+  });
+
+  it('denies everything when the record is disabled', () => {
+    const scope = buildAccessScope(row({ enabled: false, allowedLlmServices: ['openai'] }));
+    expect(isServiceAllowed(scope, ['openai'], OPENAI)).toBe(false);
+  });
+
+  it('denies everything when the service list is empty', () => {
+    const scope = buildAccessScope(row({ allowedLlmServices: [] }));
+    expect(isServiceAllowed(scope, ['openai'], OPENAI)).toBe(false);
+    expect(isServiceAllowed(scope, [], OPENAI)).toBe(false);
+  });
+
+  it('never widens the global whitelist (strict subset)', () => {
+    const scope = buildAccessScope(row({ allowedLlmServices: ['openai', 'anthropic'] }));
+    expect(isServiceAllowed(scope, ['openai'], OPENAI)).toBe(true);
+    // Granted to the user, but absent from the global whitelist → still denied.
+    expect(isServiceAllowed(scope, ['openai'], ANTHROPIC)).toBe(false);
+  });
+
+  it('matches a service by title as well as by name', () => {
+    const byTitle = buildAccessScope(row({ allowedLlmServices: ['OpenAI'] }));
+    expect(isServiceAllowed(byTitle, ['OpenAI'], OPENAI)).toBe(true);
+    expect(isServiceAllowed(byTitle, [], OPENAI)).toBe(true);
+    expect(isServiceAllowed(byTitle, [], ANTHROPIC)).toBe(false);
+  });
+
+  it('narrows within an empty global whitelist', () => {
+    const scope = buildAccessScope(row({ allowedLlmServices: ['openai'] }));
+    expect(isServiceAllowed(scope, [], OPENAI)).toBe(true);
+    expect(isServiceAllowed(scope, [], ANTHROPIC)).toBe(false);
+  });
+
+  it('tolerates a null or malformed global whitelist', () => {
+    expect(isServiceAllowed(noRecord, null, OPENAI)).toBe(true);
+    expect(isServiceAllowed(noRecord, 'openai', OPENAI)).toBe(true);
+  });
+});
+
+describe('isModelAllowed', () => {
+  it('allows every model when the user has no record', () => {
+    expect(isModelAllowed(buildAccessScope(null), 'openai/gpt-4o')).toBe(true);
+  });
+
+  it('allows every model of the granted services when allowAllModels is true', () => {
+    const scope = buildAccessScope(row({ allowedLlmServices: ['openai'], allowAllModels: true }));
+    expect(isModelAllowed(scope, 'openai/anything')).toBe(true);
+  });
+
+  it('restricts to the listed models when allowAllModels is false', () => {
+    const scope = buildAccessScope(
+      row({ allowedLlmServices: ['openai'], allowAllModels: false, allowedModels: ['openai/gpt-4o'] }),
+    );
+    expect(isModelAllowed(scope, 'openai/gpt-4o')).toBe(true);
+    expect(isModelAllowed(scope, 'openai/gpt-4o-mini')).toBe(false);
+  });
+
+  it('denies every model when the record is disabled', () => {
+    const scope = buildAccessScope(row({ enabled: false, allowAllModels: true }));
+    expect(isModelAllowed(scope, 'openai/gpt-4o')).toBe(false);
+  });
+});
+
+describe('resolveUserAccessScope', () => {
+  it('returns the no-record scope for an unauthenticated context', async () => {
+    const { ctx, findOne } = mockContext({ userId: null });
+    expect((await resolveUserAccessScope(ctx)).hasUserRecord).toBe(false);
+    expect(findOne).not.toHaveBeenCalled();
+  });
+
+  it('caches the scope per user instead of querying on every request', async () => {
+    const { ctx, findOne } = mockContext({ row: row({ allowedLlmServices: ['openai'] }) });
+    await resolveUserAccessScope(ctx);
+    await resolveUserAccessScope(ctx);
+    expect(findOne).toHaveBeenCalledTimes(1);
+  });
+
+  it('re-queries after the cache is invalidated for that user', async () => {
+    const { ctx, findOne } = mockContext({ userId: 7, row: row({ allowedLlmServices: ['openai'] }) });
+    await resolveUserAccessScope(ctx);
+    invalidateUserPermissionCache(7);
+    await resolveUserAccessScope(ctx);
+    expect(findOne).toHaveBeenCalledTimes(2);
+  });
+
+  it('keeps other users cached when one user is invalidated', async () => {
+    const first = mockContext({ userId: 1, row: row({ allowedLlmServices: ['openai'] }) });
+    const second = mockContext({ userId: 2, row: row({ allowedLlmServices: ['openai'] }) });
+    await resolveUserAccessScope(first.ctx);
+    await resolveUserAccessScope(second.ctx);
+    invalidateUserPermissionCache(2);
+    await resolveUserAccessScope(first.ctx);
+    expect(first.findOne).toHaveBeenCalledTimes(1);
+  });
+
+  it('fails closed when the collection is unavailable', async () => {
+    const { ctx } = mockContext({ throws: true });
+    const scope = await resolveUserAccessScope(ctx);
+    // Treating a failed lookup as "no record" would silently lift every user's restrictions
+    // during a rolling upgrade where the table does not exist yet.
+    expect(scope.lookupFailed).toBe(true);
+    expect(scope.denyAll).toBe(true);
+    expect(ctx.log.error).toHaveBeenCalled();
+  });
+
+  it('denies every service and model when the lookup failed', async () => {
+    const { ctx } = mockContext({ throws: true });
+    const scope = await resolveUserAccessScope(ctx);
+    expect(isServiceAllowed(scope, [], OPENAI)).toBe(false);
+    expect(isModelAllowed(scope, 'openai/gpt-4o')).toBe(false);
+  });
+
+  it('does not cache a failed lookup', async () => {
+    const { ctx, findOne } = mockContext({ throws: true });
+    await resolveUserAccessScope(ctx);
+    await resolveUserAccessScope(ctx);
+    expect(findOne).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not share a cache entry between apps with the same user id', async () => {
+    const main = mockContext({ userId: 1, appName: 'main', row: row({ allowedLlmServices: ['openai'] }) });
+    const sub = mockContext({ userId: 1, appName: 'sub', row: row({ allowedLlmServices: ['anthropic'] }) });
+    await resolveUserAccessScope(main.ctx);
+    const subScope = await resolveUserAccessScope(sub.ctx);
+    // Sub-apps share this process but have separate databases, so user 1 in "sub" is a
+    // different person than user 1 in "main" and must not inherit their grant.
+    expect(sub.findOne).toHaveBeenCalledTimes(1);
+    expect(subScope.allowedServices).toEqual(['anthropic']);
+  });
+
+  it('invalidates a user across every app', async () => {
+    const main = mockContext({ userId: 1, appName: 'main', row: row({ allowedLlmServices: ['openai'] }) });
+    const sub = mockContext({ userId: 1, appName: 'sub', row: row({ allowedLlmServices: ['openai'] }) });
+    await resolveUserAccessScope(main.ctx);
+    await resolveUserAccessScope(sub.ctx);
+    invalidateUserPermissionCache(1);
+    await resolveUserAccessScope(main.ctx);
+    await resolveUserAccessScope(sub.ctx);
+    expect(main.findOne).toHaveBeenCalledTimes(2);
+    expect(sub.findOne).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not invalidate a user whose id is a suffix of another', async () => {
+    const first = mockContext({ userId: 1, row: row({ allowedLlmServices: ['openai'] }) });
+    const second = mockContext({ userId: 21, row: row({ allowedLlmServices: ['openai'] }) });
+    await resolveUserAccessScope(first.ctx);
+    await resolveUserAccessScope(second.ctx);
+    invalidateUserPermissionCache(1);
+    await resolveUserAccessScope(second.ctx);
+    expect(second.findOne).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('enforceModelAccess', () => {
+  it('passes a permitted service and model through untouched', async () => {
+    const { ctx } = mockContext({ row: row({ allowedLlmServices: ['openai'] }) });
+    expect(await enforceModelAccess(ctx, ['openai'], OPENAI, 'gpt-4o')).toBe(true);
+    expect(ctx.status).toBe(200);
+  });
+
+  it('returns 403 model_not_available for a denied service', async () => {
+    const { ctx } = mockContext({ row: row({ allowedLlmServices: ['openai'] }) });
+    expect(await enforceModelAccess(ctx, ['openai', 'anthropic'], ANTHROPIC, 'claude')).toBe(false);
+    expect(ctx.status).toBe(403);
+    // `permission_denied` is what every other 403 in this plugin reports; keeping the type
+    // consistent means OpenAI clients can branch on it uniformly.
+    expect(ctx.body).toMatchObject({ error: { code: 'model_not_available', type: 'permission_denied' } });
+  });
+
+  it('returns 403 model_not_available for a denied model of a granted service', async () => {
+    const { ctx } = mockContext({
+      row: row({ allowedLlmServices: ['openai'], allowAllModels: false, allowedModels: ['openai/gpt-4o'] }),
+    });
+    expect(await enforceModelAccess(ctx, ['openai'], OPENAI, 'gpt-4o-mini')).toBe(false);
+    expect(ctx.status).toBe(403);
+    expect(ctx.body).toMatchObject({ error: { code: 'model_not_available', type: 'permission_denied' } });
+  });
+
+  it('denies a user-granted service that the global whitelist excludes', async () => {
+    const { ctx } = mockContext({ row: row({ allowedLlmServices: ['anthropic'] }) });
+    expect(await enforceModelAccess(ctx, ['openai'], ANTHROPIC, 'claude')).toBe(false);
+    expect(ctx.status).toBe(403);
+  });
+
+  it('returns a retryable 503 rather than allowing access when the lookup fails', async () => {
+    const { ctx } = mockContext({ throws: true });
+    expect(await enforceModelAccess(ctx, [], OPENAI, 'gpt-4o')).toBe(false);
+    // 503 not 403: the failure is ours, so clients should back off rather than treat the
+    // grant as permanently revoked.
+    expect(ctx.status).toBe(503);
+    expect(ctx.body).toMatchObject({ error: { code: 'permission_check_failed' } });
+  });
+});

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

@@ -0,0 +1,46 @@
+/**
+ * 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: 'aiApiUserPermissions',
+  autoGenId: true,
+  fields: [
+    { name: 'userId', type: 'bigInt', allowNull: false, index: true },
+    {
+      name: 'user',
+      type: 'belongsTo',
+      target: 'users',
+      targetKey: 'id',
+      foreignKey: 'userId',
+      constraints: false,
+    },
+    { name: 'enabled', type: 'boolean', defaultValue: true, index: true },
+    {
+      name: 'allowedLlmServices',
+      type: 'json',
+      defaultValue: [],
+      comment: 'LLM service names/titles this user may use. Empty means the user is denied every service.',
+    },
+    { name: 'allowAllModels', type: 'boolean', defaultValue: true },
+    {
+      name: 'allowedModels',
+      type: 'json',
+      defaultValue: [],
+      comment: 'Array of "serviceName/modelId" this user may use (when allowAllModels=false)',
+    },
+  ],
+  indexes: [
+    {
+      fields: ['userId'],
+      unique: true,
+    },
+  ],
+});