plugin-ai-api 1.0.21 → 1.0.24

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

@@ -12,6 +12,7 @@ import {
   generateCompletionId,
   toOpenAIResponse,
   toOpenAIStreamChunk,
+  toOpenAIUsageChunk,
   toOpenAIError,
   formatSSE,
   formatSSEDone,
@@ -26,9 +27,11 @@ import {
   writeResponse,
 } from '../utils/streaming';
 import { checkEmployeeAccess } from '../middleware/role-permission';
+import { enforceModelAccess } from '../utils/user-permissions';
 import { extractProviderRequestId, normalizeUsage, setAiApiUsageResult, type Usage } from '../usage';
 import type PluginAiApiServer from '../plugin';
 import { AiApiQuotaError, markLlmProviderAttempted, prepareLlmBilling } from '../billing';
+import { DirectLlmContextError, prepareDirectLlmContext, type OpenAIMessage } from '../utils/direct-llm-context';
 import { markAiApiFirstProviderOutput } from '../utils/app-observability';
 
 /**
@@ -126,22 +129,10 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
       return;
     }
 
-    // ─── Check whitelist ───
+    // ─── Check whitelist (global config ∩ per-user grant) ───
     const config = await ctx.db.getRepository('aiApiConfig').findOne();
-    if (config?.enabledLlmServices?.length) {
-      const serviceName = service.name;
-      const serviceTitle = service.title;
-      const isAllowed = config.enabledLlmServices.some((s: string) => s === serviceName || s === serviceTitle);
-      if (!isAllowed) {
-        ctx.status = 403;
-        ctx.body = toOpenAIError(
-          403,
-          `LLM service '${service.title || service.name}' is not enabled for API access`,
-          'invalid_request_error',
-          'model_not_available',
-        );
-        return;
-      }
+    if (!(await enforceModelAccess(ctx, config?.enabledLlmServices, service, modelId))) {
+      return;
     }
 
     // ─── Create LLM provider instance ───
@@ -152,9 +143,14 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
       return;
     }
 
-    await prepareLlmBilling(ctx, resolved);
-
     const providerRequestParameters = getProviderRequestParameters(body);
+    if (stream) {
+      const streamOptions = isRecord(body.stream_options) ? body.stream_options : {};
+      providerRequestParameters.stream_options = {
+        ...streamOptions,
+        include_usage: true,
+      };
+    }
     const modelOptions: Record<string, unknown> = {
       model: modelId,
       llmService: service.name,
@@ -169,13 +165,6 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
     if (body.presence_penalty !== undefined) modelOptions.presencePenalty = body.presence_penalty;
     if (body.stop !== undefined) modelOptions.stop = body.stop;
 
-    const Provider = providerMeta.provider;
-    const provider = new Provider({
-      app: ctx.app,
-      serviceOptions: service.options,
-      modelOptions,
-    });
-
     // ─── Build system prompt from AI Employee ───
     let systemPrompt = '';
     if (config?.defaultAiEmployee) {
@@ -200,12 +189,31 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
     }
 
     // ─── Build messages (inject system prompt if not provided by client) ───
-    const messages = [...body.messages];
+    let messages: OpenAIMessage[] = [...body.messages];
     const hasSystemMessage = messages.some((m: any) => m.role === 'system');
     if (systemPrompt && !hasSystemMessage) {
       messages.unshift({ role: 'system', content: systemPrompt });
     }
 
+    const preparedContext = await prepareDirectLlmContext(ctx, {
+      serviceName: service.name,
+      modelId,
+      messages,
+      tools: body.tools,
+      maxCompletionTokens: body.max_completion_tokens,
+      maxTokens: body.max_tokens,
+    });
+    messages = preparedContext.messages;
+
+    await prepareLlmBilling(ctx, resolved);
+
+    const Provider = providerMeta.provider;
+    const provider = new Provider({
+      app: ctx.app,
+      serviceOptions: service.options,
+      modelOptions,
+    });
+
     // ─── Build message tuples for LangChain model ───
     // LangChain chat models accept [role, content] tuples or BaseMessage objects.
     // We use tuples to avoid importing @langchain/core directly.
@@ -260,15 +268,16 @@ export async function handleChatCompletions(ctx: Context, plugin: PluginAiApiSer
     }
   } catch (err) {
     ctx.log.error('AI API chat completions error:', err);
-    if (!ctx.res.headersSent) {
+    if (!ctx.res?.headersSent) {
       const isQuotaError = err instanceof AiApiQuotaError;
-      ctx.status = isQuotaError ? 429 : 500;
+      const isContextError = err instanceof DirectLlmContextError;
+      ctx.status = isQuotaError ? 429 : isContextError ? 400 : 500;
       if (isQuotaError) ctx.set('X-RateLimit-Reason', err.code);
       ctx.body = toOpenAIError(
         ctx.status,
         getErrorMessage(err, 'Internal server error'),
-        isQuotaError ? 'quota_error' : 'server_error',
-        isQuotaError ? err.code : undefined,
+        isQuotaError ? 'quota_error' : isContextError ? 'invalid_request_error' : 'server_error',
+        isQuotaError || isContextError ? err.code : undefined,
       );
     }
   }
@@ -380,7 +389,13 @@ async function handleStreamingCompletion(
         finishReason = 'tool_calls';
         await writeResponse(
           ctx,
-          formatSSE(toOpenAIStreamChunk({ id: completionId, model: modelName, delta: { tool_calls: toolCallChunks } })),
+          formatSSE(
+            toOpenAIStreamChunk({
+              id: completionId,
+              model: modelName,
+              delta: { tool_calls: toolCallChunks },
+            }),
+          ),
         );
       }
       if (chunk.usage_metadata) {
@@ -402,6 +417,19 @@ async function handleStreamingCompletion(
       ),
     );
 
+    if (usage) {
+      await writeResponse(
+        ctx,
+        formatSSE(
+          toOpenAIUsageChunk({
+            id: completionId,
+            model: modelName,
+            usage,
+          }),
+        ),
+      );
+    }
+
     // Send [DONE]
     await writeResponse(ctx, formatSSEDone());
     setAiApiUsageResult(ctx, usage, { gatewayResponseId: completionId, providerRequestId });

package/src/server/routes/completions.ts

@@ -8,8 +8,15 @@
  */
 
 import { Context } from '@nocobase/actions';
-import { generateCompletionId, toOpenAIError, formatSSE, formatSSEDone } from '../utils/openai-format';
+import {
+  generateCompletionId,
+  toOpenAIError,
+  formatSSE,
+  formatSSEDone,
+  toOpenAIUsageChunk,
+} from '../utils/openai-format';
 import { resolveModelString } from '../utils/resolve-service';
+import { enforceModelAccess } from '../utils/user-permissions';
 import {
   createRequestAbortController,
   isClientDisconnected,
@@ -19,6 +26,7 @@ import {
 import { extractProviderRequestId, normalizeUsage, setAiApiUsageResult, type Usage } from '../usage';
 import type PluginAiApiServer from '../plugin';
 import { AiApiQuotaError, markLlmProviderAttempted, prepareLlmBilling } from '../billing';
+import { DirectLlmContextError, prepareDirectLlmContext, type OpenAIMessage } from '../utils/direct-llm-context';
 import { markAiApiFirstProviderOutput } from '../utils/app-observability';
 
 /**
@@ -93,22 +101,10 @@ export async function handleCompletions(ctx: Context, plugin: PluginAiApiServer)
       return;
     }
 
-    // ─── Check whitelist ───
+    // ─── Check whitelist (global config ∩ per-user grant) ───
     const config = await ctx.db.getRepository('aiApiConfig').findOne();
-    if (config?.enabledLlmServices?.length) {
-      const serviceName = service.name;
-      const serviceTitle = service.title;
-      const isAllowed = config.enabledLlmServices.some((s: string) => s === serviceName || s === serviceTitle);
-      if (!isAllowed) {
-        ctx.status = 403;
-        ctx.body = toOpenAIError(
-          403,
-          `LLM service '${service.title || service.name}' is not enabled for API access`,
-          'invalid_request_error',
-          'model_not_available',
-        );
-        return;
-      }
+    if (!(await enforceModelAccess(ctx, config?.enabledLlmServices, service, modelId))) {
+      return;
     }
 
     // ─── Create LLM provider instance ───
@@ -119,8 +115,6 @@ export async function handleCompletions(ctx: Context, plugin: PluginAiApiServer)
       return;
     }
 
-    await prepareLlmBilling(ctx, resolved);
-
     const modelOptions: Record<string, any> = {
       model: modelId,
       llmService: service.name,
@@ -131,13 +125,6 @@ export async function handleCompletions(ctx: Context, plugin: PluginAiApiServer)
     if (body.max_tokens !== undefined) modelOptions.maxTokens = body.max_tokens;
     if (body.stop !== undefined) modelOptions.stop = body.stop;
 
-    const Provider = providerMeta.provider;
-    const provider = new Provider({
-      app: ctx.app,
-      serviceOptions: service.options,
-      modelOptions,
-    });
-
     // ─── Convert prompt to message tuple ───
     const prompt =
       typeof body.prompt === 'string'
@@ -147,7 +134,7 @@ export async function handleCompletions(ctx: Context, plugin: PluginAiApiServer)
           : String(body.prompt);
 
     // Inject system prompt from AI Employee if configured
-    const langchainMessages: [string, string][] = [];
+    const messages: OpenAIMessage[] = [];
     if (config?.defaultAiEmployee) {
       const employee = await ctx.db.getRepository('aiEmployees').findOne({
         filter: { username: config.defaultAiEmployee },
@@ -155,32 +142,59 @@ export async function handleCompletions(ctx: Context, plugin: PluginAiApiServer)
       if (employee) {
         const systemPrompt = employee.about || employee.defaultPrompt || '';
         if (systemPrompt) {
-          langchainMessages.push(['system', systemPrompt]);
+          messages.push({ role: 'system', content: systemPrompt });
         }
       }
     }
-    langchainMessages.push(['human', prompt]);
+    messages.push({ role: 'user', content: prompt });
+
+    const preparedContext = await prepareDirectLlmContext(ctx, {
+      serviceName: service.name,
+      modelId,
+      messages,
+      maxTokens: body.max_tokens,
+    });
+    await prepareLlmBilling(ctx, resolved);
+
+    const Provider = providerMeta.provider;
+    const provider = new Provider({
+      app: ctx.app,
+      serviceOptions: service.options,
+      modelOptions,
+    });
+    const langchainMessages = preparedContext.messages.map((message): [string, string] => [
+      message.role === 'user' ? 'human' : message.role,
+      String(message.content ?? ''),
+    ]);
 
     const completionId = generateCompletionId().replace('chatcmpl-', 'cmpl-');
     const chatModel = provider.createModel();
     markLlmProviderAttempted(ctx);
 
     if (stream) {
-      await handleStreamingTextCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+      await handleStreamingTextCompletion(
+        ctx,
+        chatModel,
+        langchainMessages,
+        completionId,
+        body.model,
+        body.stream_options,
+      );
     } else {
       await handleNonStreamingTextCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
     }
   } catch (err) {
     ctx.log.error('AI API completions error:', err);
-    if (!ctx.res.headersSent) {
+    if (!ctx.res?.headersSent) {
       const isQuotaError = err instanceof AiApiQuotaError;
-      ctx.status = isQuotaError ? 429 : 500;
+      const isContextError = err instanceof DirectLlmContextError;
+      ctx.status = isQuotaError ? 429 : isContextError ? 400 : 500;
       if (isQuotaError) ctx.set('X-RateLimit-Reason', err.code);
       ctx.body = toOpenAIError(
         ctx.status,
         getErrorMessage(err, 'Internal server error'),
-        isQuotaError ? 'quota_error' : 'server_error',
-        isQuotaError ? err.code : undefined,
+        isQuotaError ? 'quota_error' : isContextError ? 'invalid_request_error' : 'server_error',
+        isQuotaError || isContextError ? err.code : undefined,
       );
     }
   }
@@ -237,6 +251,7 @@ async function handleStreamingTextCompletion(
   messages: [string, string][],
   completionId: string,
   modelName: string,
+  streamOptions: Record<string, unknown> | undefined,
 ) {
   ctx.set({
     'Content-Type': 'text/event-stream',
@@ -250,7 +265,10 @@ async function handleStreamingTextCompletion(
   let usage: Usage | undefined;
   let providerRequestId: string | undefined;
   try {
-    const stream = await chatModel.stream(messages, { signal: requestAbort.signal });
+    const stream = await chatModel.stream(messages, {
+      stream_options: { ...streamOptions, include_usage: true },
+      signal: requestAbort.signal,
+    });
 
     for await (const chunk of stream) {
       if (requestAbort.signal.aborted) throw requestAbort.signal.reason;
@@ -280,6 +298,7 @@ async function handleStreamingTextCompletion(
                 finish_reason: null,
               },
             ],
+            usage: null,
           }),
         );
       }
@@ -306,9 +325,24 @@ async function handleStreamingTextCompletion(
             finish_reason: 'stop',
           },
         ],
+        usage: null,
       }),
     );
 
+    if (usage) {
+      await writeResponse(
+        ctx,
+        formatSSE(
+          toOpenAIUsageChunk({
+            id: completionId,
+            model: modelName,
+            object: 'text_completion',
+            usage,
+          }),
+        ),
+      );
+    }
+
     await writeResponse(ctx, formatSSEDone());
     setAiApiUsageResult(ctx, usage, { gatewayResponseId: completionId, providerRequestId });
     ctx.state.aiApiStreamResult = { succeeded: true, id: completionId };

package/src/server/routes/embeddings.ts

@@ -10,6 +10,7 @@
 import { Context } from '@nocobase/actions';
 import { toOpenAIError, toOpenAIEmbeddingsResponse } from '../utils/openai-format';
 import { resolveModelString } from '../utils/resolve-service';
+import { enforceModelAccess } from '../utils/user-permissions';
 import { setAiApiUsageUnavailable } from '../usage';
 import type PluginAiApiServer from '../plugin';
 
@@ -112,24 +113,18 @@ export async function handleEmbeddings(ctx: Context, plugin: PluginAiApiServer)
     return;
   }
 
-  // ─── Check service whitelist ──────────────────────────────────────────────
+  // ─── Check service whitelist (global config ∩ per-user grant) ─────────────
+  // A config read failure falls open on the global list, but the per-user grant is
+  // still enforced: an explicit deny must never be bypassed by an unreadable config.
+  let globalEnabledServices: unknown = [];
   try {
     const config = await ctx.db.getRepository('aiApiConfig').findOne();
-    if (config?.enabledLlmServices?.length) {
-      const allowed = config.enabledLlmServices.some((s: string) => s === service.name || s === service.title);
-      if (!allowed) {
-        ctx.status = 403;
-        ctx.body = toOpenAIError(
-          403,
-          `LLM service '${service.title || service.name}' is not enabled for API access`,
-          'invalid_request_error',
-          'model_not_available',
-        );
-        return;
-      }
-    }
+    globalEnabledServices = config?.enabledLlmServices ?? [];
   } catch {
-    // Config read failure: fail open
+    // Config read failure: fail open on the global whitelist only.
+  }
+  if (!(await enforceModelAccess(ctx, globalEnabledServices, service, modelId))) {
+    return;
   }
 
   // ─── Get embedding provider ───────────────────────────────────────────────

package/src/server/routes/models.ts

@@ -9,6 +9,7 @@
 
 import { Context } from '@nocobase/actions';
 import { toOpenAIError } from '../utils/openai-format';
+import { isModelAllowed, isServiceAllowed, resolveUserAccessScope } from '../utils/user-permissions';
 import type PluginAiApiServer from '../plugin';
 
 /**
@@ -19,6 +20,9 @@ import type PluginAiApiServer from '../plugin';
  * so clients can copy-paste the ID directly into POST /v1/chat/completions
  * without needing to configure a defaultLlmService.
  *
+ * The catalog is scoped to the caller: a user with an aiApiUserPermissions row only
+ * sees the intersection of the global whitelist and their own grant.
+ *
  * Backward compatibility: resolveModelString() in resolve-service.ts still
  * accepts bare model IDs via its 3-tier fallback (defaultLlmService / single service).
  */
@@ -44,18 +48,25 @@ export async function handleListModels(ctx: Context, plugin: PluginAiApiServer)
       sort: 'sort',
     });
 
+    const scope = await resolveUserAccessScope(ctx);
+    if (scope.lookupFailed) {
+      respondPermissionCheckFailed(ctx);
+      return;
+    }
     const metadataMap = await loadModelMetadata(ctx);
     const now = Math.floor(Date.now() / 1000);
     const models: any[] = [];
 
     for (const service of services) {
       if (service.enabled === false) continue;
+      if (!isServiceAllowed(scope, config?.enabledLlmServices, service)) continue;
 
       const enabledModels = resolveEnabledModels(service);
       const serviceLabel = service.title || service.name;
 
       for (const model of enabledModels) {
         const fullId = `${service.name}/${model.value}`;
+        if (!isModelAllowed(scope, fullId)) continue;
         const meta = metadataMap.get(fullId);
         // An override row with enabled=false hides the model from the catalog.
         if (meta && meta.enabled === false) continue;
@@ -95,12 +106,18 @@ export async function handleGetModel(ctx: Context, modelId: string, plugin: Plug
       sort: 'sort',
     });
 
+    const scope = await resolveUserAccessScope(ctx);
+    if (scope.lookupFailed) {
+      respondPermissionCheckFailed(ctx);
+      return;
+    }
     const metadataMap = await loadModelMetadata(ctx);
     const now = Math.floor(Date.now() / 1000);
     let found: any = null;
 
     for (const service of services) {
       if (service.enabled === false) continue;
+      if (!isServiceAllowed(scope, config?.enabledLlmServices, service)) continue;
       const enabledModels = resolveEnabledModels(service);
       const serviceLabel = service.title || service.name;
 
@@ -108,6 +125,7 @@ export async function handleGetModel(ctx: Context, modelId: string, plugin: Plug
         const fullId = `${service.name}/${model.value}`;
         // Accept both new "serviceName/modelId" format AND bare model ID (backward compat)
         if (fullId === modelId || model.value === modelId) {
+          if (!isModelAllowed(scope, fullId)) continue;
           const meta = metadataMap.get(fullId);
           // A disabled override hides the model — treat as not found.
           if (meta && meta.enabled === false) continue;
@@ -135,6 +153,16 @@ export async function handleGetModel(ctx: Context, modelId: string, plugin: Plug
 
 // ─── Helpers ───
 
+function respondPermissionCheckFailed(ctx: Context): void {
+  ctx.status = 503;
+  ctx.body = toOpenAIError(
+    503,
+    'Unable to verify LLM permissions for this user. Please retry shortly.',
+    'service_unavailable',
+    'permission_check_failed',
+  );
+}
+
 export interface ModelMetadataOverride {
   contextWindow?: number | null;
   maxCompletionTokens?: number | null;