Site settings → AI, the usage tables and the 80% email show input/output tokens and the percentage; the rand amounts from the Hub are dropped on arrival. AiCall stores each call's tokens (migration ai_tokens). v2 /ai/status and /ai/usage carry tokens instead of cents. Needs Hub 2.0.1 for the token figures; older Hubs show the percentage only. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
157 lines
8.5 KiB
TypeScript
157 lines
8.5 KiB
TypeScript
// AI helpers (2.0): what the buttons do, and how a helper call goes through the Hub (§3b).
|
|
|
|
const mockCalls: Array<Record<string, unknown>> = [];
|
|
const mockSettings = new Map<string, string>();
|
|
const mockDb = {
|
|
appSetting: {
|
|
findUnique: jest.fn(async ({ where }: { where: { key: string } }) => (mockSettings.has(where.key) ? { key: where.key, value: mockSettings.get(where.key) } : null)),
|
|
upsert: jest.fn(async ({ where, update }: { where: { key: string }; update: { value: string } }) => { mockSettings.set(where.key, update.value); }),
|
|
},
|
|
aiCall: {
|
|
count: jest.fn(async () => mockCalls.filter(c => c.outcome === 'ok').length),
|
|
create: jest.fn(async ({ data }: { data: Record<string, unknown> }) => { mockCalls.push(data); return data; }),
|
|
deleteMany: jest.fn(async () => ({ count: 0 })),
|
|
},
|
|
user: { findMany: jest.fn(async () => [{ email: 'admin@test.local' }]) },
|
|
};
|
|
jest.mock('../src/config/db', () => mockDb);
|
|
|
|
const mockLicence = { connected: true, readOnly: false, state: 'active', claims: { limits: { aiMonthlyCapCents: 5000 } } as { limits: { aiMonthlyCapCents: number } } | null };
|
|
jest.mock('../src/hub/licence', () => ({ licenceStatus: jest.fn(async () => mockLicence) }));
|
|
|
|
class MockHubError extends Error {
|
|
constructor(message: string, public code: string, public statusCode: number, public data: unknown = null) { super(message); }
|
|
}
|
|
const mockPost = jest.fn();
|
|
jest.mock('../src/hub/client', () => ({ PROTOCOL_VERSION: 1, HubError: MockHubError, signedPost: (...a: unknown[]) => mockPost(...a) }));
|
|
const mockMail = jest.fn(async (_m: unknown) => undefined);
|
|
jest.mock('../src/utils/email', () => ({ sendMail: (m: unknown) => mockMail(m), emailWrapper: (s: string) => s, isSmtpConfigured: () => true }));
|
|
jest.mock('../src/utils/adminAudit', () => ({ logAdminAction: jest.fn(async () => undefined) }));
|
|
|
|
import { aiStatus, runHelper, saveAiSettings, clearAiStatusCache, tokenText, _internal } from '../src/ai';
|
|
|
|
const hubStatus = (over = {}) => ({
|
|
enabled: true, capReached: false, capCents: 5000, usedCents: 100, usedPercent: 2, renewsOn: '2026-12-01',
|
|
usedInputTokens: 40000, usedOutputTokens: 9000, capInputTokens: 1785000, capOutputTokens: 357000, ...over,
|
|
});
|
|
const req = { system: 'Write a friendly message.', input: 'Bring a sleeping bag.', maxTokens: 500 };
|
|
|
|
beforeEach(() => {
|
|
mockCalls.length = 0;
|
|
mockSettings.clear();
|
|
mockPost.mockReset();
|
|
mockMail.mockClear();
|
|
mockLicence.connected = true;
|
|
mockLicence.readOnly = false;
|
|
mockLicence.claims = { limits: { aiMonthlyCapCents: 5000 } };
|
|
clearAiStatusCache();
|
|
});
|
|
|
|
describe('status', () => {
|
|
test('a licence without AI never asks the Hub', async () => {
|
|
mockLicence.claims = { limits: { aiMonthlyCapCents: 0 } };
|
|
expect(await aiStatus()).toMatchObject({ enabled: false, capReached: false });
|
|
mockLicence.connected = false;
|
|
expect((await aiStatus()).enabled).toBe(false);
|
|
expect(mockPost).not.toHaveBeenCalled();
|
|
});
|
|
|
|
test('asks the Hub and caches its answer for a minute', async () => {
|
|
mockPost.mockResolvedValue(hubStatus());
|
|
expect(await aiStatus()).toMatchObject({ enabled: true, available: true, usedInputTokens: 40000, capOutputTokens: 357000, helpers: { draft_event: true } });
|
|
await aiStatus();
|
|
expect(mockPost).toHaveBeenCalledTimes(1);
|
|
expect(mockPost).toHaveBeenCalledWith('/api/installs/ai/status', { protocolVersion: 1 });
|
|
});
|
|
|
|
test('a Hub without AI (404) means off; an unreachable Hub keeps the buttons, marked unavailable', async () => {
|
|
mockPost.mockRejectedValueOnce(new MockHubError('Not found', 'NOT_FOUND', 404));
|
|
expect((await aiStatus()).enabled).toBe(false);
|
|
clearAiStatusCache();
|
|
mockPost.mockRejectedValueOnce(new MockHubError('down', 'HUB_UNREACHABLE', 502));
|
|
expect(await aiStatus()).toMatchObject({ enabled: true, available: false });
|
|
});
|
|
|
|
test('the Hub\'s rand amounts never leave the site (2.3.0); a Hub before 2.0.1 sends no tokens', async () => {
|
|
mockPost.mockResolvedValueOnce(hubStatus());
|
|
const s = await aiStatus() as unknown as Record<string, unknown>;
|
|
expect(s).not.toHaveProperty('capCents');
|
|
expect(s).not.toHaveProperty('usedCents');
|
|
clearAiStatusCache();
|
|
mockPost.mockResolvedValueOnce({ enabled: true, capReached: false, capCents: 5000, usedCents: 100, usedPercent: 2, renewsOn: '2026-12-01' });
|
|
expect(await aiStatus()).toMatchObject({ usedPercent: 2, usedInputTokens: null, capInputTokens: null });
|
|
});
|
|
|
|
test('tokens for people', () => {
|
|
expect(['800', '45K', '1.2M', '2M', '12M']).toEqual([800, 45000, 1200000, 2000000, 12300000].map(tokenText));
|
|
});
|
|
});
|
|
|
|
describe('running a helper', () => {
|
|
test('sends the request to the Hub, logs the call, returns the answer', async () => {
|
|
mockPost.mockResolvedValueOnce(hubStatus()).mockResolvedValueOnce({
|
|
output: 'Hi all!', usage: { inputTokens: 1840, outputTokens: 420 }, chargedCents: 0.31, status: hubStatus({ usedInputTokens: 41840, usedOutputTokens: 9420 }),
|
|
});
|
|
const r = await runHelper('draft_message', 'u1', req);
|
|
expect(r.output).toBe('Hi all!');
|
|
expect(r.status).toMatchObject({ usedInputTokens: 41840, usedOutputTokens: 9420 });
|
|
expect(mockPost).toHaveBeenLastCalledWith('/api/installs/ai/complete', { protocolVersion: 1, helper: 'draft_message', ...req }, { timeoutMs: 90000 });
|
|
expect(mockCalls).toEqual([{ userId: 'u1', helper: 'draft_message', outcome: 'ok', chargedCents: 0.31, inputTokens: 1840, outputTokens: 420 }]);
|
|
});
|
|
|
|
test('a helper switched off, or the cap reached, never reaches the Hub', async () => {
|
|
mockPost.mockResolvedValue(hubStatus({ capReached: true }));
|
|
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ code: 'FORBIDDEN', reason: 'AI_CAP_REACHED' });
|
|
clearAiStatusCache();
|
|
mockPost.mockResolvedValue(hubStatus());
|
|
await saveAiSettings({ helpers: { draft_message: false } }, { id: 'a1', role: 'admin' });
|
|
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ reason: 'AI_HELPER_OFF' });
|
|
expect(mockPost).not.toHaveBeenCalledWith('/api/installs/ai/complete', expect.anything(), expect.anything());
|
|
});
|
|
|
|
test('the per-person daily limit', async () => {
|
|
await saveAiSettings({ dailyLimitPerPerson: 1 }, { id: 'a1', role: 'admin' });
|
|
mockPost.mockResolvedValueOnce(hubStatus()).mockResolvedValueOnce({ output: 'x', chargedCents: 0.1, status: hubStatus() });
|
|
await runHelper('draft_message', 'u1', req);
|
|
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ code: 'RATE_LIMITED', reason: 'AI_DAILY_LIMIT' });
|
|
});
|
|
|
|
test('the Hub refusing at the cap updates the status, so the buttons disable at once', async () => {
|
|
mockPost.mockResolvedValueOnce(hubStatus())
|
|
.mockRejectedValueOnce(new MockHubError('used up', 'AI_CAP_REACHED', 402, { code: 'AI_CAP_REACHED', status: hubStatus({ capReached: true }) }));
|
|
await expect(runHelper('draft_message', 'u1', req)).rejects.toMatchObject({ reason: 'AI_CAP_REACHED', message: expect.stringContaining('1 December') });
|
|
expect((await aiStatus()).capReached).toBe(true);
|
|
expect(mockCalls[0]).toMatchObject({ outcome: 'cap_reached', chargedCents: 0, inputTokens: 0, outputTokens: 0 });
|
|
});
|
|
|
|
test('admins are emailed once a month at 80%', async () => {
|
|
const at80 = hubStatus({ usedPercent: 81, usedCents: 4050 });
|
|
mockPost.mockResolvedValueOnce(hubStatus()).mockResolvedValue({ output: 'x', chargedCents: 1, status: at80 });
|
|
await runHelper('draft_message', 'u1', req);
|
|
await runHelper('draft_message', 'u1', req);
|
|
expect(mockMail).toHaveBeenCalledTimes(1);
|
|
expect(mockMail.mock.calls[0]).toEqual([expect.objectContaining({ to: 'admin@test.local', subject: 'AI allowance 81% used' })]);
|
|
const text = (mockMail.mock.calls[0] as unknown as [{ text: string }])[0].text;
|
|
expect(text).toContain('40K input and 9K output tokens');
|
|
expect(text).not.toMatch(/R\d/);
|
|
});
|
|
});
|
|
|
|
describe('Hub errors', () => {
|
|
test.each([
|
|
['AI_REFUSED', 'UNAVAILABLE', 'refused'],
|
|
['AI_INCOMPLETE', 'UNAVAILABLE', 'incomplete'],
|
|
['AI_OFF', 'FORBIDDEN', 'unavailable'],
|
|
['HUB_UNREACHABLE', 'UNAVAILABLE', 'unavailable'],
|
|
])('%s → %s, logged as %s', (hubCode, code, outcome) => {
|
|
const r = _internal.fromHubError({ code: hubCode, message: 'x' });
|
|
expect(r.error.code).toBe(code);
|
|
expect(r.outcome).toBe(outcome);
|
|
});
|
|
|
|
test('today starts at midnight South African time', () => {
|
|
expect(_internal.startOfToday(new Date('2026-11-10T22:30:00Z')).toISOString()).toBe('2026-11-10T22:00:00.000Z');
|
|
expect(_internal.startOfToday(new Date('2026-11-10T10:00:00Z')).toISOString()).toBe('2026-11-09T22:00:00.000Z');
|
|
});
|
|
});
|