plugin-ai-api 1.0.20 → 1.0.23

package/dist/server/routes/completions.js

@@ -31,11 +31,12 @@ __export(completions_exports, {
 module.exports = __toCommonJS(completions_exports);
 var import_openai_format = require("../utils/openai-format");
 var import_resolve_service = require("../utils/resolve-service");
+var import_user_permissions = require("../utils/user-permissions");
 var import_streaming = require("../utils/streaming");
 var import_usage = require("../usage");
 var import_billing = require("../billing");
+var import_app_observability = require("../utils/app-observability");
 async function handleCompletions(ctx, plugin) {
-  var _a;
   const body = ctx.request.body;
   if (!(body == null ? void 0 : body.model)) {
     ctx.status = 400;
@@ -88,20 +89,8 @@ async function handleCompletions(ctx, plugin) {
       return;
     }
     const config = await ctx.db.getRepository("aiApiConfig").findOne();
-    if ((_a = config == null ? void 0 : config.enabledLlmServices) == null ? void 0 : _a.length) {
-      const serviceName = service.name;
-      const serviceTitle = service.title;
-      const isAllowed = config.enabledLlmServices.some((s) => s === serviceName || s === serviceTitle);
-      if (!isAllowed) {
-        ctx.status = 403;
-        ctx.body = (0, import_openai_format.toOpenAIError)(
-          403,
-          `LLM service '${service.title || service.name}' is not enabled for API access`,
-          "invalid_request_error",
-          "model_not_available"
-        );
-        return;
-      }
+    if (!await (0, import_user_permissions.enforceModelAccess)(ctx, config == null ? void 0 : config.enabledLlmServices, service, modelId)) {
+      return;
     }
     const providerMeta = aiPlugin.aiManager.llmProviders.get(service.provider);
     if (!providerMeta) {
@@ -142,7 +131,14 @@ async function handleCompletions(ctx, plugin) {
     const chatModel = provider.createModel();
     (0, import_billing.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);
     }
@@ -192,7 +188,7 @@ async function handleNonStreamingTextCompletion(ctx, chatModel, messages, comple
     usage: usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
   };
 }
-async function handleStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName) {
+async function handleStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName, streamOptions) {
   ctx.set({
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
@@ -204,7 +200,10 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
   let usage;
   let providerRequestId;
   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;
       let text = "";
@@ -215,6 +214,7 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
         text = (textPart == null ? void 0 : textPart.text) || "";
       }
       if (text) {
+        (0, import_app_observability.markAiApiFirstProviderOutput)(ctx);
         await (0, import_streaming.writeResponse)(
           ctx,
           (0, import_openai_format.formatSSE)({
@@ -230,7 +230,8 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
                 logprobs: null,
                 finish_reason: null
               }
-            ]
+            ],
+            usage: null
           })
         );
       }
@@ -254,13 +255,28 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
             logprobs: null,
             finish_reason: "stop"
           }
-        ]
+        ],
+        usage: null
       })
     );
+    if (usage) {
+      await (0, import_streaming.writeResponse)(
+        ctx,
+        (0, import_openai_format.formatSSE)(
+          (0, import_openai_format.toOpenAIUsageChunk)({
+            id: completionId,
+            model: modelName,
+            object: "text_completion",
+            usage
+          })
+        )
+      );
+    }
     await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSEDone)());
     (0, import_usage.setAiApiUsageResult)(ctx, usage, { gatewayResponseId: completionId, providerRequestId });
     ctx.state.aiApiStreamResult = { succeeded: true, id: completionId };
   } catch (err) {
+    const cancelled = (0, import_streaming.isClientDisconnected)(ctx, err);
     ctx.log.error("AI API completions streaming error:", err);
     if (!ctx.res.destroyed && !ctx.res.writableEnded) {
       await (0, import_streaming.writeResponse)(
@@ -274,7 +290,11 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
       );
     }
     (0, import_usage.setAiApiUsageResult)(ctx, usage, { gatewayResponseId: completionId, providerRequestId });
-    ctx.state.aiApiStreamResult = { succeeded: false, id: completionId, errorCode: "stream_error" };
+    ctx.state.aiApiStreamResult = {
+      succeeded: false,
+      id: completionId,
+      errorCode: cancelled ? "client_disconnected" : "stream_error"
+    };
   } finally {
     requestAbort.dispose();
     if (!ctx.res.writableEnded && !ctx.res.destroyed) ctx.res.end();

package/dist/server/routes/embeddings.js

@@ -31,9 +31,9 @@ __export(embeddings_exports, {
 module.exports = __toCommonJS(embeddings_exports);
 var import_openai_format = require("../utils/openai-format");
 var import_resolve_service = require("../utils/resolve-service");
+var import_user_permissions = require("../utils/user-permissions");
 var import_usage = require("../usage");
 async function handleEmbeddings(ctx, plugin) {
-  var _a;
   const body = ctx.request.body;
   if (!(body == null ? void 0 : body.model)) {
     ctx.status = 400;
@@ -102,23 +102,15 @@ async function handleEmbeddings(ctx, plugin) {
     );
     return;
   }
+  let globalEnabledServices = [];
   try {
     const config = await ctx.db.getRepository("aiApiConfig").findOne();
-    if ((_a = config == null ? void 0 : config.enabledLlmServices) == null ? void 0 : _a.length) {
-      const allowed = config.enabledLlmServices.some((s) => s === service.name || s === service.title);
-      if (!allowed) {
-        ctx.status = 403;
-        ctx.body = (0, import_openai_format.toOpenAIError)(
-          403,
-          `LLM service '${service.title || service.name}' is not enabled for API access`,
-          "invalid_request_error",
-          "model_not_available"
-        );
-        return;
-      }
-    }
+    globalEnabledServices = (config == null ? void 0 : config.enabledLlmServices) ?? [];
   } catch {
   }
+  if (!await (0, import_user_permissions.enforceModelAccess)(ctx, globalEnabledServices, service, modelId)) {
+    return;
+  }
   const aiPlugin = ctx.app.pm.get("ai");
   if (!aiPlugin) {
     ctx.status = 500;

package/dist/server/routes/models.js

@@ -26,11 +26,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var models_exports = {};
 __export(models_exports, {
+  buildModelObject: () => buildModelObject,
   handleGetModel: () => handleGetModel,
   handleListModels: () => handleListModels
 });
 module.exports = __toCommonJS(models_exports);
 var import_openai_format = require("../utils/openai-format");
+var import_user_permissions = require("../utils/user-permissions");
 async function handleListModels(ctx, plugin) {
   var _a;
   try {
@@ -49,21 +51,25 @@ async function handleListModels(ctx, plugin) {
       filter,
       sort: "sort"
     });
+    const scope = await (0, import_user_permissions.resolveUserAccessScope)(ctx);
+    if (scope.lookupFailed) {
+      respondPermissionCheckFailed(ctx);
+      return;
+    }
+    const metadataMap = await loadModelMetadata(ctx);
     const now = Math.floor(Date.now() / 1e3);
     const models = [];
     for (const service of services) {
       if (service.enabled === false) continue;
+      if (!(0, import_user_permissions.isServiceAllowed)(scope, config == null ? void 0 : config.enabledLlmServices, service)) continue;
       const enabledModels = resolveEnabledModels(service);
       const serviceLabel = service.title || service.name;
       for (const model of enabledModels) {
-        models.push({
-          // Use "serviceName/modelId" format so the ID can be used directly in
-          // POST /v1/chat/completions without ambiguity in multi-service setups.
-          id: `${service.name}/${model.value}`,
-          object: "model",
-          created: now,
-          owned_by: serviceLabel
-        });
+        const fullId = `${service.name}/${model.value}`;
+        if (!(0, import_user_permissions.isModelAllowed)(scope, fullId)) continue;
+        const meta = metadataMap.get(fullId);
+        if (meta && meta.enabled === false) continue;
+        models.push(buildModelObject(fullId, now, serviceLabel, meta));
       }
     }
     ctx.status = 200;
@@ -89,21 +95,26 @@ async function handleGetModel(ctx, modelId, plugin) {
       filter,
       sort: "sort"
     });
+    const scope = await (0, import_user_permissions.resolveUserAccessScope)(ctx);
+    if (scope.lookupFailed) {
+      respondPermissionCheckFailed(ctx);
+      return;
+    }
+    const metadataMap = await loadModelMetadata(ctx);
     const now = Math.floor(Date.now() / 1e3);
     let found = null;
     for (const service of services) {
       if (service.enabled === false) continue;
+      if (!(0, import_user_permissions.isServiceAllowed)(scope, config == null ? void 0 : 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 (fullId === modelId || model.value === modelId) {
-          found = {
-            id: fullId,
-            object: "model",
-            created: now,
-            owned_by: serviceLabel
-          };
+          if (!(0, import_user_permissions.isModelAllowed)(scope, fullId)) continue;
+          const meta = metadataMap.get(fullId);
+          if (meta && meta.enabled === false) continue;
+          found = buildModelObject(fullId, now, serviceLabel, meta);
           break;
         }
       }
@@ -122,6 +133,70 @@ async function handleGetModel(ctx, modelId, plugin) {
     ctx.body = (0, import_openai_format.toOpenAIError)(500, "Failed to retrieve model", "server_error");
   }
 }
+function respondPermissionCheckFailed(ctx) {
+  ctx.status = 503;
+  ctx.body = (0, import_openai_format.toOpenAIError)(
+    503,
+    "Unable to verify LLM permissions for this user. Please retry shortly.",
+    "service_unavailable",
+    "permission_check_failed"
+  );
+}
+async function loadModelMetadata(ctx) {
+  var _a, _b;
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const rows = await ctx.db.getRepository("aiApiModelMetadata").find();
+    for (const row of rows) {
+      const service = row.get("llmService");
+      const model = row.get("model");
+      if (!service || !model) continue;
+      map.set(`${service}/${model}`, {
+        contextWindow: row.get("contextWindow"),
+        maxCompletionTokens: row.get("maxCompletionTokens"),
+        ownedByOverride: row.get("ownedByOverride"),
+        displayName: row.get("displayName"),
+        description: row.get("description"),
+        enabled: row.get("enabled")
+      });
+    }
+  } catch (err) {
+    (_b = (_a = ctx.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "AI API model metadata unavailable, skipping overrides:", err);
+  }
+  return map;
+}
+function buildModelObject(fullId, created, serviceLabel, meta) {
+  const model = {
+    id: fullId,
+    object: "model",
+    created,
+    owned_by: (meta == null ? void 0 : meta.ownedByOverride) || serviceLabel
+  };
+  const contextWindow = toPositiveInt(meta == null ? void 0 : meta.contextWindow);
+  if (contextWindow !== null) {
+    model.context_window = contextWindow;
+    model.context_length = contextWindow;
+  }
+  const maxCompletionTokens = toPositiveInt(meta == null ? void 0 : meta.maxCompletionTokens);
+  if (maxCompletionTokens !== null) {
+    model.max_completion_tokens = maxCompletionTokens;
+  }
+  if (meta == null ? void 0 : meta.displayName) {
+    model.display_name = meta.displayName;
+    model.name = meta.displayName;
+  }
+  if (meta == null ? void 0 : meta.description) {
+    model.description = meta.description;
+  }
+  if (meta) {
+    model.active = meta.enabled !== false;
+  }
+  return model;
+}
+function toPositiveInt(value) {
+  const n = Number(value);
+  return Number.isSafeInteger(n) && n > 0 ? n : null;
+}
 async function getPluginConfig(ctx) {
   return ctx.db.getRepository("aiApiConfig").findOne();
 }
@@ -142,16 +217,23 @@ function resolveEnabledModels(service) {
   return getRecommendedModelsForProvider(service.provider);
 }
 function getRecommendedModelsForProvider(provider) {
-  try {
-    const { getRecommendedModels } = require("@nocobase/plugin-ai/src/common/recommended-models");
-    const models = getRecommendedModels(provider);
-    return Array.isArray(models) ? models : [];
-  } catch {
-    return [];
+  const modulePaths = [
+    "@nocobase/plugin-ai/dist/common/recommended-models",
+    "@nocobase/plugin-ai/src/common/recommended-models"
+  ];
+  for (const modulePath of modulePaths) {
+    try {
+      const { getRecommendedModels } = require(modulePath);
+      const models = getRecommendedModels(provider);
+      return Array.isArray(models) ? models : [];
+    } catch {
+    }
   }
+  return [];
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildModelObject,
   handleGetModel,
   handleListModels
 });

package/dist/server/routes/router.js

@@ -36,7 +36,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var router_exports = {};
 __export(router_exports, {
-  createAiLlmRouter: () => createAiLlmRouter
+  AI_LLM_PREFIX: () => AI_LLM_PREFIX,
+  MAX_REQUEST_BODY_MB_LIMIT: () => MAX_REQUEST_BODY_MB_LIMIT,
+  createAiLlmRouter: () => createAiLlmRouter,
+  getRawBody: () => getRawBody,
+  normalizeMaxRequestBodyMb: () => normalizeMaxRequestBodyMb
 });
 module.exports = __toCommonJS(router_exports);
 var import_crypto = __toESM(require("crypto"));
@@ -52,7 +56,9 @@ var import_role_permission = require("../middleware/role-permission");
 var import_usage = require("../usage");
 var import_streaming = require("../utils/streaming");
 var import_billing = require("../billing");
+var import_app_observability = require("../utils/app-observability");
 const API_PREFIX = "/api/ai-llm/v1";
+const AI_LLM_PREFIX = API_PREFIX;
 function createAiLlmRouter(plugin) {
   const checkRateLimit = (0, import_rate_limit.createRateLimitMiddleware)(plugin.rateLimiter);
   return async (ctx, next) => {
@@ -77,18 +83,6 @@ function createAiLlmRouter(plugin) {
     }
     const requestId = `req-${import_crypto.default.randomBytes(12).toString("hex")}`;
     ctx.set("X-Request-Id", requestId);
-    if (method === "POST" && !ctx.request.body) {
-      try {
-        const rawBody = await getRawBody(ctx);
-        ctx.request.body = JSON.parse(rawBody);
-      } catch (bodyErr) {
-        const status = bodyErr && typeof bodyErr === "object" && "statusCode" in bodyErr && bodyErr.statusCode === 413 ? 413 : 400;
-        const message = status === 413 ? "Request body too large (max 10 MB)" : "Invalid JSON in request body";
-        ctx.status = status;
-        ctx.body = (0, import_openai_format.toOpenAIError)(status, message, "invalid_request_error");
-        return;
-      }
-    }
     const isAuth = await (0, import_auth.authenticateBearer)(ctx);
     if (!isAuth) {
       logRequest(ctx, requestId, "-", "auth_failed", 0);
@@ -104,6 +98,29 @@ function createAiLlmRouter(plugin) {
       logRequest(ctx, requestId, "-", "rate_limited", 0);
       return;
     }
+    if (method === "POST" && !ctx.request.body) {
+      const maxBodyBytes = await resolveMaxBodyBytes(ctx);
+      const declaredLength = Number(ctx.get("Content-Length"));
+      if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+        respondBodyTooLarge(ctx, maxBodyBytes);
+        logRequest(ctx, requestId, "-", "body_too_large", 0);
+        return;
+      }
+      try {
+        const rawBody = await getRawBody(ctx, maxBodyBytes);
+        ctx.request.body = JSON.parse(rawBody);
+      } catch (bodyErr) {
+        const tooLarge = bodyErr && typeof bodyErr === "object" && "statusCode" in bodyErr && bodyErr.statusCode === 413;
+        if (tooLarge) {
+          respondBodyTooLarge(ctx, maxBodyBytes);
+          logRequest(ctx, requestId, "-", "body_too_large", 0);
+          return;
+        }
+        ctx.status = 400;
+        ctx.body = (0, import_openai_format.toOpenAIError)(400, "Invalid JSON in request body", "invalid_request_error");
+        return;
+      }
+    }
     const requestBody = ctx.request.body || {};
     const model = requestBody.model === void 0 || requestBody.model === null ? "-" : String(requestBody.model);
     const isUsageEndpoint = method === "POST" && (subPath === "/chat/completions" || subPath === "/completions" || subPath === "/embeddings");
@@ -121,6 +138,16 @@ function createAiLlmRouter(plugin) {
       };
     }
     const t0 = Date.now();
+    if (isUsageEndpoint) {
+      const service = subPath === "/embeddings" ? "llm.embedding" : resolvedMode === "agent" ? "llm.agent" : subPath === "/completions" ? "llm.completion" : "llm.chat";
+      (0, import_app_observability.startAiApiObservation)(ctx, {
+        service,
+        operation: subPath,
+        streaming,
+        model: model === "-" ? void 0 : model,
+        mode: resolvedMode
+      });
+    }
     let usageId;
     try {
       usageId = isUsageEndpoint ? await (0, import_usage.startUsageRecord)(ctx, requestId, subPath, model, streaming, resolvedMode) : void 0;
@@ -225,24 +252,65 @@ function createAiLlmRouter(plugin) {
           ctx.log.error("AI API quota reservation could not be finalized:", billingError);
         }
       }
+      if (isUsageEndpoint) {
+        const streamResult = ctx.state.aiApiStreamResult;
+        (0, import_app_observability.finishAiApiObservation)(ctx, {
+          status: (streamResult == null ? void 0 : streamResult.errorCode) === "client_disconnected" ? "cancelled" : streamResult ? streamResult.succeeded ? "succeeded" : "failed" : ctx.status >= 200 && ctx.status < 400 ? "succeeded" : ctx.status >= 500 ? "failed" : "rejected",
+          errorCode: streamResult == null ? void 0 : streamResult.errorCode
+        });
+      }
     }
   };
 }
-const MAX_BODY_BYTES = 10 * 1024 * 1024;
-function getRawBody(ctx) {
+const DEFAULT_MAX_BODY_MB = 10;
+const MAX_REQUEST_BODY_MB_LIMIT = 100;
+function normalizeMaxRequestBodyMb(value) {
+  const mb = Number(value);
+  if (!Number.isSafeInteger(mb) || mb <= 0) return DEFAULT_MAX_BODY_MB;
+  return Math.min(mb, MAX_REQUEST_BODY_MB_LIMIT);
+}
+async function resolveMaxBodyBytes(ctx) {
+  var _a, _b;
+  let configuredMb;
+  try {
+    const config = await ctx.db.getRepository("aiApiConfig").findOne();
+    configuredMb = config == null ? void 0 : config.get("maxRequestBodyMb");
+  } catch (err) {
+    (_b = (_a = ctx.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, "AI API: could not read maxRequestBodyMb, using default:", err);
+  }
+  return normalizeMaxRequestBodyMb(configuredMb) * 1024 * 1024;
+}
+function formatMb(bytes) {
+  return `${Math.round(bytes / (1024 * 1024))} MB`;
+}
+function respondBodyTooLarge(ctx, maxBodyBytes) {
+  ctx.status = 413;
+  ctx.body = (0, import_openai_format.toOpenAIError)(
+    413,
+    `Request body too large (max ${formatMb(maxBodyBytes)}). Inline base64 images inflate payloads by ~33%; raise "Max request body size" in Settings \u2192 AI API Gateway if needed.`,
+    "invalid_request_error"
+  );
+}
+function getRawBody(ctx, maxBodyBytes) {
   return new Promise((resolve, reject) => {
-    let body = "";
+    const chunks = [];
     let byteCount = 0;
+    let aborted = false;
     ctx.req.on("data", (chunk) => {
+      if (aborted) return;
       byteCount += chunk.length;
-      if (byteCount > MAX_BODY_BYTES) {
-        ctx.req.destroy();
-        reject(Object.assign(new Error("Request body too large (max 10 MB)"), { statusCode: 413 }));
+      if (byteCount > maxBodyBytes) {
+        aborted = true;
+        chunks.length = 0;
+        ctx.req.resume();
+        reject(Object.assign(new Error(`Request body too large (max ${formatMb(maxBodyBytes)})`), { statusCode: 413 }));
         return;
       }
-      body += chunk.toString();
+      chunks.push(chunk);
+    });
+    ctx.req.on("end", () => {
+      if (!aborted) resolve(Buffer.concat(chunks).toString("utf8"));
     });
-    ctx.req.on("end", () => resolve(body));
     ctx.req.on("error", reject);
   });
 }
@@ -277,5 +345,9 @@ function logRequest(ctx, requestId, model, status, durationMs) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createAiLlmRouter
+  AI_LLM_PREFIX,
+  MAX_REQUEST_BODY_MB_LIMIT,
+  createAiLlmRouter,
+  getRawBody,
+  normalizeMaxRequestBodyMb
 });

package/dist/server/usage.js

@@ -35,6 +35,7 @@ __export(usage_exports, {
 });
 module.exports = __toCommonJS(usage_exports);
 var import_billing = require("./billing");
+var import_app_observability = require("./utils/app-observability");
 function getAiApiState(ctx) {
   return ctx.state;
 }
@@ -60,6 +61,7 @@ function normalizeUsage(value) {
 function setAiApiUsageResult(ctx, value, metadata = {}) {
   const usage = normalizeUsage(value);
   getAiApiState(ctx).aiApiUsageResult = usage ? { source: "provider", usage, ...metadata } : { source: "unavailable", ...metadata };
+  (0, import_app_observability.addAiApiUsage)(ctx, usage);
   return usage;
 }
 function setAiApiUsageUnavailable(ctx, gatewayResponseId) {

package/dist/server/utils/app-observability.js

@@ -0,0 +1,110 @@
+/**
+ * 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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var app_observability_exports = {};
+__export(app_observability_exports, {
+  addAiApiUsage: () => addAiApiUsage,
+  finishAiApiObservation: () => finishAiApiObservation,
+  markAiApiFirstProviderOutput: () => markAiApiFirstProviderOutput,
+  setAiApiObservationOutcome: () => setAiApiObservationOutcome,
+  startAiApiObservation: () => startAiApiObservation
+});
+module.exports = __toCommonJS(app_observability_exports);
+const CONTRACT_SYMBOL = Symbol.for("nocobase.app-observability.contract");
+const NOOP_HANDLE = {
+  markFirstByte() {
+  },
+  addInputTokens() {
+  },
+  addOutputTokens() {
+  },
+  finish() {
+  }
+};
+function state(ctx) {
+  return ctx.state;
+}
+function safely(ctx, callback) {
+  var _a, _b, _c;
+  try {
+    callback();
+  } catch (error) {
+    (_c = (_b = (_a = ctx.app) == null ? void 0 : _a.logger) == null ? void 0 : _b.warn) == null ? void 0 : _c.call(_b, "[ai-api] App observability callback failed", { error });
+  }
+}
+function startAiApiObservation(ctx, input) {
+  let handle = NOOP_HANDLE;
+  safely(ctx, () => {
+    const contract = ctx.app[CONTRACT_SYMBOL];
+    if (!contract || typeof contract.start !== "function") return;
+    const candidate = contract.start({
+      service: input.service,
+      operation: input.operation,
+      streaming: input.streaming,
+      attributes: {
+        mode: input.mode,
+        endpoint: input.operation,
+        ...input.model ? { model: input.model } : {}
+      }
+    });
+    if (candidate && typeof candidate.finish === "function") handle = candidate;
+  });
+  state(ctx).aiApiObservabilityHandle = handle;
+}
+function markAiApiFirstProviderOutput(ctx) {
+  safely(ctx, () => {
+    var _a;
+    return (_a = state(ctx).aiApiObservabilityHandle) == null ? void 0 : _a.markFirstByte();
+  });
+}
+function addAiApiUsage(ctx, usage) {
+  if (!usage) return;
+  safely(ctx, () => {
+    const handle = state(ctx).aiApiObservabilityHandle;
+    if (usage.prompt_tokens !== null) handle == null ? void 0 : handle.addInputTokens(usage.prompt_tokens);
+    if (usage.completion_tokens !== null) handle == null ? void 0 : handle.addOutputTokens(usage.completion_tokens);
+  });
+}
+function setAiApiObservationOutcome(ctx, outcome) {
+  state(ctx).aiApiObservabilityOutcome = outcome;
+}
+function finishAiApiObservation(ctx, fallback) {
+  const current = state(ctx);
+  const handle = current.aiApiObservabilityHandle;
+  if (!handle) return;
+  current.aiApiObservabilityHandle = void 0;
+  const outcome = current.aiApiObservabilityOutcome ?? fallback;
+  current.aiApiObservabilityOutcome = void 0;
+  safely(ctx, () => handle.finish(outcome));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAiApiUsage,
+  finishAiApiObservation,
+  markAiApiFirstProviderOutput,
+  setAiApiObservationOutcome,
+  startAiApiObservation
+});