plugin-ai-api 1.0.21 → 1.0.24

package/dist/server/routes/chat-completions.js

@@ -38,8 +38,10 @@ var import_openai_format = require("../utils/openai-format");
 var import_resolve_service = require("../utils/resolve-service");
 var import_streaming = require("../utils/streaming");
 var import_role_permission = require("../middleware/role-permission");
+var import_user_permissions = require("../utils/user-permissions");
 var import_usage = require("../usage");
 var import_billing = require("../billing");
+var import_direct_llm_context = require("../utils/direct-llm-context");
 var import_app_observability = require("../utils/app-observability");
 async function handleChatCompletions(ctx, plugin) {
   var _a;
@@ -117,20 +119,8 @@ async function handleChatCompletions(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) {
@@ -138,8 +128,14 @@ async function handleChatCompletions(ctx, plugin) {
       ctx.body = (0, import_openai_format.toOpenAIError)(500, `Provider '${service.provider}' not registered`, "server_error");
       return;
     }
-    await (0, import_billing.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 = {
       model: modelId,
       llmService: service.name
@@ -151,12 +147,6 @@ async function handleChatCompletions(ctx, plugin) {
     if (body.frequency_penalty !== void 0) modelOptions.frequencyPenalty = body.frequency_penalty;
     if (body.presence_penalty !== void 0) modelOptions.presencePenalty = body.presence_penalty;
     if (body.stop !== void 0) modelOptions.stop = body.stop;
-    const Provider = providerMeta.provider;
-    const provider = new Provider({
-      app: ctx.app,
-      serviceOptions: service.options,
-      modelOptions
-    });
     let systemPrompt = "";
     if (config == null ? void 0 : config.defaultAiEmployee) {
       if (!(0, import_role_permission.checkEmployeeAccess)(ctx, config.defaultAiEmployee)) {
@@ -176,11 +166,27 @@ async function handleChatCompletions(ctx, plugin) {
         systemPrompt = employee.about || employee.defaultPrompt || "";
       }
     }
-    const messages = [...body.messages];
+    let messages = [...body.messages];
     const hasSystemMessage = messages.some((m) => m.role === "system");
     if (systemPrompt && !hasSystemMessage) {
       messages.unshift({ role: "system", content: systemPrompt });
     }
+    const preparedContext = await (0, import_direct_llm_context.prepareDirectLlmContext)(ctx, {
+      serviceName: service.name,
+      modelId,
+      messages,
+      tools: body.tools,
+      maxCompletionTokens: body.max_completion_tokens,
+      maxTokens: body.max_tokens
+    });
+    messages = preparedContext.messages;
+    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
+    const Provider = providerMeta.provider;
+    const provider = new Provider({
+      app: ctx.app,
+      serviceOptions: service.options,
+      modelOptions
+    });
     const langchainMessages = messages.map((msg) => {
       const role = msg.role === "assistant" ? "ai" : msg.role;
       const content = normalizeMessageContent(msg.content);
@@ -223,15 +229,16 @@ async function handleChatCompletions(ctx, plugin) {
     }
   } catch (err) {
     ctx.log.error("AI API chat completions error:", err);
-    if (!ctx.res.headersSent) {
+    if (!((_a = ctx.res) == null ? void 0 : _a.headersSent)) {
       const isQuotaError = err instanceof import_billing.AiApiQuotaError;
-      ctx.status = isQuotaError ? 429 : 500;
+      const isContextError = err instanceof import_direct_llm_context.DirectLlmContextError;
+      ctx.status = isQuotaError ? 429 : isContextError ? 400 : 500;
       if (isQuotaError) ctx.set("X-RateLimit-Reason", err.code);
       ctx.body = (0, import_openai_format.toOpenAIError)(
         ctx.status,
         getErrorMessage(err, "Internal server error"),
-        isQuotaError ? "quota_error" : "server_error",
-        isQuotaError ? err.code : void 0
+        isQuotaError ? "quota_error" : isContextError ? "invalid_request_error" : "server_error",
+        isQuotaError || isContextError ? err.code : void 0
       );
     }
   }
@@ -312,7 +319,13 @@ async function handleStreamingCompletion(ctx, chatModel, messages, completionId,
         finishReason = "tool_calls";
         await (0, import_streaming.writeResponse)(
           ctx,
-          (0, import_openai_format.formatSSE)((0, import_openai_format.toOpenAIStreamChunk)({ id: completionId, model: modelName, delta: { tool_calls: toolCallChunks } }))
+          (0, import_openai_format.formatSSE)(
+            (0, import_openai_format.toOpenAIStreamChunk)({
+              id: completionId,
+              model: modelName,
+              delta: { tool_calls: toolCallChunks }
+            })
+          )
         );
       }
       if (chunk.usage_metadata) {
@@ -331,6 +344,18 @@ async function handleStreamingCompletion(ctx, chatModel, messages, completionId,
         })
       )
     );
+    if (usage) {
+      await (0, import_streaming.writeResponse)(
+        ctx,
+        (0, import_openai_format.formatSSE)(
+          (0, import_openai_format.toOpenAIUsageChunk)({
+            id: completionId,
+            model: modelName,
+            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 };

package/dist/server/routes/completions.js

@@ -31,9 +31,11 @@ __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_direct_llm_context = require("../utils/direct-llm-context");
 var import_app_observability = require("../utils/app-observability");
 async function handleCompletions(ctx, plugin) {
   var _a;
@@ -89,20 +91,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) {
@@ -110,7 +100,6 @@ async function handleCompletions(ctx, plugin) {
       ctx.body = (0, import_openai_format.toOpenAIError)(500, `Provider '${service.provider}' not registered`, "server_error");
       return;
     }
-    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
     const modelOptions = {
       model: modelId,
       llmService: service.name
@@ -119,14 +108,8 @@ async function handleCompletions(ctx, plugin) {
     if (body.top_p !== void 0) modelOptions.topP = body.top_p;
     if (body.max_tokens !== void 0) modelOptions.maxTokens = body.max_tokens;
     if (body.stop !== void 0) modelOptions.stop = body.stop;
-    const Provider = providerMeta.provider;
-    const provider = new Provider({
-      app: ctx.app,
-      serviceOptions: service.options,
-      modelOptions
-    });
     const prompt = typeof body.prompt === "string" ? body.prompt : Array.isArray(body.prompt) ? body.prompt.join("\n") : String(body.prompt);
-    const langchainMessages = [];
+    const messages = [];
     if (config == null ? void 0 : config.defaultAiEmployee) {
       const employee = await ctx.db.getRepository("aiEmployees").findOne({
         filter: { username: config.defaultAiEmployee }
@@ -134,30 +117,55 @@ async function handleCompletions(ctx, plugin) {
       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 (0, import_direct_llm_context.prepareDirectLlmContext)(ctx, {
+      serviceName: service.name,
+      modelId,
+      messages,
+      maxTokens: body.max_tokens
+    });
+    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
+    const Provider = providerMeta.provider;
+    const provider = new Provider({
+      app: ctx.app,
+      serviceOptions: service.options,
+      modelOptions
+    });
+    const langchainMessages = preparedContext.messages.map((message) => [
+      message.role === "user" ? "human" : message.role,
+      String(message.content ?? "")
+    ]);
     const completionId = (0, import_openai_format.generateCompletionId)().replace("chatcmpl-", "cmpl-");
     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);
     }
   } catch (err) {
     ctx.log.error("AI API completions error:", err);
-    if (!ctx.res.headersSent) {
+    if (!((_a = ctx.res) == null ? void 0 : _a.headersSent)) {
       const isQuotaError = err instanceof import_billing.AiApiQuotaError;
-      ctx.status = isQuotaError ? 429 : 500;
+      const isContextError = err instanceof import_direct_llm_context.DirectLlmContextError;
+      ctx.status = isQuotaError ? 429 : isContextError ? 400 : 500;
       if (isQuotaError) ctx.set("X-RateLimit-Reason", err.code);
       ctx.body = (0, import_openai_format.toOpenAIError)(
         ctx.status,
         getErrorMessage(err, "Internal server error"),
-        isQuotaError ? "quota_error" : "server_error",
-        isQuotaError ? err.code : void 0
+        isQuotaError ? "quota_error" : isContextError ? "invalid_request_error" : "server_error",
+        isQuotaError || isContextError ? err.code : void 0
       );
     }
   }
@@ -193,7 +201,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",
@@ -205,7 +213,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 = "";
@@ -232,7 +243,8 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
                 logprobs: null,
                 finish_reason: null
               }
-            ]
+            ],
+            usage: null
           })
         );
       }
@@ -256,9 +268,23 @@ 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 };

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

@@ -32,6 +32,7 @@ __export(models_exports, {
 });
 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 {
@@ -50,15 +51,22 @@ 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) {
         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));
@@ -87,16 +95,23 @@ 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) {
+          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);
@@ -118,6 +133,15 @@ 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();

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

@@ -0,0 +1,184 @@
+/**
+ * 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 direct_llm_context_exports = {};
+__export(direct_llm_context_exports, {
+  DirectLlmContextError: () => DirectLlmContextError,
+  prepareDirectLlmContext: () => prepareDirectLlmContext
+});
+module.exports = __toCommonJS(direct_llm_context_exports);
+class DirectLlmContextError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "DirectLlmContextError";
+  }
+}
+function getValue(record, key) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.get) == null ? void 0 : _a.call(record, key)) ?? (record == null ? void 0 : record[key]);
+}
+function positiveInteger(value) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function hasImageContent(value) {
+  return Array.isArray(value) && value.some(
+    (block) => typeof block === "object" && block !== null && block.type === "image_url"
+  );
+}
+function estimateValueTokens(value) {
+  if (value === void 0) return 0;
+  return Math.ceil(Buffer.byteLength(JSON.stringify(value), "utf8") / 3);
+}
+function estimateMessagesTokens(messages) {
+  return messages.reduce((total, message) => total + estimateValueTokens(message) + 4, 0);
+}
+function containsUnsupportedContent(messages) {
+  return messages.some((message) => hasImageContent(message.content));
+}
+function isInstruction(message) {
+  return message.role === "system" || message.role === "developer";
+}
+function splitTurns(messages) {
+  const fixed = [];
+  const turns = [];
+  let currentTurn;
+  for (const message of messages) {
+    if (isInstruction(message)) {
+      fixed.push(message);
+      continue;
+    }
+    if (message.role === "user" || !currentTurn) {
+      currentTurn = [message];
+      turns.push(currentTurn);
+      continue;
+    }
+    currentTurn.push(message);
+  }
+  return { fixed, turns };
+}
+function messagesWithTurns(messages, turns) {
+  const retainedMessages = new Set(turns.flat());
+  return messages.filter((message) => isInstruction(message) || retainedMessages.has(message));
+}
+async function loadModelMetadata(ctx, serviceName, modelId) {
+  const row = await ctx.db.getRepository("aiApiModelMetadata").findOne({
+    filter: { llmService: serviceName, model: modelId, enabled: true }
+  });
+  const contextWindow = positiveInteger(getValue(row, "contextWindow"));
+  const maxCompletionTokens = positiveInteger(getValue(row, "maxCompletionTokens"));
+  if (!contextWindow || !maxCompletionTokens) {
+    throw new DirectLlmContextError(
+      "model_context_metadata_not_configured",
+      `Context metadata is not configured for '${serviceName}/${modelId}'. Configure context window and max completion tokens.`
+    );
+  }
+  return { contextWindow, maxCompletionTokens };
+}
+async function resolveOverflowBehavior(ctx) {
+  var _a;
+  const userId = (_a = ctx.state.currentUser) == null ? void 0 : _a.id;
+  if (userId === null || userId === void 0) return "reject";
+  const policy = await ctx.db.getRepository("aiApiUserQuotaPolicies").findOne({
+    filter: { userId, enabled: true }
+  });
+  return getValue(policy, "contextOverflowBehavior") === "truncate" ? "truncate" : "reject";
+}
+function resolveReservedOutputTokens(options, metadata) {
+  const requested = positiveInteger(options.maxCompletionTokens ?? options.maxTokens);
+  if (requested && requested > metadata.maxCompletionTokens) {
+    throw new DirectLlmContextError(
+      "max_completion_tokens_exceeds_model_limit",
+      `Requested max completion tokens (${requested}) exceeds the model limit (${metadata.maxCompletionTokens}).`
+    );
+  }
+  return requested ?? metadata.maxCompletionTokens;
+}
+async function prepareDirectLlmContext(ctx, options) {
+  if (containsUnsupportedContent(options.messages)) {
+    throw new DirectLlmContextError(
+      "context_estimation_unsupported",
+      "Context enforcement does not support image_url content without a model-specific vision token estimator."
+    );
+  }
+  const [metadata, behavior] = await Promise.all([
+    loadModelMetadata(ctx, options.serviceName, options.modelId),
+    resolveOverflowBehavior(ctx)
+  ]);
+  const reservedOutputTokens = resolveReservedOutputTokens(options, metadata);
+  const inputTokenBudget = metadata.contextWindow - reservedOutputTokens;
+  if (inputTokenBudget <= 0) {
+    throw new DirectLlmContextError(
+      "context_length_exceeded",
+      `The model context window (${metadata.contextWindow}) leaves no input capacity after reserving ${reservedOutputTokens} output tokens.`
+    );
+  }
+  const fixedOverheadTokens = estimateValueTokens(options.tools) + (options.tools === void 0 ? 0 : 4);
+  const originalEstimate = estimateMessagesTokens(options.messages) + fixedOverheadTokens;
+  if (originalEstimate <= inputTokenBudget) {
+    return {
+      messages: options.messages,
+      estimatedInputTokens: originalEstimate,
+      inputTokenBudget,
+      reservedOutputTokens,
+      truncated: false
+    };
+  }
+  if (behavior === "reject") {
+    throw new DirectLlmContextError(
+      "context_length_exceeded",
+      `Estimated input tokens (${originalEstimate}) exceed the allowed input budget (${inputTokenBudget}).`
+    );
+  }
+  const { turns } = splitTurns(options.messages);
+  let remainingTurns = turns;
+  let messages = messagesWithTurns(options.messages, remainingTurns);
+  let estimatedInputTokens = estimateMessagesTokens(messages) + fixedOverheadTokens;
+  while (remainingTurns.length > 1 && estimatedInputTokens > inputTokenBudget) {
+    remainingTurns = remainingTurns.slice(1);
+    messages = messagesWithTurns(options.messages, remainingTurns);
+    estimatedInputTokens = estimateMessagesTokens(messages) + fixedOverheadTokens;
+  }
+  if (estimatedInputTokens > inputTokenBudget) {
+    throw new DirectLlmContextError(
+      "context_length_exceeded",
+      `The fixed instructions, tools, and newest conversation turn require ${estimatedInputTokens} input tokens, exceeding the allowed budget (${inputTokenBudget}).`
+    );
+  }
+  return {
+    messages,
+    estimatedInputTokens,
+    inputTokenBudget,
+    reservedOutputTokens,
+    truncated: messages.length !== options.messages.length
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DirectLlmContextError,
+  prepareDirectLlmContext
+});

package/dist/server/utils/openai-format.js

@@ -43,7 +43,8 @@ __export(openai_format_exports, {
   toOpenAIEmbeddingsResponse: () => toOpenAIEmbeddingsResponse,
   toOpenAIError: () => toOpenAIError,
   toOpenAIResponse: () => toOpenAIResponse,
-  toOpenAIStreamChunk: () => toOpenAIStreamChunk
+  toOpenAIStreamChunk: () => toOpenAIStreamChunk,
+  toOpenAIUsageChunk: () => toOpenAIUsageChunk
 });
 module.exports = __toCommonJS(openai_format_exports);
 var import_crypto = __toESM(require("crypto"));
@@ -116,7 +117,19 @@ function toOpenAIStreamChunk(options) {
         logprobs: null,
         finish_reason: finishReason
       }
-    ]
+    ],
+    usage: null
+  };
+}
+function toOpenAIUsageChunk(options) {
+  const { id, model, usage, object = "chat.completion.chunk" } = options;
+  return {
+    id,
+    object,
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [],
+    usage
   };
 }
 function toOpenAIEmbeddingsResponse(options) {
@@ -154,5 +167,6 @@ function formatSSEDone() {
   toOpenAIEmbeddingsResponse,
   toOpenAIError,
   toOpenAIResponse,
-  toOpenAIStreamChunk
+  toOpenAIStreamChunk,
+  toOpenAIUsageChunk
 });