plugin-ai-api 1.1.0 → 1.1.2

package/src/client-v2/pages/ModelRoutingPage.tsx

@@ -0,0 +1,238 @@
+import React, { useCallback, useEffect, useState } from 'react';
+import { Button, Card, Form, Input, Select, Space, Switch, Typography, message } from 'antd';
+import { useFlowContext } from '@nocobase/flow-engine';
+import { useT } from '../locale';
+import { errorMessage, unwrapData } from './api';
+
+const { Text } = Typography;
+
+interface VirtualModel {
+  id?: string | number;
+  name: string;
+  mode: string;
+  fallbackModel: string;
+  visionModels: string[];
+  toolModels: string[];
+  reasoningModels: string[];
+  cheapModels: string[];
+  generalModels: string[];
+  enabled: boolean;
+}
+
+interface EnabledLlmService {
+  llmService: string;
+  llmServiceTitle?: string;
+  enabledModels?: Array<{ label?: string; value: string }>;
+}
+
+interface ModelOption {
+  value: string; // "serviceName/modelId"
+  label: string;
+}
+
+const DEFAULT_ALIAS = 'auto';
+
+export default function ModelRoutingPage() {
+  const ctx = useFlowContext();
+  const t = useT();
+  const [form] = Form.useForm<Partial<VirtualModel>>();
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [options, setOptions] = useState<ModelOption[]>([]);
+  const [recordId, setRecordId] = useState<string | number | undefined>();
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const [vmRes, servicesRes] = await Promise.all([
+        ctx.api.request({
+          url: 'aiApiVirtualModels:list',
+          method: 'get',
+          params: { filter: { name: DEFAULT_ALIAS }, pageSize: 1 },
+        }),
+        // Use the normalized catalog so recommended/provider/custom modes all surface their
+        // actual runtime models. The raw llmServices endpoint can return an empty enabledModels
+        // array for recommended-mode services, which would leave this page with no choices.
+        ctx.api.request({ url: 'ai:listAllEnabledModels', method: 'get' }),
+      ]);
+
+      // Build the shared option list: every enabled model of every service, as "service/model".
+      const svcList = unwrapData<EnabledLlmService[]>(servicesRes, []);
+      const opts: ModelOption[] = [];
+      for (const service of svcList) {
+        const label = service.llmServiceTitle || service.llmService;
+        for (const model of service.enabledModels || []) {
+          if (!model?.value) continue;
+          opts.push({
+            value: `${service.llmService}/${model.value}`,
+            label: `${label} / ${model.label || model.value}`,
+          });
+        }
+      }
+
+      const existing = unwrapData<VirtualModel[]>(vmRes, [])[0];
+      // Keep stale references visible: values already configured on this alias but no longer
+      // present in the enabled catalog are merged back into the options so admins can still
+      // see, reorder, and replace them instead of being left with an opaque raw value.
+      if (existing) {
+        const known = new Set(opts.map((option) => option.value));
+        const configured = [
+          existing.fallbackModel,
+          ...(existing.visionModels || []),
+          ...(existing.toolModels || []),
+          ...(existing.reasoningModels || []),
+          ...(existing.cheapModels || []),
+          ...(existing.generalModels || []),
+        ].filter((value): value is string => typeof value === 'string' && value.length > 0);
+        for (const value of configured) {
+          if (known.has(value)) continue;
+          known.add(value);
+          opts.push({ value, label: `${value} (${t('unavailable')})` });
+        }
+      }
+      setOptions(opts);
+      if (existing) {
+        setRecordId(existing.id);
+        form.setFieldsValue({
+          name: existing.name,
+          mode: existing.mode || 'chat',
+          fallbackModel: existing.fallbackModel,
+          visionModels: existing.visionModels || [],
+          toolModels: existing.toolModels || [],
+          reasoningModels: existing.reasoningModels || [],
+          cheapModels: existing.cheapModels || [],
+          generalModels: existing.generalModels || [],
+          enabled: existing.enabled !== false,
+        });
+      } else {
+        form.setFieldsValue({
+          name: DEFAULT_ALIAS,
+          mode: 'chat',
+          fallbackModel: undefined,
+          enabled: true,
+          visionModels: [],
+          toolModels: [],
+          reasoningModels: [],
+          cheapModels: [],
+          generalModels: [],
+        });
+      }
+    } catch (error) {
+      message.error(errorMessage(error));
+    } finally {
+      setLoading(false);
+    }
+  }, [ctx.api, form, t]);
+
+  useEffect(() => {
+    load();
+  }, [load]);
+
+  const save = async () => {
+    const values = await form.validateFields();
+    setSaving(true);
+    try {
+      if (recordId) {
+        await ctx.api.request({ url: `aiApiVirtualModels:update/${recordId}`, method: 'post', data: values });
+      } else {
+        const res = await ctx.api.request({ url: 'aiApiVirtualModels:create', method: 'post', data: values });
+        const created = unwrapData<VirtualModel | undefined>(res, undefined);
+        if (created?.id) setRecordId(created.id);
+      }
+      message.success(t('Saved successfully'));
+    } catch (error) {
+      message.error(errorMessage(error));
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  // Keep stored order visible: render selected tags in the order of the field value,
+  // and let the dropdown offer the remaining options.
+  const orderedSelectProps = {
+    options,
+    optionFilterProp: 'label' as const,
+    showSearch: true,
+    loading,
+  };
+
+  const listField = (name: keyof VirtualModel, label: string, tooltip: string) => (
+    <Form.Item name={name} label={label} tooltip={tooltip}>
+      <Select
+        mode="multiple"
+        placeholder={t('Select models — the order shown is the routing priority')}
+        {...orderedSelectProps}
+      />
+    </Form.Item>
+  );
+
+  return (
+    <Card loading={loading} title={t('Model routing (virtual models)')}>
+      <Form form={form} layout="vertical">
+        <Form.Item name="name" label={t('Alias')} rules={[{ required: true }]}>
+          <Input disabled style={{ maxWidth: 240 }} />
+        </Form.Item>
+        <Form.Item name="mode" hidden>
+          <Input />
+        </Form.Item>
+        <Form.Item
+          name="fallbackModel"
+          label={t('Fallback model')}
+          rules={[{ required: true, message: t('A fallback model is required') }]}
+          tooltip={t(
+            'Used when no capability bucket candidate is usable and the fallback is permitted for the caller.',
+          )}
+        >
+          <Select
+            placeholder={t('Select a fallback model')}
+            options={options}
+            optionFilterProp="label"
+            showSearch
+            style={{ maxWidth: 480 }}
+          />
+        </Form.Item>
+
+        {listField(
+          'visionModels',
+          t('Vision models (in order)'),
+          t('Requests with an image or file block use the first permitted model here.'),
+        )}
+        {listField(
+          'toolModels',
+          t('Tool-calling models (in order)'),
+          t('Requests with tools/tool_choice use the first permitted model here.'),
+        )}
+        {listField(
+          'reasoningModels',
+          t('Reasoning models (in order)'),
+          t('Requests with an explicit reasoning or reasoning_effort parameter use the first permitted model here.'),
+        )}
+        {listField(
+          'cheapModels',
+          t('Cheap models (in order)'),
+          t('Optional. When set, cheap-eligible requests use the first permitted model here.'),
+        )}
+        {listField(
+          'generalModels',
+          t('General models (in order)'),
+          t(
+            'Default bucket when no capability rule matched. Leave empty to derive from all enabled models ordered by Model metadata sortOrder.',
+          ),
+        )}
+
+        <Form.Item name="enabled" label={t('Enabled')} valuePropName="checked">
+          <Switch />
+        </Form.Item>
+
+        <Space>
+          <Button type="primary" onClick={save} loading={saving}>
+            {t('Save')}
+          </Button>
+          <Text type="secondary">
+            {t('An empty bucket is derived automatically from Model metadata (capability flags + sortOrder).')}
+          </Text>
+        </Space>
+      </Form>
+    </Card>
+  );
+}

package/src/client-v2/pages/UsageGroupsPage.tsx

@@ -66,7 +66,7 @@ interface GroupMember {
 export default function UsageGroupsPage() {
   const ctx = useFlowContext();
   const t = useT();
-  const [form] = Form.useForm<UsageGroup>();
+  const [form] = Form.useForm<Partial<UsageGroup>>();
   const [memberForm] = Form.useForm<{ userId: string | number }>();
   const selectedServices = Form.useWatch('allowedLlmServices', form);
   const allowAllModels = Form.useWatch('allowAllModels', form);
@@ -127,13 +127,39 @@ export default function UsageGroupsPage() {
   const loadUnassignedUsers = useCallback(
     async (keyword?: string) => {
       try {
+        // Plain collection reads on the main data source, so core ACL enforces
+        // aiApiGroupMembers:list and users:list. No custom server action needed.
+        const memberResponse = await ctx.api.request({
+          url: 'aiApiGroupMembers:list',
+          method: 'get',
+          params: { fields: ['userId'], paginate: false, pageSize: 10000 },
+        });
+        const assignedIds = new Set(
+          unwrapData<Array<{ userId: string | number }>>(memberResponse, []).map((row) => String(row.userId)),
+        );
+        const conditions: Record<string, unknown>[] = [];
+        if (keyword) {
+          conditions.push({
+            $or: [
+              { username: { $includes: keyword } },
+              { email: { $includes: keyword } },
+              { nickname: { $includes: keyword } },
+            ],
+          });
+        }
+        if (assignedIds.size > 0) {
+          conditions.push({ id: { $notIn: [...assignedIds] } });
+        }
         const response = await ctx.api.request({
-          url: 'aiApiUsageGroups:listUnassignedUsers',
+          url: 'users:list',
           method: 'get',
-          params: { keyword, pageSize: 100 },
+          params: {
+            filter: conditions.length ? { $and: conditions } : {},
+            fields: ['id', 'username', 'nickname', 'email'],
+            pageSize: 100,
+          },
         });
-        const rows = unwrapData<UserSummary[]>(response, []);
-        setUnassignedUsers(rows);
+        setUnassignedUsers(unwrapData<UserSummary[]>(response, []));
       } catch (error) {
         message.error(errorMessage(error));
       }
@@ -162,7 +188,7 @@ export default function UsageGroupsPage() {
       allowedLlmServices: [],
       allowAllModels: true,
       allowedModels: [],
-    } as UsageGroup);
+    });
     setOpen(true);
   };
 
@@ -170,8 +196,10 @@ export default function UsageGroupsPage() {
     setEditing(record);
     form.setFieldsValue(record);
     setOpen(true);
-    await loadMembers(record.id);
+    // The default group has no explicit members by design; only load the member
+    // list and unassigned users for regular groups.
     if (!record.isDefault) {
+      await loadMembers(record.id);
       await loadUnassignedUsers();
     }
   };
@@ -212,8 +240,10 @@ export default function UsageGroupsPage() {
     if (!editing) return;
     const values = await memberForm.validateFields();
     try {
+      // Plain create on aiApiGroupMembers; the server beforeSave hook enforces the
+      // one-group-per-user and no-default-group-membership rules.
       await ctx.api.request({
-        url: 'aiApiUsageGroups:addMember',
+        url: 'aiApiGroupMembers:create',
         method: 'post',
         data: { groupId: editing.id, userId: values.userId },
       });
@@ -229,9 +259,8 @@ export default function UsageGroupsPage() {
   const removeMember = async (member: GroupMember) => {
     try {
       await ctx.api.request({
-        url: 'aiApiUsageGroups:removeMember',
+        url: `aiApiGroupMembers:destroy/${member.id}`,
         method: 'post',
-        data: { groupId: member.groupId, userId: member.userId },
       });
       message.success(t('Member removed'));
       if (editing) {
@@ -246,23 +275,44 @@ export default function UsageGroupsPage() {
   const searchGroupByUser = async () => {
     if (!searchUserKeyword.trim()) return;
     try {
-      const response = await ctx.api.request({
-        url: 'aiApiUsageGroups:searchUsers',
+      const userResponse = await ctx.api.request({
+        url: 'users:list',
         method: 'get',
-        params: { keyword: searchUserKeyword, pageSize: 1 },
+        params: {
+          filter: {
+            $or: [
+              { username: { $includes: searchUserKeyword } },
+              { email: { $includes: searchUserKeyword } },
+              { nickname: { $includes: searchUserKeyword } },
+            ],
+          },
+          fields: ['id', 'username', 'nickname', 'email'],
+          pageSize: 1,
+        },
       });
-      const users = unwrapData<UserSummary[]>(response, []);
+      const users = unwrapData<UserSummary[]>(userResponse, []);
       if (users.length === 0) {
         message.warning(t('User not found'));
         setSearchedGroup(null);
         return;
       }
-      const groupResponse = await ctx.api.request({
-        url: 'aiApiUsageGroups:getByUser',
+      // Look up the membership row; a user with no row falls back to the default group.
+      const memberResponse = await ctx.api.request({
+        url: 'aiApiGroupMembers:list',
         method: 'get',
-        params: { userId: users[0].id },
+        params: { filter: { userId: users[0].id }, appends: ['group'], pageSize: 1 },
       });
-      setSearchedGroup(unwrapData<UsageGroup>(groupResponse, null));
+      const memberRows = unwrapData<Array<{ group?: UsageGroup }>>(memberResponse, []);
+      if (memberRows[0]?.group) {
+        setSearchedGroup(memberRows[0].group);
+        return;
+      }
+      const defaultResponse = await ctx.api.request({
+        url: 'aiApiUsageGroups:list',
+        method: 'get',
+        params: { filter: { isDefault: true }, pageSize: 1 },
+      });
+      setSearchedGroup(unwrapData<UsageGroup[]>(defaultResponse, [])[0] ?? null);
     } catch (error) {
       message.error(errorMessage(error));
     }
@@ -491,28 +541,15 @@ export default function UsageGroupsPage() {
           </Form.Item>
         </Form>
         {editing && (
-          <Card title={t('Members')} size="small" style={{ marginTop: 24 }}>
+          <Card title={editing.isDefault ? t('Membership') : t('Members')} size="small" style={{ marginTop: 24 }}>
             {editing.isDefault ? (
-              <>
-                <Alert
-                  type="info"
-                  showIcon
-                  message={t(
-                    'Users who do not belong to any other group automatically use this default group — no need to add members.',
-                  )}
-                  style={{ marginBottom: members.length > 0 ? 12 : 0 }}
-                />
-                {members.length > 0 && (
-                  <Table
-                    rowKey="id"
-                    columns={memberColumns}
-                    dataSource={members}
-                    loading={membersLoading}
-                    pagination={false}
-                    size="small"
-                  />
+              <Alert
+                type="info"
+                showIcon
+                message={t(
+                  'Users who do not belong to any other group automatically use this default group — no need to add members.',
                 )}
-              </>
+              />
             ) : (
               <>
                 <Form form={memberForm} layout="inline">

package/src/client-v2/plugin.tsx

@@ -51,6 +51,14 @@ export class PluginAiApiClient extends Plugin<Record<string, never>, Application
       componentLoader: () => import('./pages/ModelMetadataPage'),
     });
 
+    this.pluginSettingsManager.addPageTabItem({
+      menuKey: 'ai-api',
+      key: 'model-routing',
+      title: this.t('Model routing'),
+      aclSnippet: AI_API_ACL_SNIPPET,
+      sort: 4,
+      componentLoader: () => import('./pages/ModelRoutingPage'),
+    });
     this.pluginSettingsManager.addPageTabItem({
       menuKey: 'ai-api',
       key: 'usage-groups',

package/src/index.ts

@@ -1,11 +1,11 @@
-/**
- * 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.
- */
-
-export * from './server';
-export { default } from './server';
+/**
+ * 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.
+ */
+
+export * from './server';
+export { default } from './server';

package/src/locale/en-US.json

@@ -20,6 +20,7 @@
   "LLM service": "LLM service",
   "Model": "Model",
   "Input price / 1M": "Input price / 1M",
+  "Cache input price / 1M": "Cache input price / 1M",
   "Output price / 1M": "Output price / 1M",
   "Fixed request cost": "Fixed request cost",
   "Currency": "Currency",
@@ -134,5 +135,41 @@
   "All services": "All services",
   "No models": "No models",
   "Leave empty to allow every service enabled in the general configuration.": "Leave empty to allow every service enabled in the general configuration.",
-  "Users who do not belong to any other group automatically use this default group — no need to add members.": "Users who do not belong to any other group automatically use this default group — no need to add members."
+  "Users who do not belong to any other group automatically use this default group — no need to add members.": "Users who do not belong to any other group automatically use this default group — no need to add members.",
+  "Membership": "Membership",
+  "Model routing": "Model routing",
+  "Model routing (virtual models)": "Model routing (virtual models)",
+  "Alias": "Alias",
+  "Fallback model": "Fallback model",
+  "A fallback model is required": "A fallback model is required",
+  "Used when no capability bucket candidate is usable and the fallback is permitted for the caller.": "Used when no capability bucket candidate is usable and the fallback is permitted for the caller.",
+  "Vision models (in order)": "Vision models (in order)",
+  "Requests with an image or file block use the first permitted model here.": "Requests with an image or file block use the first permitted model here.",
+  "Tool-calling models (in order)": "Tool-calling models (in order)",
+  "Requests with tools/tool_choice use the first permitted model here.": "Requests with tools/tool_choice use the first permitted model here.",
+  "Reasoning models (in order)": "Reasoning models (in order)",
+  "Requests with an explicit reasoning or reasoning_effort parameter use the first permitted model here.": "Requests with an explicit reasoning or reasoning_effort parameter use the first permitted model here.",
+  "Cheap models (in order)": "Cheap models (in order)",
+  "Optional. When set, cheap-eligible requests use the first permitted model here.": "Optional. When set, cheap-eligible requests use the first permitted model here.",
+  "General models (in order)": "General models (in order)",
+  "Default bucket when no capability rule matched. Leave empty to derive from all enabled models ordered by Model metadata sortOrder.": "Default bucket when no capability rule matched. Leave empty to derive from all enabled models ordered by Model metadata sortOrder.",
+  "Type service/model and press Enter — earlier entries are preferred": "Type service/model and press Enter — earlier entries are preferred",
+  "An empty bucket is derived automatically from Model metadata (capability flags + sortOrder).": "An empty bucket is derived automatically from Model metadata (capability flags + sortOrder).",
+  "Save": "Save",
+  "Supports vision": "Supports vision",
+  "Used by virtual-model routing for image/file requests.": "Used by virtual-model routing for image/file requests.",
+  "Supports tool calling": "Supports tool calling",
+  "Used by virtual-model routing for requests with tools/tool_choice.": "Used by virtual-model routing for requests with tools/tool_choice.",
+  "Reasoning tier": "Reasoning tier",
+  "cheap | general | reasoning. Used by virtual-model routing buckets.": "cheap | general | reasoning. Used by virtual-model routing buckets.",
+  "Cheap": "Cheap",
+  "General": "General",
+  "Reasoning": "Reasoning",
+  "Routing priority": "Routing priority",
+  "Ascending — lower is preferred when a bucket is derived from metadata.": "Ascending — lower is preferred when a bucket is derived from metadata.",
+  "Select models — the order shown is the routing priority": "Select models — the order shown is the routing priority",
+  "Select a fallback model": "Select a fallback model",
+  "Name": "Name",
+  "Rate limit/min": "Rate limit/min",
+  "unavailable": "(unavailable)"
 }