plugin-ai-api 1.0.24 → 1.0.28

package/src/server/quota-groups.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 type { Model } from '@nocobase/database';
+
+export type QuotaMode = 'share' | 'per_user';
+
+export interface AiApiUsageGroup {
+  id: string | number | bigint;
+  name: string;
+  isDefault: boolean;
+  quotaMode: QuotaMode;
+  rateLimitPerMinute: number;
+  enabled: boolean;
+  periodType: string;
+  timezone: string;
+  requestLimit: string | number | bigint | null;
+  totalTokenLimit: string | number | bigint | null;
+  costLimit: string | null;
+  currency: string;
+  rejectUnpricedModel: boolean;
+  missingUsageBehavior: 'allow' | 'use_reserved';
+  contextOverflowBehavior: 'reject' | 'truncate';
+  allowedLlmServices: string[];
+  allowAllModels: boolean;
+  allowedModels: string[];
+}
+
+export async function getDefaultGroup(ctx: Context): Promise<AiApiUsageGroup> {
+  const existing = await ctx.db.getRepository('aiApiUsageGroups').findOne({
+    filter: { isDefault: true },
+  });
+
+  if (existing) {
+    return modelToGroup(existing);
+  }
+
+  const created = await ctx.db.getRepository('aiApiUsageGroups').create({
+    values: {
+      name: 'Default',
+      isDefault: true,
+      quotaMode: 'per_user',
+      rateLimitPerMinute: 60,
+      enabled: false,
+      periodType: 'monthly',
+      timezone: 'UTC',
+      requestLimit: null,
+      totalTokenLimit: null,
+      costLimit: null,
+      currency: 'USD',
+      rejectUnpricedModel: true,
+      missingUsageBehavior: 'use_reserved',
+      contextOverflowBehavior: 'reject',
+      allowedLlmServices: [],
+      allowAllModels: true,
+      allowedModels: [],
+    },
+  });
+
+  return modelToGroup(created);
+}
+
+export async function resolveUserGroup(
+  ctx: Context,
+  userId: string | number | bigint | undefined | null,
+): Promise<AiApiUsageGroup> {
+  if (userId === undefined || userId === null) {
+    return getDefaultGroup(ctx);
+  }
+
+  const member = await ctx.db.getRepository('aiApiGroupMembers').findOne({
+    filter: { userId },
+    appends: ['group'],
+  });
+
+  if (member && member.get('group')) {
+    return modelToGroup(member.get('group'));
+  }
+
+  return getDefaultGroup(ctx);
+}
+
+export function modelToGroup(model: Model | Record<string, unknown>): AiApiUsageGroup {
+  const record =
+    typeof (model as Model).get === 'function' ? (model as Model).get() : (model as Record<string, unknown>);
+  return {
+    id: record.id as string | number | bigint,
+    name: (record.name as string) ?? '',
+    isDefault: !!record.isDefault,
+    quotaMode: (record.quotaMode as QuotaMode) ?? 'per_user',
+    rateLimitPerMinute: Number(record.rateLimitPerMinute ?? 60),
+    enabled: !!record.enabled,
+    periodType: (record.periodType as string) ?? 'monthly',
+    timezone: (record.timezone as string) ?? 'UTC',
+    requestLimit: (record.requestLimit as string | number | bigint | null) ?? null,
+    totalTokenLimit: (record.totalTokenLimit as string | number | bigint | null) ?? null,
+    costLimit: (record.costLimit as string | null) ?? null,
+    currency: (record.currency as string) ?? 'USD',
+    rejectUnpricedModel: !!record.rejectUnpricedModel,
+    missingUsageBehavior: (record.missingUsageBehavior as 'allow' | 'use_reserved') ?? 'use_reserved',
+    contextOverflowBehavior: (record.contextOverflowBehavior as 'reject' | 'truncate') ?? 'reject',
+    allowedLlmServices: stringArray(record.allowedLlmServices),
+    allowAllModels: record.allowAllModels !== false,
+    allowedModels: stringArray(record.allowedModels),
+  };
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
+}

package/src/server/resource/ai-api-config.ts

@@ -46,8 +46,8 @@ const aiApiConfigResource: ResourceOptions = {
             defaultAiEmployee: '',
             defaultLlmService: '',
             enabledLlmServices: [],
-            rateLimitPerMinute: 60,
             maxRequestBodyMb: 10,
+            pdfRenderPagesAsImages: false,
             quotaEnabled: false,
             defaultReservationOutputTokens: 4096,
             options: {},
@@ -70,8 +70,8 @@ const aiApiConfigResource: ResourceOptions = {
             defaultAiEmployee: values.defaultAiEmployee ?? '',
             defaultLlmService: values.defaultLlmService ?? '',
             enabledLlmServices: values.enabledLlmServices ?? [],
-            rateLimitPerMinute: values.rateLimitPerMinute ?? 60,
             maxRequestBodyMb: coerceMaxRequestBodyMb(values.maxRequestBodyMb ?? DEFAULT_MAX_REQUEST_BODY_MB),
+            pdfRenderPagesAsImages: values.pdfRenderPagesAsImages ?? false,
             quotaEnabled: values.quotaEnabled ?? false,
             defaultReservationOutputTokens: values.defaultReservationOutputTokens ?? 4096,
             options: values.options ?? {},
@@ -83,10 +83,12 @@ const aiApiConfigResource: ResourceOptions = {
         if (values.defaultAiEmployee !== undefined) updateData.defaultAiEmployee = values.defaultAiEmployee;
         if (values.defaultLlmService !== undefined) updateData.defaultLlmService = values.defaultLlmService;
         if (values.enabledLlmServices !== undefined) updateData.enabledLlmServices = values.enabledLlmServices;
-        if (values.rateLimitPerMinute !== undefined) updateData.rateLimitPerMinute = values.rateLimitPerMinute;
         if (values.maxRequestBodyMb !== undefined) {
           updateData.maxRequestBodyMb = coerceMaxRequestBodyMb(values.maxRequestBodyMb);
         }
+        if (values.pdfRenderPagesAsImages !== undefined) {
+          updateData.pdfRenderPagesAsImages = Boolean(values.pdfRenderPagesAsImages);
+        }
         if (values.quotaEnabled !== undefined) updateData.quotaEnabled = values.quotaEnabled;
         if (values.defaultReservationOutputTokens !== undefined) {
           updateData.defaultReservationOutputTokens = values.defaultReservationOutputTokens;

package/src/server/resource/ai-api-usage-groups.ts

@@ -0,0 +1,171 @@
+/**
+ * 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';
+
+const USER_SUMMARY_FIELDS = ['id', 'username', 'nickname', 'email'];
+
+async function getByUser(ctx: Context, next: () => Promise<void>) {
+  const { userId } = ctx.action.params;
+  if (!userId) {
+    ctx.throw(400, 'userId is required');
+  }
+  const member = await ctx.db.getRepository('aiApiGroupMembers').findOne({
+    filter: { userId },
+    appends: ['group'],
+  });
+
+  if (member && member.get('group')) {
+    ctx.body = member.get('group');
+    return next();
+  }
+
+  const defaultGroup = await ctx.db.getRepository('aiApiUsageGroups').findOne({
+    filter: { isDefault: true },
+  });
+
+  if (!defaultGroup) {
+    ctx.throw(404, 'Default group not found');
+  }
+
+  ctx.body = defaultGroup;
+  return next();
+}
+
+async function listUnassignedUsers(ctx: Context, next: () => Promise<void>) {
+  const { page = 1, pageSize = 20, keyword } = ctx.action.params;
+
+  const memberRows = (await ctx.db.getRepository('aiApiGroupMembers').find({
+    fields: ['userId'],
+    pageSize: 10000,
+  })) as unknown[];
+  const assignedUserIds = memberRows.map((row) => {
+    const value = (row as Record<string, unknown>).get?.('userId') ?? (row as Record<string, unknown>).userId;
+    return String(value);
+  });
+
+  const where: Record<string, unknown> = {};
+  if (keyword) {
+    where.$or = [
+      { username: { $includes: keyword } },
+      { email: { $includes: keyword } },
+      { nickname: { $includes: keyword } },
+    ];
+  }
+  if (assignedUserIds.length > 0) {
+    where.id = { $notIn: assignedUserIds };
+  }
+
+  const repository = ctx.db.getRepository('users');
+  const [rows, count] = await repository.findAndCount({
+    filter: where,
+    fields: USER_SUMMARY_FIELDS,
+    page: Number(page),
+    pageSize: Number(pageSize),
+  });
+
+  ctx.body = { rows, count };
+  return next();
+}
+
+async function searchUsers(ctx: Context, next: () => Promise<void>) {
+  const { keyword, pageSize = 20 } = ctx.action.params;
+
+  const where: Record<string, unknown> = {};
+  if (keyword) {
+    where.$or = [
+      { username: { $includes: keyword } },
+      { email: { $includes: keyword } },
+      { nickname: { $includes: keyword } },
+    ];
+  }
+
+  const [rows, count] = await ctx.db.getRepository('users').findAndCount({
+    filter: where,
+    fields: USER_SUMMARY_FIELDS,
+    page: 1,
+    pageSize: Number(pageSize),
+  });
+
+  ctx.body = { rows, count };
+  return next();
+}
+
+async function addMember(ctx: Context, next: () => Promise<void>) {
+  const { groupId, userId } = ctx.action.params.values || ctx.action.params || {};
+  if (!groupId || !userId) {
+    ctx.throw(400, 'groupId and userId are required');
+  }
+
+  const group = await ctx.db.getRepository('aiApiUsageGroups').findOne({
+    filterByTk: groupId,
+  });
+  if (!group) {
+    ctx.throw(404, 'Usage group not found');
+  }
+  // The default group is a fallback, not a membership target: an explicit row would
+  // pin the user there and hide them from listUnassignedUsers forever.
+  if (group.get('isDefault')) {
+    ctx.throw(400, 'Cannot add members to the default group: users without another group use it automatically');
+  }
+
+  const existing = await ctx.db.getRepository('aiApiGroupMembers').findOne({
+    filter: { userId },
+  });
+  if (existing) {
+    ctx.throw(409, 'User already belongs to a group');
+  }
+
+  const member = await ctx.db.getRepository('aiApiGroupMembers').create({
+    values: { groupId, userId },
+  });
+  ctx.body = member;
+  return next();
+}
+
+async function removeMember(ctx: Context, next: () => Promise<void>) {
+  const { groupId, userId } = ctx.action.params.values || ctx.action.params || {};
+  if (!groupId || !userId) {
+    ctx.throw(400, 'groupId and userId are required');
+  }
+
+  const member = await ctx.db.getRepository('aiApiGroupMembers').findOne({
+    filter: { groupId, userId },
+  });
+  if (!member) {
+    ctx.throw(404, 'Member not found');
+  }
+
+  await ctx.db.getRepository('aiApiGroupMembers').destroy({
+    filterByTk: member.get('id'),
+  });
+  ctx.body = member;
+  return next();
+}
+
+export default {
+  name: 'aiApiUsageGroups',
+  actions: {
+    getByUser: {
+      handler: getByUser,
+    },
+    listUnassignedUsers: {
+      handler: listUnassignedUsers,
+    },
+    searchUsers: {
+      handler: searchUsers,
+    },
+    addMember: {
+      handler: addMember,
+    },
+    removeMember: {
+      handler: removeMember,
+    },
+  },
+};

package/src/server/resource/ai-api-usage-monitor.ts

@@ -7,6 +7,7 @@ interface UsageSummaryRow {
   inputTokens?: string | number;
   outputTokens?: string | number;
   totalTokens?: string | number;
+  promptCacheTokens?: string | number;
 }
 
 interface CostSummaryRow {
@@ -45,6 +46,7 @@ const aiApiUsageMonitorResource: ResourceOptions = {
           [fn('COALESCE', fn('SUM', col('inputTokens')), 0), 'inputTokens'],
           [fn('COALESCE', fn('SUM', col('outputTokens')), 0), 'outputTokens'],
           [fn('COALESCE', fn('SUM', col('totalTokens')), 0), 'totalTokens'],
+          [fn('COALESCE', fn('SUM', col('promptCacheTokens')), 0), 'promptCacheTokens'],
         ],
         where,
         raw: true,
@@ -61,6 +63,7 @@ const aiApiUsageMonitorResource: ResourceOptions = {
         inputTokens: Number(totals?.inputTokens ?? 0),
         outputTokens: Number(totals?.outputTokens ?? 0),
         totalTokens: Number(totals?.totalTokens ?? 0),
+        promptCacheTokens: Number(totals?.promptCacheTokens ?? 0),
         costsByCurrency: costs.map((item) => ({
           currency: item.currency || 'USD',
           totalCost: String(item.totalCost ?? 0),

package/src/server/routes/agent-completions.ts

@@ -19,6 +19,7 @@ import {
 import { resolveModelString } from '../utils/resolve-service';
 import { checkEmployeeAccess } from '../middleware/role-permission';
 import { enforceModelAccess } from '../utils/user-permissions';
+import { getAiApiConfig } from '../utils/request-cache';
 import { isStreamingRequested } from '../utils/streaming';
 import {
   AgentRuntimeContext,
@@ -89,7 +90,7 @@ export async function handleAgentCompletions(ctx: Context, plugin: PluginAiApiSe
   }
 
   // ─── Load config and validate AI Employee ─────────────────────────────────
-  const config = await ctx.db.getRepository('aiApiConfig').findOne();
+  const config = await getAiApiConfig(ctx);
   const defaultAiEmployee = config ? config.get('defaultAiEmployee') || config.defaultAiEmployee : null;
   if (!defaultAiEmployee) {
     ctx.status = 400;