plugin-ai-api 1.0.24 → 1.0.28

package/src/server/__tests__/file-processor.test.ts

@@ -0,0 +1,225 @@
+import dns from 'dns';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  FileProcessorError,
+  fetchFileAsBase64,
+  httpFileUrlFetcher,
+  isBlockedAddress,
+  type FileProcessorContext,
+} from '../services/file-processor';
+
+const PUBLIC_ADDRESS = { address: '93.184.216.34', family: 4 };
+
+function mockDnsLookup(...results: Array<Array<{ address: string; family: number }>>) {
+  const spy = vi.spyOn(dns.promises, 'lookup');
+  for (const addresses of results) {
+    // The overloaded lookup signatures defeat vitest's inferred mock value type.
+    spy.mockResolvedValueOnce(addresses as never);
+  }
+  spy.mockRejectedValue(new Error('unexpected dns lookup'));
+  return spy;
+}
+
+function mockFetch(...responses: Response[]) {
+  const fetchMock = vi.fn();
+  for (const response of responses) {
+    fetchMock.mockResolvedValueOnce(response);
+  }
+  fetchMock.mockRejectedValue(new Error('unexpected fetch'));
+  vi.stubGlobal('fetch', fetchMock);
+  return fetchMock;
+}
+
+function okResponse(body: string, contentType = 'text/plain') {
+  return new Response(body, {
+    status: 200,
+    headers: { 'content-type': contentType, 'content-length': String(Buffer.byteLength(body)) },
+  });
+}
+
+function redirectResponse(location: string, status = 302) {
+  return new Response(null, { status, headers: { location } });
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+describe('isBlockedAddress', () => {
+  it('blocks private, loopback, link-local and reserved IPv4 ranges', () => {
+    expect(isBlockedAddress('0.0.0.0')).toBe(true);
+    expect(isBlockedAddress('10.0.0.1')).toBe(true);
+    expect(isBlockedAddress('100.64.0.1')).toBe(true);
+    expect(isBlockedAddress('100.127.255.255')).toBe(true);
+    expect(isBlockedAddress('127.0.0.1')).toBe(true);
+    expect(isBlockedAddress('169.254.169.254')).toBe(true);
+    expect(isBlockedAddress('172.16.0.1')).toBe(true);
+    expect(isBlockedAddress('172.31.255.255')).toBe(true);
+    expect(isBlockedAddress('192.0.0.1')).toBe(true);
+    expect(isBlockedAddress('192.168.0.10')).toBe(true);
+    expect(isBlockedAddress('198.18.0.1')).toBe(true);
+    expect(isBlockedAddress('198.19.0.1')).toBe(true);
+    expect(isBlockedAddress('224.0.0.1')).toBe(true);
+    expect(isBlockedAddress('255.255.255.255')).toBe(true);
+  });
+
+  it('allows public IPv4 addresses at the range boundaries', () => {
+    expect(isBlockedAddress('8.8.8.8')).toBe(false);
+    expect(isBlockedAddress('100.63.255.255')).toBe(false);
+    expect(isBlockedAddress('100.128.0.0')).toBe(false);
+    expect(isBlockedAddress('172.15.255.255')).toBe(false);
+    expect(isBlockedAddress('172.32.0.0')).toBe(false);
+    expect(isBlockedAddress('192.167.0.1')).toBe(false);
+    expect(isBlockedAddress('198.17.255.255')).toBe(false);
+    expect(isBlockedAddress('198.20.0.0')).toBe(false);
+  });
+
+  it('blocks unspecified, loopback, ULA, link-local and multicast IPv6 addresses', () => {
+    expect(isBlockedAddress('::')).toBe(true);
+    expect(isBlockedAddress('::1')).toBe(true);
+    expect(isBlockedAddress('fc00::1')).toBe(true);
+    expect(isBlockedAddress('fd12:3456::1')).toBe(true);
+    expect(isBlockedAddress('fe80::1')).toBe(true);
+    expect(isBlockedAddress('febf::1')).toBe(true);
+    expect(isBlockedAddress('ff02::1')).toBe(true);
+  });
+
+  it('blocks IPv6 forms that embed blocked IPv4 addresses', () => {
+    expect(isBlockedAddress('::ffff:127.0.0.1')).toBe(true);
+    expect(isBlockedAddress('::ffff:10.0.0.1')).toBe(true);
+    expect(isBlockedAddress('::ffff:169.254.169.254')).toBe(true);
+    expect(isBlockedAddress('::10.0.0.1')).toBe(true);
+    expect(isBlockedAddress('64:ff9b::7f00:1')).toBe(true);
+  });
+
+  it('allows public IPv6 addresses', () => {
+    expect(isBlockedAddress('2001:4860:4860::8888')).toBe(false);
+    expect(isBlockedAddress('2606:4700:4700::1111')).toBe(false);
+    expect(isBlockedAddress('::ffff:8.8.8.8')).toBe(false);
+    expect(isBlockedAddress('64:ff9b::808:808')).toBe(false);
+  });
+
+  it('blocks unparseable input defensively', () => {
+    expect(isBlockedAddress('')).toBe(true);
+    expect(isBlockedAddress('not-an-ip')).toBe(true);
+    expect(isBlockedAddress('1::2::3')).toBe(true);
+    expect(isBlockedAddress('1.2.3')).toBe(true);
+    expect(isBlockedAddress('1.2.3.256')).toBe(true);
+  });
+});
+
+describe('fetchFileAsBase64 SSRF protection', () => {
+  it('blocks hosts that resolve to private addresses before fetching', async () => {
+    const lookupSpy = mockDnsLookup([{ address: '169.254.169.254', family: 4 }]);
+    const fetchMock = mockFetch();
+    await expect(fetchFileAsBase64('https://evil.example.com/latest/meta-data')).rejects.toMatchObject({
+      code: 'blocked_host',
+    });
+    expect(lookupSpy).toHaveBeenCalledWith('evil.example.com', { all: true });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('blocks when any resolved address is private', async () => {
+    mockDnsLookup([PUBLIC_ADDRESS, { address: '10.0.0.1', family: 4 }]);
+    const fetchMock = mockFetch();
+    await expect(fetchFileAsBase64('https://dual.example.com/file')).rejects.toMatchObject({
+      code: 'blocked_host',
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('fetches files from public hosts', async () => {
+    mockDnsLookup([PUBLIC_ADDRESS]);
+    const fetchMock = mockFetch(okResponse('hello world'));
+    const result = await fetchFileAsBase64('https://example.com/doc.txt');
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://example.com/doc.txt',
+      expect.objectContaining({ redirect: 'manual' }),
+    );
+    expect(result.mimeType).toBe('text/plain');
+    expect(result.filename).toBe('doc.txt');
+    expect(result.fileData).toBe(`data:text/plain;base64,${Buffer.from('hello world').toString('base64')}`);
+  });
+
+  it('blocks redirects that point at private hosts', async () => {
+    const lookupSpy = mockDnsLookup([PUBLIC_ADDRESS], [{ address: '127.0.0.1', family: 4 }]);
+    const fetchMock = mockFetch(redirectResponse('http://internal.example/secret'));
+    await expect(fetchFileAsBase64('https://example.com/file')).rejects.toMatchObject({ code: 'blocked_host' });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(lookupSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('follows redirects to allowed public hosts', async () => {
+    mockDnsLookup([PUBLIC_ADDRESS], [{ address: '104.16.0.1', family: 4 }]);
+    const fetchMock = mockFetch(redirectResponse('https://cdn.example.com/doc.txt', 301), okResponse('payload'));
+    const result = await fetchFileAsBase64('https://example.com/doc.txt');
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(result.fileData).toBe(`data:text/plain;base64,${Buffer.from('payload').toString('base64')}`);
+    expect(result.filename).toBe('doc.txt');
+  });
+
+  it('resolves relative redirect locations against the current URL', async () => {
+    mockDnsLookup([PUBLIC_ADDRESS], [PUBLIC_ADDRESS]);
+    const fetchMock = mockFetch(redirectResponse('/moved/doc.txt'), okResponse('data'));
+    await fetchFileAsBase64('https://example.com/doc.txt');
+    expect(fetchMock).toHaveBeenLastCalledWith(
+      'https://example.com/moved/doc.txt',
+      expect.objectContaining({ redirect: 'manual' }),
+    );
+  });
+
+  it('blocks literal private IP hosts without DNS lookup or fetch', async () => {
+    const lookupSpy = vi.spyOn(dns.promises, 'lookup');
+    const fetchMock = mockFetch();
+    await expect(fetchFileAsBase64('http://192.168.0.10/x')).rejects.toMatchObject({ code: 'blocked_host' });
+    expect(lookupSpy).not.toHaveBeenCalled();
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('blocks bracketed IPv6 loopback literals', async () => {
+    const fetchMock = mockFetch();
+    await expect(fetchFileAsBase64('http://[::1]/x')).rejects.toMatchObject({ code: 'blocked_host' });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('stops after the redirect limit', async () => {
+    const lookupSpy = vi.spyOn(dns.promises, 'lookup');
+    lookupSpy.mockResolvedValue([PUBLIC_ADDRESS] as never);
+    const fetchMock = vi.fn().mockResolvedValue(redirectResponse('https://example.com/loop'));
+    vi.stubGlobal('fetch', fetchMock);
+    await expect(fetchFileAsBase64('https://example.com/loop', { maxRedirects: 3 })).rejects.toMatchObject({
+      code: 'too_many_redirects',
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(4);
+  });
+
+  it('reports DNS failures as fetch_failed', async () => {
+    const lookupSpy = vi.spyOn(dns.promises, 'lookup');
+    lookupSpy.mockRejectedValue(new Error('getaddrinfo ENOTFOUND'));
+    const fetchMock = mockFetch();
+    await expect(fetchFileAsBase64('https://no-such-host.example/x')).rejects.toMatchObject({
+      code: 'fetch_failed',
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('keeps the existing URL validation errors', async () => {
+    await expect(fetchFileAsBase64('not a url')).rejects.toMatchObject({ code: 'invalid_url' });
+    await expect(fetchFileAsBase64('ftp://example.com/file')).rejects.toMatchObject({
+      code: 'unsupported_protocol',
+    });
+  });
+
+  it('surfaces blocked hosts through the httpFileUrlFetcher processor', async () => {
+    const fetchMock = mockFetch();
+    const context = { ctx: {} } as unknown as FileProcessorContext;
+    await expect(
+      httpFileUrlFetcher.process({ type: 'file_url', file_url: { url: 'http://10.0.0.5/data.pdf' } }, context),
+    ).rejects.toBeInstanceOf(FileProcessorError);
+    await expect(
+      httpFileUrlFetcher.process({ type: 'file_url', file_url: { url: 'http://10.0.0.5/data.pdf' } }, context),
+    ).rejects.toMatchObject({ code: 'blocked_host' });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -21,7 +21,7 @@ function permissionLookupFailureContext() {
       getRepository: (name: string) => {
         if (name === 'aiApiConfig') return { findOne: vi.fn(async () => null) };
         if (name === 'llmServices') return { find: vi.fn(async () => []) };
-        if (name === 'aiApiUserPermissions') {
+        if (name === 'aiApiGroupMembers') {
           return { findOne: vi.fn(async () => Promise.reject(new Error('permission database unavailable'))) };
         }
         return { find: vi.fn(async () => []) };

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__/permission-sync.test.ts

@@ -10,60 +10,61 @@
 import { Context } from '@nocobase/actions';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { PluginAiApiServer } from '../plugin';
-import { invalidateUserPermissionCache, resolveUserAccessScope } from '../utils/user-permissions';
+import { invalidateGroupAccessCache, resolveUserAccessScope } from '../utils/user-permissions';
 
 /**
- * Covers the cross-node half of permission revocation.
+ * Covers the cross-node half of group-access invalidation.
  *
  * syncMessageManager hardcodes `skipSelf: true` (sync-message-manager.ts:59,73), so the node
  * that writes the change never receives its own broadcast. That makes two things load-bearing
  * and easy to regress: the writer must invalidate its own cache locally, and every other node
  * must invalidate on receipt. Neither is observable from a single-node test of the cache alone.
  */
-function mockContext(userId: number, row: unknown) {
-  const findOne = vi.fn(async () => row);
+function row(values: Record<string, unknown>) {
+  return { get: (key?: string) => (key === undefined ? values : values[key]) };
+}
+
+function mockContext(userId: number, groupValues: Record<string, unknown>) {
+  const group = row({ allowedLlmServices: [], allowAllModels: true, allowedModels: [], ...groupValues });
+  const findOne = vi.fn(async () => row({ group }));
   const ctx = {
     state: { currentUser: { id: userId } },
-    db: { getRepository: () => ({ findOne }) },
+    db: {
+      getRepository: (name: string) =>
+        name === 'aiApiGroupMembers' ? { findOne } : { findOne: async () => null, create: vi.fn() },
+    },
     app: { name: 'main' },
     log: { warn: vi.fn(), error: vi.fn() },
   } as unknown as Context;
   return { ctx, findOne };
 }
 
-function row(values: Record<string, unknown>) {
-  return { get: (key: string) => values[key] };
-}
-
 beforeEach(() => {
-  invalidateUserPermissionCache();
+  invalidateGroupAccessCache();
 });
 
-describe('cross-node permission invalidation', () => {
+describe('cross-node group access invalidation', () => {
   it("drops the receiving node's cached scope", async () => {
     const plugin = Object.create(PluginAiApiServer.prototype) as PluginAiApiServer;
-    const { ctx, findOne } = mockContext(1, row({ allowedLlmServices: ['openai'] }));
+    const { ctx } = mockContext(1, { id: 5, allowedLlmServices: ['openai'] });
 
-    await resolveUserAccessScope(ctx);
-    await resolveUserAccessScope(ctx);
-    expect(findOne).toHaveBeenCalledTimes(1);
+    const before = await resolveUserAccessScope(ctx);
+    expect(await resolveUserAccessScope(ctx)).toBe(before);
 
-    await plugin.handleSyncMessage({ type: 'invalidateUserPermissions', userId: 1 });
+    await plugin.handleSyncMessage({ type: 'invalidateGroupAccess', groupId: 5 });
 
-    await resolveUserAccessScope(ctx);
-    expect(findOne).toHaveBeenCalledTimes(2);
+    expect(await resolveUserAccessScope(ctx)).not.toBe(before);
   });
 
-  it('ignores unrelated message types and other users', async () => {
+  it('ignores unrelated message types and other groups', async () => {
     const plugin = Object.create(PluginAiApiServer.prototype) as PluginAiApiServer;
-    const { ctx, findOne } = mockContext(1, row({ allowedLlmServices: ['openai'] }));
-    await resolveUserAccessScope(ctx);
+    const { ctx } = mockContext(1, { id: 5, allowedLlmServices: ['openai'] });
+    const before = await resolveUserAccessScope(ctx);
 
-    await plugin.handleSyncMessage({ type: 'somethingElse', userId: 1 });
-    await plugin.handleSyncMessage({ type: 'invalidateUserPermissions', userId: 2 });
+    await plugin.handleSyncMessage({ type: 'somethingElse', groupId: 5 });
+    await plugin.handleSyncMessage({ type: 'invalidateGroupAccess', groupId: 6 });
 
-    await resolveUserAccessScope(ctx);
-    expect(findOne).toHaveBeenCalledTimes(1);
+    expect(await resolveUserAccessScope(ctx)).toBe(before);
   });
 
   it('tolerates a malformed message instead of throwing into the subscriber', async () => {
@@ -77,18 +78,16 @@ describe('cross-node permission invalidation', () => {
     const sendSyncMessage = vi.fn(async () => undefined);
     Object.assign(plugin, { sendSyncMessage });
 
-    const { ctx, findOne } = mockContext(1, row({ allowedLlmServices: ['openai'] }));
-    await resolveUserAccessScope(ctx);
-    expect(findOne).toHaveBeenCalledTimes(1);
+    const { ctx } = mockContext(1, { id: 5, allowedLlmServices: ['openai'] });
+    const before = await resolveUserAccessScope(ctx);
 
-    // revokeUserPermissions is private; reach it the way the db hook does.
-    (plugin as unknown as { revokeUserPermissions: (id: unknown, tx?: unknown) => void }).revokeUserPermissions(1);
+    // invalidateGroupAccess is private; reach it the way the db hook does.
+    (plugin as unknown as { invalidateGroupAccess: (id: unknown, tx?: unknown) => void }).invalidateGroupAccess(5);
 
     // Local cache cleared without any message coming back to us.
-    await resolveUserAccessScope(ctx);
-    expect(findOne).toHaveBeenCalledTimes(2);
+    expect(await resolveUserAccessScope(ctx)).not.toBe(before);
     expect(sendSyncMessage).toHaveBeenCalledWith(
-      { type: 'invalidateUserPermissions', userId: 1 },
+      { type: 'invalidateGroupAccess', groupId: 5 },
       { transaction: undefined },
     );
   });
@@ -99,11 +98,11 @@ describe('cross-node permission invalidation', () => {
     Object.assign(plugin, { sendSyncMessage });
     const transaction = { id: 'tx-1' };
 
-    (plugin as unknown as { revokeUserPermissions: (id: unknown, tx?: unknown) => void }).revokeUserPermissions(
+    (plugin as unknown as { invalidateGroupAccess: (id: unknown, tx?: unknown) => void }).invalidateGroupAccess(
       7,
       transaction,
     );
 
-    expect(sendSyncMessage).toHaveBeenCalledWith({ type: 'invalidateUserPermissions', userId: 7 }, { transaction });
+    expect(sendSyncMessage).toHaveBeenCalledWith({ type: 'invalidateGroupAccess', groupId: 7 }, { transaction });
   });
 });

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-groups.test.ts

@@ -0,0 +1,160 @@
+import type { Context } from '@nocobase/actions';
+import { createMockDatabase, type Database } from '@nocobase/database';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { resolveUserGroup, getDefaultGroup } from '../quota-groups';
+
+describe('AI API usage groups', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = await createMockDatabase();
+    db.collection({
+      name: 'aiApiUsageGroups',
+      fields: [
+        { name: 'name', type: 'string' },
+        { name: 'isDefault', type: 'boolean' },
+        { name: 'quotaMode', type: 'string' },
+        { name: 'rateLimitPerMinute', type: 'integer' },
+        { name: 'enabled', type: 'boolean' },
+        { name: 'periodType', type: 'string' },
+        { name: 'timezone', type: 'string' },
+        { name: 'requestLimit', type: 'bigInt' },
+        { name: 'totalTokenLimit', type: 'bigInt' },
+        { name: 'costLimit', type: 'decimal', precision: 20, scale: 8 },
+        { name: 'currency', type: 'string' },
+        { name: 'rejectUnpricedModel', type: 'boolean' },
+        { name: 'missingUsageBehavior', type: 'string' },
+        { name: 'contextOverflowBehavior', type: 'string' },
+        { name: 'allowedLlmServices', type: 'json' },
+        { name: 'allowAllModels', type: 'boolean' },
+        { name: 'allowedModels', type: 'json' },
+      ],
+    });
+    db.collection({
+      name: 'aiApiGroupMembers',
+      fields: [
+        { name: 'groupId', type: 'bigInt' },
+        {
+          name: 'group',
+          type: 'belongsTo',
+          target: 'aiApiUsageGroups',
+          targetKey: 'id',
+          foreignKey: 'groupId',
+        },
+        { name: 'userId', type: 'bigInt' },
+      ],
+      indexes: [{ fields: ['userId'], unique: true }],
+    });
+    await db.sync({ force: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  function context(): Context {
+    return { db, request: {}, state: {} } as unknown as Context;
+  }
+
+  it('creates the default group lazily with open model access', async () => {
+    const group = await getDefaultGroup(context());
+    expect(group.name).toBe('Default');
+    expect(group.isDefault).toBe(true);
+    expect(group.quotaMode).toBe('per_user');
+    // The default group must never lock everyone out: empty lists mean "no narrowing".
+    expect(group.allowedLlmServices).toEqual([]);
+    expect(group.allowAllModels).toBe(true);
+    expect(group.allowedModels).toEqual([]);
+
+    const second = await getDefaultGroup(context());
+    expect(second.id).toBe(group.id);
+  });
+
+  it('resolves an unassigned user to the default group', async () => {
+    const group = await resolveUserGroup(context(), 99);
+    expect(group.name).toBe('Default');
+    expect(group.isDefault).toBe(true);
+  });
+
+  it('resolves an assigned user to their explicit group', async () => {
+    const custom = await db.getRepository('aiApiUsageGroups').create({
+      values: {
+        name: 'Pro',
+        isDefault: false,
+        quotaMode: 'share',
+        rateLimitPerMinute: 120,
+        enabled: true,
+        periodType: 'monthly',
+        timezone: 'UTC',
+        currency: 'USD',
+        rejectUnpricedModel: true,
+        missingUsageBehavior: 'use_reserved',
+        contextOverflowBehavior: 'reject',
+      },
+    });
+    await db.getRepository('aiApiGroupMembers').create({
+      values: { groupId: custom.get('id'), userId: 42 },
+    });
+
+    const group = await resolveUserGroup(context(), 42);
+    expect(group.name).toBe('Pro');
+    expect(group.quotaMode).toBe('share');
+  });
+
+  it('carries the model access fields through group resolution', async () => {
+    const custom = await db.getRepository('aiApiUsageGroups').create({
+      values: {
+        name: 'Restricted',
+        isDefault: false,
+        quotaMode: 'per_user',
+        rateLimitPerMinute: 60,
+        enabled: false,
+        periodType: 'monthly',
+        timezone: 'UTC',
+        currency: 'USD',
+        rejectUnpricedModel: true,
+        missingUsageBehavior: 'use_reserved',
+        contextOverflowBehavior: 'reject',
+        allowedLlmServices: ['svc'],
+        allowAllModels: false,
+        allowedModels: ['svc/model-a'],
+      },
+    });
+    await db.getRepository('aiApiGroupMembers').create({
+      values: { groupId: custom.get('id'), userId: 43 },
+    });
+
+    const group = await resolveUserGroup(context(), 43);
+    expect(group.allowedLlmServices).toEqual(['svc']);
+    expect(group.allowAllModels).toBe(false);
+    expect(group.allowedModels).toEqual(['svc/model-a']);
+  });
+
+  it('drops non-string entries from the access lists', async () => {
+    const custom = await db.getRepository('aiApiUsageGroups').create({
+      values: {
+        name: 'Messy',
+        isDefault: false,
+        quotaMode: 'per_user',
+        rateLimitPerMinute: 60,
+        enabled: false,
+        periodType: 'monthly',
+        timezone: 'UTC',
+        currency: 'USD',
+        rejectUnpricedModel: true,
+        missingUsageBehavior: 'use_reserved',
+        contextOverflowBehavior: 'reject',
+        allowedLlmServices: ['svc', null, 42],
+        allowAllModels: false,
+        allowedModels: [{ k: 1 }, 'svc/model-a'],
+      },
+    });
+    await db.getRepository('aiApiGroupMembers').create({
+      values: { groupId: custom.get('id'), userId: 44 },
+    });
+
+    const group = await resolveUserGroup(context(), 44);
+    expect(group.allowedLlmServices).toEqual(['svc']);
+    expect(group.allowedModels).toEqual(['svc/model-a']);
+  });
+});

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

@@ -10,6 +10,7 @@ describe('AI API usage monitor summary', () => {
       inputTokens: '100',
       outputTokens: '25',
       totalTokens: '125',
+      promptCacheTokens: '40',
     });
     const findAll = vi.fn().mockResolvedValue([
       { currency: 'USD', totalCost: '0.12500000' },
@@ -53,6 +54,7 @@ describe('AI API usage monitor summary', () => {
       inputTokens: 100,
       outputTokens: 25,
       totalTokens: 125,
+      promptCacheTokens: 40,
       costsByCurrency: [
         { currency: 'USD', totalCost: '0.12500000' },
         { currency: 'EUR', totalCost: '0.05000000' },