plugin-ai-api 1.0.8 → 1.0.10

package/dist/server/routes/completions.js

@@ -31,6 +31,7 @@ __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_streaming = require("../utils/streaming");
 async function handleCompletions(ctx, plugin) {
   var _a;
   const body = ctx.request.body;
@@ -54,7 +55,7 @@ async function handleCompletions(ctx, plugin) {
     );
     return;
   }
-  const stream = body.stream === true;
+  const stream = (0, import_streaming.isStreamingRequested)(body.stream);
   const resolved = await (0, import_resolve_service.resolveModelString)(ctx, body.model);
   if (!resolved) {
     ctx.status = 404;
@@ -145,7 +146,7 @@ async function handleCompletions(ctx, plugin) {
     ctx.log.error("AI API completions error:", err);
     if (!ctx.res.headersSent) {
       ctx.status = 500;
-      ctx.body = (0, import_openai_format.toOpenAIError)(500, err.message || "Internal server error", "server_error");
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, getErrorMessage(err, "Internal server error"), "server_error");
     }
   }
 }
@@ -189,9 +190,12 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
     "X-Accel-Buffering": "no"
   });
   ctx.status = 200;
+  const requestAbort = (0, import_streaming.createRequestAbortController)(ctx);
+  let usage;
   try {
-    const stream = await chatModel.stream(messages);
+    const stream = await chatModel.stream(messages, { signal: requestAbort.signal });
     for await (const chunk of stream) {
+      if (requestAbort.signal.aborted) throw requestAbort.signal.reason;
       let text = "";
       if (typeof chunk.content === "string") {
         text = chunk.content;
@@ -200,7 +204,8 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
         text = (textPart == null ? void 0 : textPart.text) || "";
       }
       if (text) {
-        ctx.res.write(
+        await (0, import_streaming.writeResponse)(
+          ctx,
           (0, import_openai_format.formatSSE)({
             id: completionId,
             object: "text_completion",
@@ -218,8 +223,16 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
           })
         );
       }
+      if (chunk.usage_metadata) {
+        usage = {
+          prompt_tokens: chunk.usage_metadata.input_tokens || 0,
+          completion_tokens: chunk.usage_metadata.output_tokens || 0,
+          total_tokens: chunk.usage_metadata.total_tokens || 0
+        };
+      }
     }
-    ctx.res.write(
+    await (0, import_streaming.writeResponse)(
+      ctx,
       (0, import_openai_format.formatSSE)({
         id: completionId,
         object: "text_completion",
@@ -236,21 +249,30 @@ async function handleStreamingTextCompletion(ctx, chatModel, messages, completio
         ]
       })
     );
-    ctx.res.write((0, import_openai_format.formatSSEDone)());
+    await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSEDone)());
+    ctx.state.aiApiStreamResult = { succeeded: true, id: completionId, usage };
   } catch (err) {
     ctx.log.error("AI API completions streaming error:", err);
-    ctx.res.write(
-      (0, import_openai_format.formatSSE)({
-        error: {
-          message: err.message || "Streaming error",
-          type: "server_error"
-        }
-      })
-    );
+    if (!ctx.res.destroyed && !ctx.res.writableEnded) {
+      await (0, import_streaming.writeResponse)(
+        ctx,
+        (0, import_openai_format.formatSSE)({
+          error: {
+            message: getErrorMessage(err, "Streaming error"),
+            type: "server_error"
+          }
+        })
+      );
+    }
+    ctx.state.aiApiStreamResult = { succeeded: false, id: completionId, usage, errorCode: "stream_error" };
   } finally {
-    ctx.res.end();
+    requestAbort.dispose();
+    if (!ctx.res.writableEnded && !ctx.res.destroyed) ctx.res.end();
   }
 }
+function getErrorMessage(error, fallback) {
+  return error instanceof Error && error.message ? error.message : fallback;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   handleCompletions

package/dist/server/routes/router.js

@@ -49,11 +49,12 @@ var import_embeddings = require("./embeddings");
 var import_openai_format = require("../utils/openai-format");
 var import_rate_limit = require("../middleware/rate-limit");
 var import_role_permission = require("../middleware/role-permission");
+var import_usage = require("../usage");
 const API_PREFIX = "/api/ai-llm/v1";
 function createAiLlmRouter(plugin) {
   const checkRateLimit = (0, import_rate_limit.createRateLimitMiddleware)(plugin.rateLimiter);
   return async (ctx, next) => {
-    var _a;
+    var _a, _b, _c, _d;
     const { path, method } = ctx;
     if (!path.startsWith(API_PREFIX)) {
       return next();
@@ -100,11 +101,29 @@ function createAiLlmRouter(plugin) {
     }
     const model = ((_a = ctx.request.body) == null ? void 0 : _a.model) ?? "-";
     const t0 = Date.now();
+    let usageId;
+    try {
+      usageId = await (0, import_usage.startUsageRecord)(
+        ctx,
+        requestId,
+        subPath,
+        String(model),
+        Boolean((_b = ctx.request.body) == null ? void 0 : _b.stream)
+      );
+    } catch (usageError) {
+      ctx.log.error("AI API usage record could not be created:", usageError);
+    }
     try {
       if (method === "POST" && subPath === "/chat/completions") {
         const mode = await resolveMode(ctx);
         await (mode === "agent" ? (0, import_agent_completions.handleAgentCompletions)(ctx, plugin) : (0, import_chat_completions.handleChatCompletions)(ctx, plugin));
-        logRequest(ctx, requestId, model, "ok", Date.now() - t0);
+        logRequest(
+          ctx,
+          requestId,
+          model,
+          ((_c = ctx.state.aiApiStreamResult) == null ? void 0 : _c.succeeded) === false ? "error" : "ok",
+          Date.now() - t0
+        );
         return;
       }
       if (method === "POST" && subPath === "/embeddings") {
@@ -124,7 +143,13 @@ function createAiLlmRouter(plugin) {
         } else {
           await (0, import_completions.handleCompletions)(ctx, plugin);
         }
-        logRequest(ctx, requestId, model, "ok", Date.now() - t0);
+        logRequest(
+          ctx,
+          requestId,
+          model,
+          ((_d = ctx.state.aiApiStreamResult) == null ? void 0 : _d.succeeded) === false ? "error" : "ok",
+          Date.now() - t0
+        );
         return;
       }
       if (method === "GET" && subPath === "/models") {
@@ -164,7 +189,19 @@ function createAiLlmRouter(plugin) {
       logRequest(ctx, requestId, model, "error", Date.now() - t0);
       if (!ctx.res.headersSent) {
         ctx.status = 500;
-        ctx.body = (0, import_openai_format.toOpenAIError)(500, err.message || "Internal server error", "server_error");
+        ctx.body = (0, import_openai_format.toOpenAIError)(
+          500,
+          err instanceof Error && err.message ? err.message : "Internal server error",
+          "server_error"
+        );
+      }
+    } finally {
+      if (usageId !== void 0) {
+        try {
+          await (0, import_usage.finishUsageRecord)(ctx, usageId, t0, ctx.status >= 200 && ctx.status < 400 ? "succeeded" : "failed");
+        } catch (usageError) {
+          ctx.log.error("AI API usage record could not be finalized:", usageError);
+        }
       }
     }
   };

package/dist/server/usage.js

@@ -0,0 +1,81 @@
+/**
+ * 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 usage_exports = {};
+__export(usage_exports, {
+  finishUsageRecord: () => finishUsageRecord,
+  startUsageRecord: () => startUsageRecord
+});
+module.exports = __toCommonJS(usage_exports);
+async function startUsageRecord(ctx, requestId, endpoint, model, streaming) {
+  var _a, _b;
+  const body = ctx.request.body || {};
+  const messages = Array.isArray(body.messages) ? body.messages : void 0;
+  const oauth = ctx.state.oauthPrincipal;
+  const record = await ctx.db.getRepository("aiApiUsageRecords").create({
+    values: {
+      requestId,
+      userId: String((_a = ctx.state.currentUser) == null ? void 0 : _a.id),
+      roleName: ctx.state.currentRole || ((_b = ctx.state.currentRoles) == null ? void 0 : _b[0]) || "unknown",
+      authType: ctx.state.aiApiAuthType || (oauth ? "oidc" : "session"),
+      oauthClientId: oauth == null ? void 0 : oauth.clientId,
+      oauthSubject: oauth == null ? void 0 : oauth.subject,
+      oauthScopes: oauth == null ? void 0 : oauth.scopes,
+      endpoint,
+      mode: ctx.get("X-AI-Mode") || void 0,
+      model: model === "-" ? void 0 : model,
+      status: "pending",
+      streaming,
+      startedAt: /* @__PURE__ */ new Date(),
+      requestMetadata: { messageCount: messages == null ? void 0 : messages.length, requestedMaxTokens: body.max_tokens }
+    }
+  });
+  return record.id;
+}
+async function finishUsageRecord(ctx, id, startedAt, status) {
+  var _a;
+  const response = ctx.body || {};
+  const streamResult = ctx.state.aiApiStreamResult;
+  const usage = response.usage || (streamResult == null ? void 0 : streamResult.usage);
+  const values = {
+    status: streamResult ? streamResult.succeeded ? "succeeded" : "failed" : status,
+    httpStatus: ctx.status,
+    errorCode: ((_a = response.error) == null ? void 0 : _a.code) || (streamResult == null ? void 0 : streamResult.errorCode),
+    inputTokens: usage == null ? void 0 : usage.prompt_tokens,
+    outputTokens: usage == null ? void 0 : usage.completion_tokens,
+    totalTokens: usage == null ? void 0 : usage.total_tokens,
+    providerRequestId: response.id || (streamResult == null ? void 0 : streamResult.id),
+    completedAt: /* @__PURE__ */ new Date(),
+    durationMs: Date.now() - startedAt,
+    responseMetadata: { usageSource: usage ? "response" : "unavailable" }
+  };
+  await ctx.db.getRepository("aiApiUsageRecords").update({ filterByTk: id, values });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  finishUsageRecord,
+  startUsageRecord
+});

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

@@ -71,7 +71,15 @@ function toOpenAIError(statusCode, message, type = "invalid_request_error", code
   };
 }
 function toOpenAIResponse(options) {
-  const { id, model, content, finishReason = "stop", usage } = options;
+  var _a;
+  const {
+    id,
+    model,
+    content,
+    finishReason = ((_a = options.toolCalls) == null ? void 0 : _a.length) ? "tool_calls" : "stop",
+    usage,
+    toolCalls
+  } = options;
   return {
     id,
     object: "chat.completion",
@@ -83,7 +91,8 @@ function toOpenAIResponse(options) {
         index: 0,
         message: {
           role: "assistant",
-          content
+          content,
+          ...(toolCalls == null ? void 0 : toolCalls.length) ? { tool_calls: toolCalls } : {}
         },
         logprobs: null,
         finish_reason: finishReason

package/dist/server/utils/streaming.js

@@ -0,0 +1,80 @@
+/**
+ * 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 streaming_exports = {};
+__export(streaming_exports, {
+  createRequestAbortController: () => createRequestAbortController,
+  isStreamingRequested: () => isStreamingRequested,
+  writeResponse: () => writeResponse
+});
+module.exports = __toCommonJS(streaming_exports);
+function isStreamingRequested(value) {
+  return value !== false;
+}
+function createRequestAbortController(ctx) {
+  const controller = new AbortController();
+  const abort = () => {
+    if (!ctx.res.writableEnded) controller.abort(new Error("Client disconnected"));
+  };
+  ctx.req.once("aborted", abort);
+  ctx.res.once("close", abort);
+  return {
+    signal: controller.signal,
+    dispose() {
+      ctx.req.off("aborted", abort);
+      ctx.res.off("close", abort);
+    }
+  };
+}
+async function writeResponse(ctx, data) {
+  if (ctx.res.writableEnded || ctx.res.destroyed) return false;
+  if (!ctx.res.write(data)) await waitForDrain(ctx);
+  return true;
+}
+function waitForDrain(ctx) {
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      ctx.res.off("drain", onDrain);
+      ctx.res.off("close", onClose);
+    };
+    const onDrain = () => {
+      cleanup();
+      resolve();
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("Client disconnected"));
+    };
+    ctx.res.once("drain", onDrain);
+    ctx.res.once("close", onClose);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestAbortController,
+  isStreamingRequested,
+  writeResponse
+});

package/dist/swagger.js

@@ -183,7 +183,7 @@ var swagger_default = {
                   model: { type: "string" },
                   prompt: { type: "string" },
                   max_tokens: { type: "integer" },
-                  stream: { type: "boolean", default: false }
+                  stream: { type: "boolean", default: true }
                 },
                 required: ["model", "prompt"]
               }
@@ -294,7 +294,9 @@ var swagger_default = {
         properties: {
           role: { type: "string", enum: ["system", "user", "assistant", "tool"] },
           content: { type: "string" },
-          name: { type: "string" }
+          name: { type: "string" },
+          tool_call_id: { type: "string" },
+          tool_calls: { type: "array", items: { $ref: "#/components/schemas/ToolCall" } }
         },
         required: ["role", "content"]
       },
@@ -303,12 +305,17 @@ var swagger_default = {
         properties: {
           model: { type: "string", example: "openai/gpt-4o" },
           messages: { type: "array", items: { $ref: "#/components/schemas/ChatMessage" } },
-          stream: { type: "boolean", default: false },
+          stream: { type: "boolean", default: true },
           temperature: { type: "number", minimum: 0, maximum: 2 },
           max_tokens: { type: "integer" },
           top_p: { type: "number" },
           frequency_penalty: { type: "number" },
-          presence_penalty: { type: "number" }
+          presence_penalty: { type: "number" },
+          tools: { type: "array", items: { $ref: "#/components/schemas/ToolDefinition" } },
+          tool_choice: {
+            description: "OpenAI-compatible tool choice: auto, none, required, or a named function choice.",
+            oneOf: [{ type: "string", enum: ["auto", "none", "required"] }, { type: "object" }]
+          }
         },
         required: ["model", "messages"]
       },
@@ -339,6 +346,33 @@ var swagger_default = {
             }
           }
         }
+      },
+      ToolDefinition: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: ["function"] },
+          function: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              description: { type: "string" },
+              parameters: { type: "object" }
+            },
+            required: ["name", "parameters"]
+          }
+        },
+        required: ["type", "function"]
+      },
+      ToolCall: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          type: { type: "string", enum: ["function"] },
+          function: {
+            type: "object",
+            properties: { name: { type: "string" }, arguments: { type: "string" } }
+          }
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-ai-api",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "main": "dist/server/index.js",
   "dependencies": {},
   "peerDependencies": {
@@ -28,5 +28,6 @@
     "client.d.ts",
     "client-v2.d.ts",
     "server.d.ts"
-  ]
+  ],
+  "license": "Apache-2.0"
 }

package/src/server/__tests__/openai-format.test.ts

@@ -0,0 +1,52 @@
+import { toOpenAIResponse, toOpenAIStreamChunk } from '../utils/openai-format';
+import { isStreamingRequested } from '../utils/streaming';
+
+describe('AI API OpenAI tool-call formatting', () => {
+  it('streams by default and only disables streaming for an explicit false value', () => {
+    expect(isStreamingRequested(undefined)).toBe(true);
+    expect(isStreamingRequested(true)).toBe(true);
+    expect(isStreamingRequested(false)).toBe(false);
+  });
+  it('returns tool calls and the matching finish reason for a non-stream response', () => {
+    const response = toOpenAIResponse({
+      id: 'chatcmpl-1',
+      model: 'service/model',
+      content: '',
+      toolCalls: [
+        {
+          id: 'call-1',
+          type: 'function',
+          function: { name: 'get_weather', arguments: '{"city":"Hanoi"}' },
+        },
+      ],
+    });
+
+    expect(response.choices[0].finish_reason).toBe('tool_calls');
+    expect(response.choices[0].message.tool_calls).toEqual([
+      {
+        id: 'call-1',
+        type: 'function',
+        function: { name: 'get_weather', arguments: '{"city":"Hanoi"}' },
+      },
+    ]);
+  });
+
+  it('formats streaming tool-call deltas', () => {
+    const chunk = toOpenAIStreamChunk({
+      id: 'chatcmpl-1',
+      model: 'service/model',
+      delta: {
+        tool_calls: [
+          {
+            index: 0,
+            id: 'call-1',
+            type: 'function',
+            function: { name: 'get_weather', arguments: '{"city"' },
+          },
+        ],
+      },
+    });
+
+    expect(chunk.choices[0].delta.tool_calls?.[0].function?.name).toBe('get_weather');
+  });
+});

package/src/server/collections/ai-api-usage-records.ts

@@ -0,0 +1,33 @@
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'aiApiUsageRecords',
+  autoGenId: true,
+  fields: [
+    { name: 'requestId', type: 'string', unique: true, index: true },
+    { name: 'userId', type: 'string', index: true },
+    { name: 'roleName', type: 'string', index: true },
+    { name: 'authType', type: 'string', index: true },
+    { name: 'oauthClientId', type: 'string', allowNull: true, index: true },
+    { name: 'oauthSubject', type: 'string', allowNull: true },
+    { name: 'oauthScopes', type: 'json', allowNull: true },
+    { name: 'endpoint', type: 'string' },
+    { name: 'mode', type: 'string', allowNull: true },
+    { name: 'model', type: 'string', allowNull: true, index: true },
+    { name: 'status', type: 'string', index: true },
+    { name: 'httpStatus', type: 'integer', allowNull: true },
+    { name: 'errorCode', type: 'string', allowNull: true },
+    { name: 'streaming', type: 'boolean', defaultValue: false },
+    { name: 'inputTokens', type: 'integer', allowNull: true },
+    { name: 'outputTokens', type: 'integer', allowNull: true },
+    { name: 'totalTokens', type: 'integer', allowNull: true },
+    { name: 'estimatedCost', type: 'decimal', allowNull: true, precision: 20, scale: 8 },
+    { name: 'currency', type: 'string', allowNull: true },
+    { name: 'providerRequestId', type: 'string', allowNull: true },
+    { name: 'requestMetadata', type: 'jsonb', defaultValue: {} },
+    { name: 'responseMetadata', type: 'jsonb', defaultValue: {} },
+    { name: 'startedAt', type: 'datetimeTz', allowNull: true },
+    { name: 'completedAt', type: 'datetimeTz', allowNull: true },
+    { name: 'durationMs', type: 'integer', allowNull: true },
+  ],
+});