plugin-ai-api 1.1.1 → 1.1.2

package/src/server/collections/ai-api-virtual-models.ts

@@ -0,0 +1,58 @@
+/**
+ * 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';
+
+/**
+ * Virtual model aliases (e.g. "auto") that the gateway resolves to a concrete
+ * LLM model based on the request shape and the caller's access scope.
+ *
+ * The per-capability lists are ordered: the resolver walks them top-down and
+ * picks the FIRST model the current user is permitted to use. A list left empty
+ * is derived from aiApiModelMetadata (capability flags + sortOrder). When no
+ * candidate is usable, `fallbackModel` is used when it is also permitted for
+ * the caller. An alias never widens the caller's model access.
+ */
+export default defineCollection({
+  name: 'aiApiVirtualModels',
+  autoGenId: true,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+      unique: true,
+      allowNull: false,
+      comment: 'Alias the client passes as the model id, e.g. "auto".',
+    },
+    {
+      name: 'mode',
+      type: 'string',
+      defaultValue: 'chat',
+      comment: 'Endpoint family this alias serves: chat | embedding.',
+    },
+    {
+      name: 'fallbackModel',
+      type: 'string',
+      allowNull: false,
+      comment:
+        'Concrete "service/modelId" used when no capability bucket candidate is usable and fallback is permitted.',
+    },
+    {
+      name: 'visionModels',
+      type: 'json',
+      defaultValue: [],
+      comment: 'Ordered "service/modelId" list for vision requests.',
+    },
+    { name: 'toolModels', type: 'json', defaultValue: [], comment: 'Ordered list for tool-calling requests.' },
+    { name: 'reasoningModels', type: 'json', defaultValue: [], comment: 'Ordered list for reasoning-tier requests.' },
+    { name: 'cheapModels', type: 'json', defaultValue: [], comment: 'Ordered list for cheap-tier requests.' },
+    { name: 'generalModels', type: 'json', defaultValue: [], comment: 'Ordered list for general requests.' },
+    { name: 'enabled', type: 'boolean', defaultValue: true, index: true },
+  ],
+});

package/src/server/middleware/response-record-resource.ts

@@ -0,0 +1,44 @@
+/**
+ * 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';
+
+export const RESPONSE_RECORD_COLLECTION = 'aiApiResponseRecords';
+
+type RepositoryAwareContext = Context & {
+  getCurrentRepository?: () => { targetCollection?: { name?: string } } | null;
+};
+
+function routeCandidates(ctx: Context): string[] {
+  const params = ctx.action?.params;
+  const candidates = [ctx.action?.resourceName, params?.resourceName, params?.associatedName, params?.targetCollection];
+  return candidates.filter((value): value is string => typeof value === 'string').flatMap((value) => value.split('.'));
+}
+
+export function targetsResponseRecordCollection(ctx: Context): boolean {
+  const repositoryContext = ctx as RepositoryAwareContext;
+  if (repositoryContext.getCurrentRepository) {
+    try {
+      if (repositoryContext.getCurrentRepository()?.targetCollection?.name === RESPONSE_RECORD_COLLECTION) return true;
+    } catch {
+      // Some custom resources have no repository. Fall back to the resolved route fields.
+    }
+  }
+  return routeCandidates(ctx).includes(RESPONSE_RECORD_COLLECTION);
+}
+
+export function blockResponseRecordResource() {
+  return async (ctx: Context, next: Next): Promise<void> => {
+    if (targetsResponseRecordCollection(ctx)) {
+      ctx.throw(404, 'Not Found');
+      return;
+    }
+    await next();
+  };
+}

package/src/server/middleware/role-permission.ts

@@ -11,44 +11,80 @@ import { Context } from '@nocobase/actions';
 import { toOpenAIError } from '../utils/openai-format';
 
 const PERMISSION_TTL_MS = 15_000;
-const permissionCache = new Map<string, { record: any; expiresAt: number }>();
+
+export interface RolePermissionRecord {
+  roleName?: string;
+  enabled?: boolean;
+  allowAllEmployees?: boolean;
+  allowedEmployees?: string[];
+}
+
+const permissionCache = new Map<string, { record: RolePermissionRecord | null; expiresAt: number }>();
 
 export function invalidateRolePermissionCache(roleName?: string): void {
-  if (roleName) permissionCache.delete(roleName);
-  else permissionCache.clear();
+  if (!roleName) {
+    permissionCache.clear();
+    return;
+  }
+  const suffix = `:role:${roleName}`;
+  for (const key of permissionCache.keys()) {
+    if (key.endsWith(suffix)) permissionCache.delete(key);
+  }
+}
+
+function unwrapRecord(raw: unknown): RolePermissionRecord | null {
+  if (!raw) return null;
+  if (typeof (raw as { get?: unknown }).get === 'function') {
+    const model = raw as { get: (key: string) => unknown };
+    return {
+      roleName: model.get('roleName') as string | undefined,
+      enabled: model.get('enabled') as boolean | undefined,
+      allowAllEmployees: model.get('allowAllEmployees') as boolean | undefined,
+      allowedEmployees: model.get('allowedEmployees') as string[] | undefined,
+    };
+  }
+  return raw as RolePermissionRecord;
+}
+
+async function loadRolePermission(ctx: Context, roleName: string): Promise<RolePermissionRecord | null> {
+  const cacheKey = `${ctx.app?.name ?? 'main'}:role:${roleName}`;
+  const cached = permissionCache.get(cacheKey);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.record;
+  }
+  const record = unwrapRecord(await ctx.db.getRepository('aiApiRolePermissions').findOne({ filter: { roleName } }));
+  permissionCache.set(cacheKey, { record, expiresAt: Date.now() + PERMISSION_TTL_MS });
+  return record;
 }
 
 /**
- * Check whether the authenticated role is allowed to use the AI API.
- * Loads the permission record and stores it in ctx.state.aiApiRolePermission.
+ * Check whether the authenticated roles are allowed to use the AI API.
+ *
+ * Every role — including root — must hold an enabled aiApiRolePermissions row;
+ * there is no special-case bypass, so a leaked API key stays scoped to whatever
+ * its role was granted in Settings → Users & Permissions → [Role] → AI API.
+ *
+ * Multi-role callers are evaluated with union semantics: the request is allowed
+ * when ANY assigned role is enabled, and the enabled records are stored in
+ * ctx.state.aiApiRolePermissions for downstream handlers (see checkEmployeeAccess).
  *
  * Returns true if access is allowed (caller may proceed).
  * Returns false if access is denied (403 already written to ctx, caller must return).
- *
- * The 'root' and 'admin' roles always bypass the check.
  */
 export async function checkRolePermission(ctx: Context): Promise<boolean> {
-  const roleName = ctx.state.currentRoles?.[0] || 'member';
-
-  // root / admin always allowed
-  if (roleName === 'root' || roleName === 'admin') {
-    return true;
-  }
+  const roleNames = ctx.state.currentRoles?.length
+    ? (ctx.state.currentRoles as string[])
+    : [ctx.state.currentRole || 'member'];
 
-  const cached = permissionCache.get(roleName);
-  const record =
-    cached && cached.expiresAt > Date.now()
-      ? cached.record
-      : await ctx.db.getRepository('aiApiRolePermissions').findOne({ filter: { roleName } });
-  if (!cached || cached.expiresAt <= Date.now()) {
-    permissionCache.set(roleName, { record, expiresAt: Date.now() + PERMISSION_TTL_MS });
-  }
+  const records = (await Promise.all(roleNames.map((name) => loadRolePermission(ctx, name)))).filter(
+    (record): record is RolePermissionRecord => !!record?.enabled,
+  );
 
-  if (!record?.enabled) {
+  if (!records.length) {
     ctx.status = 403;
     ctx.body = toOpenAIError(
       403,
-      `Role '${roleName}' is not authorized to use the AI API. ` +
+      `None of the roles [${roleNames.join(', ')}] is authorized to use the AI API. ` +
         `An admin must enable access in Settings → Users & Permissions → [Role] → AI API.`,
       'permission_denied',
       'role_not_permitted',
@@ -56,24 +92,22 @@ export async function checkRolePermission(ctx: Context): Promise<boolean> {
     return false;
   }
 
-  // Store for downstream handlers
-  ctx.state.aiApiRolePermission = record;
+  // Store for downstream handlers (employee scoping, usage attribution).
+  ctx.state.aiApiRolePermissions = records;
   return true;
 }
 
 /**
- * Check whether the current role is allowed to use a specific AI Employee.
- * Must be called after checkRolePermission (so ctx.state.aiApiRolePermission is set).
+ * Check whether the current roles may use a specific AI Employee.
+ * Must be called after checkRolePermission (so ctx.state.aiApiRolePermissions is set).
  *
  * Returns true when:
- * - Role is admin/root (no permission record stored)
- * - allowAllEmployees is true
- * - The employeeUsername is in the allowedEmployees list
+ * - Any enabled role has allowAllEmployees=true, or
+ * - The employeeUsername appears in the union of the enabled roles' allowedEmployees lists
  */
 export function checkEmployeeAccess(ctx: Context, employeeUsername: string): boolean {
-  const perm = ctx.state.aiApiRolePermission;
-  // admin/root paths have no record stored → always allowed
-  if (!perm) return true;
-  if (perm.allowAllEmployees) return true;
-  return ((perm.allowedEmployees as string[]) || []).includes(employeeUsername);
+  const perms = (ctx.state.aiApiRolePermissions as RolePermissionRecord[] | undefined) || [];
+  return perms.some(
+    (perm) => perm.allowAllEmployees || ((perm.allowedEmployees as string[]) || []).includes(employeeUsername),
+  );
 }

package/src/server/migrations/20260901000000-remove-default-group-members.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { Migration } from '@nocobase/server';
+
+/**
+ * The default usage group is a pure fallback: users with no aiApiGroupMembers row
+ * resolve to it automatically at runtime. Earlier migrations (legacy quota-policy
+ * backfill and group-delete reassignment) wrote explicit member rows pointing at
+ * the default group. Those rows are redundant, hide users from the "unassigned"
+ * filter, and can no longer be created through the guarded create path. Drop them
+ * so the default group holds no explicit members.
+ */
+export default class RemoveDefaultGroupMembers extends Migration {
+  // afterSync: aiApiGroupMembers / aiApiUsageGroups must be registered and synced.
+  on = 'afterSync' as const;
+
+  async up() {
+    const groupCollection = this.db.getCollection('aiApiUsageGroups');
+    const memberCollection = this.db.getCollection('aiApiGroupMembers');
+    if (!groupCollection || !memberCollection) return;
+    if (!(await groupCollection.existsInDb()) || !(await memberCollection.existsInDb())) return;
+
+    const defaultGroup = await this.db.getRepository('aiApiUsageGroups').findOne({
+      filter: { isDefault: true },
+    });
+    if (!defaultGroup) return;
+
+    const groupId = defaultGroup.get('id');
+    // Destroy one by one so per-row destroy events fire; member counts here are small.
+    const members = await this.db.getRepository('aiApiGroupMembers').find({
+      filter: { groupId },
+    });
+    for (const member of members) {
+      await this.db.getRepository('aiApiGroupMembers').destroy({ filterByTk: member.get('id') });
+    }
+
+    if (members.length) {
+      this.app.logger.info(
+        `[ai-api] Removed ${members.length} explicit member row(s) from the default usage group; those users now fall back to it implicitly.`,
+      );
+    }
+  }
+
+  async down() {
+    // Irreversible: the dropped rows carried no extra data, and re-adding them would
+    // re-introduce the inconsistency this migration removes. Users still resolve to
+    // the default group implicitly, so behaviour is unchanged.
+  }
+}

package/src/server/migrations/20260902000000-seed-default-role-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 { Migration } from '@nocobase/server';
+
+/**
+ * The AI API gateway no longer bypasses permission checks for any role, root and admin
+ * included: every role needs an enabled aiApiRolePermissions row. Existing deployments
+ * rely on root's and admin's implicit access, so seed both rows here — otherwise every
+ * root/admin API key would start failing with 403 right after the upgrade.
+ * Rows an admin already created are left untouched.
+ */
+export default class SeedDefaultRolePermissions extends Migration {
+  // afterSync: aiApiRolePermissions must be registered and synced before we write to it.
+  on = 'afterSync' as const;
+
+  async up() {
+    const collection = this.db.getCollection('aiApiRolePermissions');
+    if (!collection || !(await collection.existsInDb())) return;
+
+    const repository = this.db.getRepository('aiApiRolePermissions');
+    const rolesToSeed = [
+      { roleName: 'root', enabled: true, allowAllEmployees: true, allowedEmployees: [] },
+      { roleName: 'admin', enabled: true, allowAllEmployees: true, allowedEmployees: [] },
+    ];
+    for (const values of rolesToSeed) {
+      const existing = await repository.findOne({ filter: { roleName: values.roleName } });
+      if (existing) continue;
+      await repository.create({ values });
+      this.app.logger.info(
+        `[ai-api] Seeded aiApiRolePermissions for role ${values.roleName} (the built-in bypass was removed).`,
+      );
+    }
+  }
+
+  async down() {
+    // Keep the rows on rollback: deleting them would lock root/admin out of the gateway,
+    // and the rows are harmless for older code paths that bypass the check anyway.
+  }
+}

package/src/server/migrations/20260903000000-seed-sample-response-records.ts

@@ -0,0 +1,162 @@
+/**
+ * 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 { Migration } from '@nocobase/server';
+
+const SAMPLE_IDS = ['resp_sample_welcome', 'resp_sample_followup'];
+
+export default class SeedSampleResponseRecord extends Migration {
+  on = 'afterSync' as const;
+
+  async up() {
+    const collection = this.db.getCollection('aiApiResponseRecords');
+    if (!collection || !(await collection.existsInDb())) return;
+
+    // Never seed demo content in production unless the operator opts in explicitly.
+    if (process.env.NODE_ENV === 'production' && process.env.AI_API_SEED_SAMPLE_RESPONSES !== 'true') {
+      this.app.logger.info(
+        '[ai-api] Skipped sample response records in production (set AI_API_SEED_SAMPLE_RESPONSES=true to enable).',
+      );
+      return;
+    }
+
+    const rootUser = await this.db.getRepository('users').findOne({ filter: { 'roles.name': 'root' } });
+    if (!rootUser) {
+      this.app.logger.warn('[ai-api] Skipped sample response records because no root user exists.');
+      return;
+    }
+    const repository = this.db.getRepository('aiApiResponseRecords');
+
+    const now = Math.floor(Date.now() / 1000);
+    const expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+    const firstOutput = {
+      id: SAMPLE_IDS[0],
+      object: 'response',
+      created_at: now,
+      completed_at: now,
+      status: 'completed',
+      error: null,
+      incomplete_details: null,
+      instructions: null,
+      max_output_tokens: null,
+      model: 'sample/gpt-4',
+      output: [
+        {
+          id: 'msg_sample_welcome',
+          type: 'message',
+          status: 'completed',
+          role: 'assistant',
+          content: [
+            {
+              type: 'output_text',
+              text: 'Hello! Welcome to the NocoBase AI API. How can I help you today?',
+              annotations: [],
+            },
+          ],
+        },
+      ],
+      output_text: 'Hello! Welcome to the NocoBase AI API. How can I help you today?',
+      parallel_tool_calls: true,
+      previous_response_id: null,
+      reasoning: null,
+      service_tier: 'default',
+      temperature: null,
+      text: null,
+      tool_choice: 'auto',
+      tools: [],
+      top_p: null,
+      truncation: 'disabled',
+      usage: {
+        input_tokens: 15,
+        input_tokens_details: { cached_tokens: 0 },
+        output_tokens: 20,
+        output_tokens_details: { reasoning_tokens: 0 },
+        total_tokens: 35,
+      },
+      metadata: { sample: 'true', purpose: 'documentation' },
+    };
+
+    const firstValues = {
+      responseId: SAMPLE_IDS[0],
+      userId: rootUser.get('id'),
+      model: firstOutput.model,
+      input: 'Hello! I am testing the Responses API.',
+      output: firstOutput,
+      previousResponseId: null,
+      metadata: firstOutput.metadata,
+      expiresAt,
+    };
+
+    const secondOutput = {
+      ...firstOutput,
+      id: SAMPLE_IDS[1],
+      created_at: now + 60,
+      completed_at: now + 60,
+      output: [
+        {
+          id: 'msg_sample_followup',
+          type: 'message',
+          status: 'completed',
+          role: 'assistant',
+          content: [
+            {
+              type: 'output_text',
+              text: 'I can help with questions, code, data analysis, and more.',
+              annotations: [],
+            },
+          ],
+        },
+      ],
+      output_text: 'I can help with questions, code, data analysis, and more.',
+      previous_response_id: SAMPLE_IDS[0],
+      usage: {
+        input_tokens: 25,
+        input_tokens_details: { cached_tokens: 0 },
+        output_tokens: 15,
+        output_tokens_details: { reasoning_tokens: 0 },
+        total_tokens: 40,
+      },
+    };
+    const secondValues = {
+      responseId: SAMPLE_IDS[1],
+      userId: rootUser.get('id'),
+      model: secondOutput.model,
+      input: 'What can you help me with?',
+      output: secondOutput,
+      previousResponseId: SAMPLE_IDS[0],
+      metadata: secondOutput.metadata,
+      expiresAt,
+    };
+
+    // Create each missing sample independently inside one transaction, so a rerun after a
+    // partial failure still seeds the remaining record without duplicating the existing one.
+    const candidates = [firstValues, secondValues];
+    await this.db.sequelize.transaction(async (transaction) => {
+      for (const values of candidates) {
+        const exists = await repository.findOne({ filter: { responseId: values.responseId }, transaction });
+        if (!exists) {
+          await repository.create({ values, transaction });
+        }
+      }
+    });
+    this.app.logger.info('[ai-api] Seeded sample Responses API records for the root user.');
+  }
+
+  async down() {
+    const repository = this.db.getRepository('aiApiResponseRecords');
+    const records = await repository.find({ filter: { responseId: { $in: SAMPLE_IDS } } });
+    for (const record of records) {
+      const metadata = record.get('metadata');
+      // Only remove records we actually seeded — a user-owned record may reuse a sample id.
+      if (metadata && typeof metadata === 'object' && (metadata as Record<string, unknown>).sample === 'true') {
+        await repository.destroy({ filterByTk: record.get('id') });
+      }
+    }
+  }
+}