plugin-ai-api 1.1.1 → 1.1.2

package/dist/server/usage.js

@@ -60,6 +60,20 @@ function extractPromptCacheTokens(source) {
   if (typeof source.cache_read === "number") return source.cache_read;
   return null;
 }
+function extractReasoningTokens(source) {
+  const detailCandidates = [
+    source.output_token_details,
+    source.output_tokens_details,
+    source.completion_tokens_details
+  ];
+  for (const details of detailCandidates) {
+    if (!details || typeof details !== "object") continue;
+    const record = details;
+    const value = normalizeTokenCount(record.reasoning ?? record.reasoning_tokens);
+    if (value !== null) return value;
+  }
+  return normalizeTokenCount(source.reasoning_tokens ?? source.reasoningTokens);
+}
 function normalizeUsage(value) {
   if (!value || typeof value !== "object") return void 0;
   const source = value;
@@ -77,7 +91,8 @@ function normalizeUsage(value) {
     // Keep normalizeUsage idempotent: streaming routes normalize the chunk
     // usage once and hand the result to setAiApiUsageResult, which normalizes
     // again — an already-extracted prompt_cache_tokens must survive that pass.
-    prompt_cache_tokens: extractPromptCacheTokens(source) ?? normalizeTokenCount(source.prompt_cache_tokens)
+    prompt_cache_tokens: extractPromptCacheTokens(source) ?? normalizeTokenCount(source.prompt_cache_tokens),
+    reasoning_tokens: extractReasoningTokens(source) ?? normalizeTokenCount(source.reasoning_tokens)
   };
 }
 function setAiApiUsageResult(ctx, value, metadata = {}, responseMetadata) {
@@ -126,7 +141,9 @@ async function startUsageRecord(ctx, requestId, endpoint, model, streaming, mode
     values: {
       requestId,
       userId,
-      roleName: state.currentRole || ((_b = state.currentRoles) == null ? void 0 : _b[0]) || "unknown",
+      // When several roles granted access (union semantics), record all of them so the
+      // audit trail shows the full set, not just the first role in the list.
+      roleName: ((_b = state.currentRoles) == null ? void 0 : _b.length) ? state.currentRoles.join(",") : state.currentRole || "unknown",
       authType: state.aiApiAuthType || (oauth ? "oidc" : "unknown"),
       oauthClientId: oauth == null ? void 0 : oauth.clientId,
       oauthSubject: oauth == null ? void 0 : oauth.subject,
@@ -141,7 +158,7 @@ async function startUsageRecord(ctx, requestId, endpoint, model, streaming, mode
         messageCount: messages == null ? void 0 : messages.length,
         promptCount,
         embeddingInputCount,
-        requestedMaxTokens: body.max_completion_tokens ?? body.max_tokens
+        requestedMaxTokens: body.max_output_tokens ?? body.max_completion_tokens ?? body.max_tokens
       }
     }
   });
@@ -184,7 +201,11 @@ async function finishUsageRecord(ctx, id, startedAt, status) {
     durationMs: Date.now() - startedAt,
     responseMetadata: {
       usageSource: usageResult.source,
-      ...gatewayResponseId ? { gatewayResponseId } : {}
+      ...gatewayResponseId ? { gatewayResponseId } : {},
+      // When the request went through a virtual alias, keep both the alias and why
+      // it routed there; resolvedModel (from billing state) already holds the concrete model.
+      ...state.aiApiVirtualModel ? { virtualModel: state.aiApiVirtualModel } : {},
+      ...state.aiApiRoutingReason ? { routingReason: state.aiApiRoutingReason } : {}
     }
   };
   await ctx.db.getRepository("aiApiUsageRecords").update({ filterByTk: id, values });

package/dist/server/utils/direct-llm-context.js

@@ -261,7 +261,7 @@ function resolveReservedOutputTokens(options, metadata) {
 async function prepareDirectLlmContext(ctx, options) {
   const [metadata, behavior] = await Promise.all([
     loadModelMetadata(ctx, options.serviceName, options.modelId),
-    resolveOverflowBehavior(ctx)
+    options.overflowBehavior ? Promise.resolve(options.overflowBehavior) : resolveOverflowBehavior(ctx)
   ]);
   const reservedOutputTokens = resolveReservedOutputTokens(options, metadata);
   const inputTokenBudget = metadata.contextWindow - reservedOutputTokens;

package/dist/server/utils/resolve-service.js

@@ -27,6 +27,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var resolve_service_exports = {};
 __export(resolve_service_exports, {
   resolveLlmService: () => resolveLlmService,
+  resolveModelReference: () => resolveModelReference,
   resolveModelString: () => resolveModelString
 });
 module.exports = __toCommonJS(resolve_service_exports);
@@ -74,8 +75,31 @@ async function resolveModelString(ctx, modelString) {
   }
   return null;
 }
+async function resolveModelReference(ctx, reference) {
+  const repo = ctx.db.getRepository("llmServices");
+  const slashPositions = [];
+  for (let i = 0; i < reference.length; i++) {
+    if (reference[i] === "/") {
+      slashPositions.push(i);
+    }
+  }
+  for (const pos of slashPositions) {
+    const serviceKey = reference.substring(0, pos);
+    const modelId = reference.substring(pos + 1);
+    if (!serviceKey || !modelId) continue;
+    let service = await repo.findOne({ filter: { name: serviceKey } });
+    if (!service) {
+      service = await repo.findOne({ filter: { title: serviceKey } });
+    }
+    if (service) {
+      return { service, modelId };
+    }
+  }
+  return null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   resolveLlmService,
+  resolveModelReference,
   resolveModelString
 });

package/dist/server/utils/response-store.js

@@ -0,0 +1,138 @@
+/**
+ * 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 response_store_exports = {};
+__export(response_store_exports, {
+  RESPONSE_RETENTION_MS: () => RESPONSE_RETENTION_MS,
+  cleanupExpiredResponseRecords: () => cleanupExpiredResponseRecords,
+  deleteResponseRecord: () => deleteResponseRecord,
+  getResponseRecord: () => getResponseRecord,
+  loadConversationChain: () => loadConversationChain,
+  storeResponseRecord: () => storeResponseRecord
+});
+module.exports = __toCommonJS(response_store_exports);
+var import_responses_format = require("./responses-format");
+const RETENTION_DAYS = 30;
+const MS_PER_DAY = 24 * 60 * 60 * 1e3;
+const RESPONSE_RETENTION_MS = RETENTION_DAYS * MS_PER_DAY;
+function valueOf(model, key) {
+  if (!model) return void 0;
+  if (typeof model.get === "function") {
+    return model.get(key);
+  }
+  return model[key];
+}
+function isExpired(value) {
+  if (value === void 0 || value === null || value === "") return true;
+  const timestamp = value instanceof Date ? value.getTime() : new Date(String(value)).getTime();
+  return !Number.isFinite(timestamp) || timestamp <= Date.now();
+}
+async function storeResponseRecord(ctx, response, requestBody, userId) {
+  if (requestBody.store === false) return;
+  await ctx.db.getRepository("aiApiResponseRecords").create({
+    values: {
+      responseId: response.id,
+      userId,
+      model: response.model,
+      input: requestBody.input,
+      output: response,
+      previousResponseId: response.previous_response_id,
+      metadata: response.metadata,
+      expiresAt: new Date(Date.now() + RESPONSE_RETENTION_MS)
+    }
+  });
+}
+async function getResponseRecord(ctx, responseId, userId) {
+  const row = await ctx.db.getRepository("aiApiResponseRecords").findOne({
+    filter: { responseId, userId }
+  });
+  if (!row || isExpired(valueOf(row, "expiresAt"))) return null;
+  return {
+    id: valueOf(row, "id"),
+    responseId: valueOf(row, "responseId"),
+    userId: valueOf(row, "userId"),
+    model: valueOf(row, "model"),
+    input: valueOf(row, "input"),
+    output: valueOf(row, "output"),
+    previousResponseId: valueOf(row, "previousResponseId") ?? void 0,
+    metadata: valueOf(row, "metadata"),
+    expiresAt: valueOf(row, "expiresAt")
+  };
+}
+function responseOutputToMessages(output) {
+  return (0, import_responses_format.responsesInputToMessages)(output.output);
+}
+async function loadConversationChain(ctx, responseId, userId, maxDepth = 100) {
+  const records = [];
+  const visited = /* @__PURE__ */ new Set();
+  let currentId = responseId;
+  while (currentId) {
+    if (records.length >= maxDepth || visited.has(currentId)) return null;
+    visited.add(currentId);
+    const record = await getResponseRecord(ctx, currentId, userId);
+    if (!record) return null;
+    records.unshift(record);
+    currentId = record.previousResponseId;
+  }
+  return records.flatMap((record) => [
+    ...(0, import_responses_format.responsesInputToMessages)(record.input),
+    ...responseOutputToMessages(record.output)
+  ]);
+}
+async function cleanupExpiredResponseRecords(ctx) {
+  const repo = ctx.db.getRepository("aiApiResponseRecords");
+  const now = /* @__PURE__ */ new Date();
+  let deleted = 0;
+  for (; ; ) {
+    const expired = await repo.find({
+      filter: { expiresAt: { $lt: now } },
+      fields: ["id"],
+      limit: 1e3,
+      sort: "id"
+    });
+    const ids = expired.map((record) => record.get("id"));
+    if (ids.length === 0) return deleted;
+    const count = await repo.destroy({ filterByTk: ids, individualHooks: false });
+    if (typeof count === "number") deleted += count;
+    else deleted += ids.length;
+    if (count === 0) return deleted;
+  }
+}
+async function deleteResponseRecord(ctx, responseId, userId) {
+  const record = await getResponseRecord(ctx, responseId, userId);
+  if (!record) return false;
+  await ctx.db.getRepository("aiApiResponseRecords").destroy({ filterByTk: record.id });
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RESPONSE_RETENTION_MS,
+  cleanupExpiredResponseRecords,
+  deleteResponseRecord,
+  getResponseRecord,
+  loadConversationChain,
+  storeResponseRecord
+});