plugin-ai-api 1.1.1 → 1.1.2

package/src/server/__tests__/types/responses-sdk.types.test-d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compile-time structural contracts: local response shapes must be assignable to
+ * the OpenAI SDK types. If this file compiles, the runtime payload shape is SDK-compatible.
+ * Run with: tsc -p tsconfig.test.json --noEmit
+ */
+import type {
+  Response as OpenAIResponse,
+  ResponseCreatedEvent,
+  ResponseCompletedEvent,
+  ResponseUsage,
+} from 'openai/resources/responses/responses';
+import type { ResponseObject } from '../../utils/responses-format';
+
+// ─── ResponseObject must be assignable to the SDK Response type ──────────────
+declare const responseObject: ResponseObject;
+const sdkResponse: OpenAIResponse = responseObject;
+
+// ─── ResponseStreamEvent terminal payloads must be SDK-compatible ────────────
+declare const response: OpenAIResponse;
+const sdkCreated: ResponseCreatedEvent = { type: 'response.created', response, sequence_number: 0 };
+const sdkCompleted: ResponseCompletedEvent = { type: 'response.completed', response, sequence_number: 0 };
+
+export { sdkResponse, sdkCreated, sdkCompleted };

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

@@ -130,6 +130,102 @@ describe('AI API usage groups', () => {
     expect(group.allowedModels).toEqual(['svc/model-a']);
   });
 
+  it('rejects adding a member to the default group via the beforeSave guard', async () => {
+    // Mirror the plugin.ts aiApiGroupMembers.beforeSave hook: adding a member to the
+    // default group is rejected because the default group is a fallback, not a target.
+    const defaultGroup = await db.getRepository('aiApiUsageGroups').create({
+      values: {
+        name: 'Default',
+        isDefault: true,
+        quotaMode: 'per_user',
+        rateLimitPerMinute: 60,
+        enabled: false,
+        periodType: 'monthly',
+        timezone: 'UTC',
+        currency: 'USD',
+        rejectUnpricedModel: true,
+        missingUsageBehavior: 'use_reserved',
+        contextOverflowBehavior: 'reject',
+      },
+    });
+
+    db.on('aiApiGroupMembers.beforeSave', async (model) => {
+      const targetGroupId = model.get('groupId');
+      if (!targetGroupId) return;
+      const targetGroup = await db.getRepository('aiApiUsageGroups').findOne({ filterByTk: targetGroupId });
+      if (targetGroup?.get('isDefault')) {
+        throw new Error('Cannot add members to the default group.');
+      }
+    });
+
+    await expect(
+      db.getRepository('aiApiGroupMembers').create({ values: { groupId: defaultGroup.get('id'), userId: 7 } }),
+    ).rejects.toThrow('Cannot add members to the default group');
+  });
+
+  it('drops members of a deleted group so they fall back to the default group', async () => {
+    // Mirror the plugin.ts aiApiUsageGroups.beforeDestroy hook: deleting a non-default
+    // group destroys its member rows, and affected users resolve to the default group
+    // implicitly instead of being reassigned to an explicit default membership.
+    await db.getRepository('aiApiUsageGroups').create({
+      values: {
+        name: 'Default',
+        isDefault: true,
+        quotaMode: 'per_user',
+        rateLimitPerMinute: 60,
+        enabled: false,
+        periodType: 'monthly',
+        timezone: 'UTC',
+        currency: 'USD',
+        rejectUnpricedModel: true,
+        missingUsageBehavior: 'use_reserved',
+        contextOverflowBehavior: 'reject',
+      },
+    });
+    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: 55 },
+    });
+
+    db.on('aiApiUsageGroups.beforeDestroy', async (model, options) => {
+      if (model.get('isDefault')) {
+        throw new Error('The default usage group cannot be deleted.');
+      }
+      const members = await db.getRepository('aiApiGroupMembers').find({
+        filter: { groupId: model.get('id') },
+        transaction: options?.transaction,
+      });
+      for (const member of members) {
+        await db.getRepository('aiApiGroupMembers').destroy({
+          filterByTk: member.get('id'),
+          transaction: options?.transaction,
+        });
+      }
+    });
+
+    await db.getRepository('aiApiUsageGroups').destroy({ filterByTk: custom.get('id') });
+
+    const remaining = await db.getRepository('aiApiGroupMembers').findOne({ filter: { userId: 55 } });
+    expect(remaining).toBeNull();
+    // With no explicit membership, the user now resolves to the default group.
+    const resolved = await resolveUserGroup(context(), 55);
+    expect(resolved.name).toBe('Default');
+    expect(resolved.isDefault).toBe(true);
+  });
   it('drops non-string entries from the access lists', async () => {
     const custom = await db.getRepository('aiApiUsageGroups').create({
       values: {

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

@@ -7,6 +7,7 @@ import { resolveModelString } from '../utils/resolve-service';
 
 vi.mock('../utils/resolve-service', () => ({
   resolveModelString: vi.fn(),
+  resolveModelReference: vi.fn(),
 }));
 
 interface ModelResult {

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

@@ -25,6 +25,7 @@ describe('AI API usage normalization', () => {
       completion_tokens: 5,
       total_tokens: 17,
       prompt_cache_tokens: null,
+      reasoning_tokens: null,
     });
   });
 
@@ -34,6 +35,7 @@ describe('AI API usage normalization', () => {
       completion_tokens: 0,
       total_tokens: 0,
       prompt_cache_tokens: null,
+      reasoning_tokens: null,
     });
   });
 
@@ -45,15 +47,26 @@ describe('AI API usage normalization', () => {
       completion_tokens: 5,
       total_tokens: 15,
       prompt_cache_tokens: 8,
+      reasoning_tokens: null,
     });
     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,
+      reasoning_tokens: null,
     });
   });
 
+  it('extracts reasoning token details from LangChain and OpenAI usage shapes', () => {
+    expect(
+      normalizeUsage({ input_tokens: 10, output_tokens: 5, output_token_details: { reasoning: 3 } }),
+    ).toMatchObject({ reasoning_tokens: 3 });
+    expect(
+      normalizeUsage({ prompt_tokens: 10, completion_tokens: 5, completion_tokens_details: { reasoning_tokens: 4 } }),
+    ).toMatchObject({ reasoning_tokens: 4 });
+  });
+
   it('is idempotent so streaming double-normalization keeps prompt_cache_tokens', () => {
     const streamChunkUsage = {
       input_tokens: 100,
@@ -85,6 +98,7 @@ describe('AI API usage normalization', () => {
       completion_tokens: 50,
       total_tokens: 150,
       prompt_cache_tokens: 80,
+      reasoning_tokens: null,
     });
     expect(ctx.state.aiApiUsageResult).toMatchObject({
       source: 'provider',

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

@@ -5,9 +5,9 @@ vi.mock('dayjs', () => ({
   default: () => ({ tz: vi.fn() }),
 }));
 
-import { validateQuotaPolicy } from '../validation';
+import { validateModelMetadata, validateQuotaPolicy, validateVirtualModel } from '../validation';
 
-function quotaPolicy(values: Record<string, unknown>): Model {
+function record(values: Record<string, unknown>): Model {
   return {
     get: (key: string) => values[key],
   } as Model;
@@ -22,26 +22,85 @@ const requiredPolicy = {
 
 describe('AI API quota policy validation', () => {
   it('uses reject when context overflow behavior is absent', () => {
-    expect(() => validateQuotaPolicy(quotaPolicy(requiredPolicy))).not.toThrow();
+    expect(() => validateQuotaPolicy(record(requiredPolicy))).not.toThrow();
   });
 
   it.each(['reject', 'truncate'] as const)('accepts %s context overflow behavior', (contextOverflowBehavior) => {
-    expect(() => validateQuotaPolicy(quotaPolicy({ ...requiredPolicy, contextOverflowBehavior }))).not.toThrow();
+    expect(() => validateQuotaPolicy(record({ ...requiredPolicy, contextOverflowBehavior }))).not.toThrow();
   });
 
   it('rejects an unsupported context overflow behavior', () => {
-    expect(() => validateQuotaPolicy(quotaPolicy({ ...requiredPolicy, contextOverflowBehavior: 'compact' }))).toThrow(
+    expect(() => validateQuotaPolicy(record({ ...requiredPolicy, contextOverflowBehavior: 'compact' }))).toThrow(
       'contextOverflowBehavior must be reject or truncate.',
     );
   });
 
   it.each(['share', 'per_user'] as const)('accepts %s quota mode', (quotaMode) => {
-    expect(() => validateQuotaPolicy(quotaPolicy({ ...requiredPolicy, quotaMode }))).not.toThrow();
+    expect(() => validateQuotaPolicy(record({ ...requiredPolicy, quotaMode }))).not.toThrow();
   });
 
   it('rejects an unsupported quota mode', () => {
-    expect(() => validateQuotaPolicy(quotaPolicy({ ...requiredPolicy, quotaMode: 'global' }))).toThrow(
+    expect(() => validateQuotaPolicy(record({ ...requiredPolicy, quotaMode: 'global' }))).toThrow(
       'quotaMode must be share or per_user.',
     );
   });
 });
+
+describe('AI API model metadata validation', () => {
+  const validMetadata = {
+    llmService: 'openai',
+    model: 'gpt-5',
+    supportsVision: true,
+    supportsToolCalling: true,
+    reasoningTier: 'general',
+    sortOrder: 0,
+    enabled: true,
+  };
+
+  it('accepts routing metadata fields', () => {
+    expect(() => validateModelMetadata(record(validMetadata))).not.toThrow();
+  });
+
+  it('accepts omitted fields that receive collection defaults', () => {
+    expect(() => validateModelMetadata(record({ llmService: 'openai', model: 'gpt-5' }))).not.toThrow();
+  });
+
+  it.each([
+    [{ ...validMetadata, reasoningTier: 'fast' }, 'reasoningTier must be cheap, general, or reasoning.'],
+    [{ ...validMetadata, sortOrder: 1.5 }, 'sortOrder must be an integer.'],
+    [{ ...validMetadata, supportsVision: 'yes' }, 'supportsVision must be a boolean.'],
+  ])('rejects invalid routing metadata', (values, message) => {
+    expect(() => validateModelMetadata(record(values))).toThrow(message);
+  });
+});
+
+describe('AI API virtual model validation', () => {
+  const validVirtualModel = {
+    name: 'auto',
+    mode: 'chat',
+    fallbackModel: 'openai/gpt-5',
+    visionModels: [],
+    toolModels: ['openai/gpt-5'],
+    reasoningModels: [],
+    cheapModels: [],
+    generalModels: [],
+    enabled: true,
+  };
+
+  it('accepts a complete virtual model', () => {
+    expect(() => validateVirtualModel(record(validVirtualModel))).not.toThrow();
+  });
+
+  it('accepts omitted fields that receive collection defaults', () => {
+    expect(() => validateVirtualModel(record({ name: 'auto', fallbackModel: 'openai/gpt-5' }))).not.toThrow();
+  });
+
+  it.each([
+    [{ ...validVirtualModel, mode: 'audio' }, 'mode must be chat or embedding.'],
+    [{ ...validVirtualModel, fallbackModel: 'gpt-5' }, 'fallbackModel must use the service/modelId format.'],
+    [{ ...validVirtualModel, toolModels: 'openai/gpt-5' }, 'toolModels must be an array.'],
+    [{ ...validVirtualModel, visionModels: ['invalid'] }, 'visionModels[0] must use the service/modelId format.'],
+  ])('rejects an invalid virtual model', (values, message) => {
+    expect(() => validateVirtualModel(record(values))).toThrow(message);
+  });
+});