plugin-ai-api 1.1.1 → 1.1.2

package/dist/swagger.js

@@ -197,6 +197,143 @@ var swagger_default = {
         }
       }
     },
+    "/ai-llm/v1/responses": {
+      post: {
+        tags: ["ai-llm"],
+        summary: "Create a model response",
+        description: "OpenAI Responses API endpoint. Supports text/image/file inputs, function calling, streaming, reasoning output when exposed by the provider, and owner-scoped previous_response_id chains. Built-in web_search and file_search tools are not supported.",
+        security: [{ BearerAuth: [] }],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  model: { type: "string", example: "openai/gpt-4o" },
+                  input: {
+                    oneOf: [{ type: "string" }, { type: "array", items: { type: "object" } }]
+                  },
+                  instructions: { type: "string" },
+                  max_output_tokens: { type: "integer" },
+                  temperature: { type: "number", minimum: 0, maximum: 2 },
+                  top_p: { type: "number", minimum: 0, maximum: 1 },
+                  tools: { type: "array", description: "Function tools only", items: { type: "object" } },
+                  tool_choice: { oneOf: [{ type: "string" }, { type: "object" }] },
+                  metadata: { type: "object" },
+                  previous_response_id: { type: "string" },
+                  store: { type: "boolean", default: true },
+                  stream: { type: "boolean", default: false },
+                  truncation: { type: "string", enum: ["auto", "disabled"], default: "disabled" },
+                  service_tier: { type: "string", enum: ["auto", "default", "flex", "scale", "priority"] },
+                  prompt_cache_key: { type: "string" },
+                  prompt_cache_retention: { type: "string", enum: ["in_memory", "24h"], nullable: true },
+                  reasoning: { type: "object" },
+                  safety_identifier: { type: "string", maxLength: 64 },
+                  parallel_tool_calls: { type: "boolean", default: true },
+                  text: { type: "object" }
+                },
+                required: ["model", "input"]
+              }
+            }
+          }
+        },
+        responses: {
+          200: {
+            description: "OpenAI Response object, or Responses API SSE events when stream=true",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    id: { type: "string", example: "resp_abc123" },
+                    object: { type: "string", const: "response" },
+                    created_at: { type: "integer" },
+                    completed_at: { type: "integer", nullable: true },
+                    model: { type: "string" },
+                    status: {
+                      type: "string",
+                      enum: ["completed", "failed", "in_progress", "cancelled", "queued", "incomplete"]
+                    },
+                    output_text: { type: "string" },
+                    output: { type: "array", items: { type: "object" } },
+                    usage: {
+                      type: "object",
+                      properties: {
+                        input_tokens: { type: "integer" },
+                        input_tokens_details: {
+                          type: "object",
+                          properties: { cached_tokens: { type: "integer" } }
+                        },
+                        output_tokens: { type: "integer" },
+                        output_tokens_details: {
+                          type: "object",
+                          properties: { reasoning_tokens: { type: "integer" } }
+                        },
+                        total_tokens: { type: "integer" }
+                      }
+                    },
+                    metadata: { type: "object", nullable: true },
+                    previous_response_id: { type: "string", nullable: true },
+                    truncation: { type: "string", enum: ["auto", "disabled"] },
+                    error: { type: "object", nullable: true }
+                  }
+                }
+              },
+              "text/event-stream": { schema: { type: "string" } }
+            }
+          },
+          400: { description: "Invalid request or unsupported tool" },
+          404: { description: "Model or previous response not found" },
+          429: { description: "Rate limit or quota exceeded" }
+        }
+      }
+    },
+    "/ai-llm/v1/responses/{id}": {
+      get: {
+        tags: ["ai-llm"],
+        summary: "Retrieve a stored model response",
+        description: "Returns a non-expired response created by the authenticated user. Responses created with store=false cannot be retrieved.",
+        security: [{ BearerAuth: [] }],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: { type: "string", example: "resp_abc123" }
+          },
+          {
+            name: "stream",
+            in: "query",
+            schema: { type: "boolean", default: false },
+            description: "Only false is currently supported; stream retrieval is rejected."
+          }
+        ],
+        responses: {
+          200: { description: "Stored OpenAI Response object" },
+          400: { description: "Unsupported retrieve expansion or streaming parameter" },
+          404: { description: "Response not found, expired, or owned by another user" }
+        }
+      },
+      delete: {
+        tags: ["ai-llm"],
+        summary: "Delete a stored model response",
+        description: "Deletes a stored response owned by the authenticated user.",
+        security: [{ BearerAuth: [] }],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: { type: "string", example: "resp_abc123" }
+          }
+        ],
+        responses: {
+          204: { description: "Response deleted" },
+          404: { description: "Response not found, expired, or owned by another user" }
+        }
+      }
+    },
     "/ai-llm/v1/embeddings": {
       post: {
         tags: ["ai-llm"],

package/package.json

@@ -1,33 +1,35 @@
-{
-  "name": "plugin-ai-api",
-  "version": "1.1.1",
-  "main": "dist/server/index.js",
-  "dependencies": {},
-  "peerDependencies": {
-    "@nocobase/client": "2.x",
-    "@nocobase/server": "2.x",
-    "@nocobase/database": "2.x",
-    "@nocobase/plugin-acl": "2.x",
-    "@nocobase/plugin-ai": "2.x",
-    "@nocobase/plugin-api-keys": "2.x",
-    "@nocobase/client-v2": "2.x",
-    "@nocobase/flow-engine": "2.x"
-  },
-  "nocobase": {
-    "supportedVersions": [
-      "2.x"
-    ],
-    "editionLevel": 0
-  },
-  "files": [
-    "dist",
-    "src",
-    "client.js",
-    "client-v2.js",
-    "server.js",
-    "client.d.ts",
-    "client-v2.d.ts",
-    "server.d.ts"
-  ],
-  "license": "Apache-2.0"
+{
+  "name": "plugin-ai-api",
+  "version": "1.1.2",
+  "main": "dist/server/index.js",
+  "dependencies": {},
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/database": "2.x",
+    "@nocobase/plugin-acl": "2.x",
+    "@nocobase/plugin-ai": "2.x",
+    "@nocobase/plugin-api-keys": "2.x",
+    "@nocobase/client-v2": "2.x",
+    "@nocobase/flow-engine": "2.x"
+  },
+  "nocobase": {
+    "supportedVersions": [
+      "2.x"
+    ],
+    "editionLevel": 0
+  },
+  "files": [
+    "dist",
+    "src",
+    "client.js",
+    "client-v2.js",
+    "server.js",
+    "client.d.ts",
+    "client-v2.d.ts",
+    "server.d.ts"
+  ],
+  "license": "Apache-2.0"
+,
+  "keywords": "AI"
 }

package/src/__tests__/locale.test.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { readFileSync } from 'fs';
+import { join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const LOCALE_DIR = join(__dirname, '..', 'locale');
+const FILES = ['en-US.json', 'zh-CN.json', 'vi-VN.json'] as const;
+
+function loadLocale(file: string): Record<string, string> {
+  return JSON.parse(readFileSync(join(LOCALE_DIR, file), 'utf8')) as Record<string, string>;
+}
+
+describe('plugin-ai-api locale files', () => {
+  it('all locale files are valid JSON with no empty values', () => {
+    for (const file of FILES) {
+      const locale = loadLocale(file);
+      expect(Object.keys(locale).length, `${file} should not be empty`).toBeGreaterThan(0);
+      for (const [key, value] of Object.entries(locale)) {
+        expect(typeof value, `${file}[${JSON.stringify(key)}] must be a string`).toBe('string');
+        expect(value.trim().length, `${file}[${JSON.stringify(key)}] must not be blank`).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('all locales expose the identical set of keys', () => {
+    const [base, ...rest] = FILES;
+    const baseKeys = Object.keys(loadLocale(base)).sort();
+    for (const file of rest) {
+      const keys = Object.keys(loadLocale(file)).sort();
+      const missing = baseKeys.filter((key) => !keys.includes(key));
+      const extra = keys.filter((key) => !baseKeys.includes(key));
+      expect({ file, missing, extra }).toEqual({ file, missing: [], extra: [] });
+    }
+  });
+});

package/src/client/__tests__/settings-registration.test.tsx

@@ -29,6 +29,7 @@ describe('AI API v1 settings registration', () => {
       'ai-api.config',
       'ai-api.model-pricing',
       'ai-api.model-metadata',
+      'ai-api.model-routing',
       'ai-api.usage-groups',
       'ai-api.usage',
     ]);

package/src/client/plugin.tsx

@@ -8,13 +8,14 @@
  */
 
 import { Plugin, lazy } from '@nocobase/client';
-import PluginACLClient from '@nocobase/plugin-acl/client';
+import PluginACLClient from '@nocobase/plugin-acl';
 import { AI_API_ACL_SNIPPET } from '../constants';
 import React from 'react';
 
 const AiApiConfigPage = React.lazy(() => import('../client-v2/pages/GeneralPage'));
 const AiApiModelPricingPage = React.lazy(() => import('../client-v2/pages/ModelPricingPage'));
 const AiApiModelMetadataPage = React.lazy(() => import('../client-v2/pages/ModelMetadataPage'));
+const AiApiModelRoutingPage = React.lazy(() => import('../client-v2/pages/ModelRoutingPage'));
 const AiApiUsageGroupsPage = React.lazy(() => import('../client-v2/pages/UsageGroupsPage'));
 const AiApiUsagePage = React.lazy(() => import('../client-v2/pages/UsagePage'));
 const { AiApiRolePermissions } = lazy(() => import('./components/AiApiRolePermissions'), 'AiApiRolePermissions');
@@ -48,6 +49,13 @@ export class PluginAiApiClient extends Plugin {
       sort: 3,
     });
 
+    this.app.pluginSettingsManager.add('ai-api.model-routing', {
+      title: this.t('Model routing'),
+      Component: AiApiModelRoutingPage,
+      aclSnippet: AI_API_ACL_SNIPPET,
+      sort: 4,
+    });
+
     this.app.pluginSettingsManager.add('ai-api.usage-groups', {
       title: this.t('Usage groups'),
       Component: AiApiUsageGroupsPage,

package/src/client-v2/__tests__/settings-registration.test.tsx

@@ -54,6 +54,7 @@ describe('AI API v2 settings registration', () => {
       'ai-api.index',
       'ai-api.model-pricing',
       'ai-api.model-metadata',
+      'ai-api.model-routing',
       'ai-api.usage-groups',
       'ai-api.usage',
     ]);

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

@@ -23,6 +23,10 @@ interface ModelMetadata {
   id: string | number;
   llmService: string;
   model: string;
+  supportsVision?: boolean;
+  supportsToolCalling?: boolean;
+  reasoningTier?: string;
+  sortOrder?: number;
   contextWindow?: number | null;
   maxCompletionTokens?: number | null;
   ownedByOverride?: string | null;
@@ -138,6 +142,10 @@ export default function ModelMetadataPage() {
       displayName: values.displayName?.trim() || null,
       description: values.description?.trim() || null,
       systemPrompt: values.systemPrompt?.trim() || null,
+      supportsVision: !!values.supportsVision,
+      supportsToolCalling: values.supportsToolCalling !== false,
+      reasoningTier: values.reasoningTier || 'general',
+      sortOrder: values.sortOrder ?? 0,
     };
     setSaving(true);
     try {
@@ -289,6 +297,42 @@ export default function ModelMetadataPage() {
           >
             <Input.TextArea rows={4} placeholder={t('Leave empty to not override')} />
           </Form.Item>
+          <Form.Item
+            name="supportsVision"
+            label={t('Supports vision')}
+            valuePropName="checked"
+            tooltip={t('Used by virtual-model routing for image/file requests.')}
+          >
+            <Switch />
+          </Form.Item>
+          <Form.Item
+            name="supportsToolCalling"
+            label={t('Supports tool calling')}
+            valuePropName="checked"
+            tooltip={t('Used by virtual-model routing for requests with tools/tool_choice.')}
+          >
+            <Switch defaultChecked />
+          </Form.Item>
+          <Form.Item
+            name="reasoningTier"
+            label={t('Reasoning tier')}
+            tooltip={t('cheap | general | reasoning. Used by virtual-model routing buckets.')}
+          >
+            <Select
+              options={[
+                { value: 'cheap', label: t('Cheap') },
+                { value: 'general', label: t('General') },
+                { value: 'reasoning', label: t('Reasoning') },
+              ]}
+            />
+          </Form.Item>
+          <Form.Item
+            name="sortOrder"
+            label={t('Routing priority')}
+            tooltip={t('Ascending — lower is preferred when a bucket is derived from metadata.')}
+          >
+            <InputNumber precision={0} style={{ width: '100%' }} placeholder="0" />
+          </Form.Item>
           <Form.Item name="enabled" label={t('Enabled')} valuePropName="checked">
             <Switch />
           </Form.Item>

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>
+  );
+}