plugin-ai-api 1.0.0

package/dist/server/routes/router.js

@@ -0,0 +1,189 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var router_exports = {};
+__export(router_exports, {
+  createAiLlmRouter: () => createAiLlmRouter
+});
+module.exports = __toCommonJS(router_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_auth = require("./auth");
+var import_models = require("./models");
+var import_chat_completions = require("./chat-completions");
+var import_completions = require("./completions");
+var import_agent_completions = require("./agent-completions");
+var import_embeddings = require("./embeddings");
+var import_openai_format = require("../utils/openai-format");
+var import_rate_limit = require("../middleware/rate-limit");
+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;
+    const { path, method } = ctx;
+    if (!path.startsWith(API_PREFIX)) {
+      return next();
+    }
+    const subPath = path.substring(API_PREFIX.length);
+    ctx.set("Access-Control-Allow-Origin", "*");
+    ctx.set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    ctx.set("Access-Control-Allow-Headers", "Authorization, Content-Type, X-AI-Mode, X-Timezone, X-Locale");
+    ctx.set("Access-Control-Expose-Headers", "X-Request-Id, X-RateLimit-Limit, X-RateLimit-Remaining, Retry-After");
+    ctx.set("Access-Control-Max-Age", "86400");
+    if (method === "OPTIONS") {
+      ctx.status = 204;
+      return;
+    }
+    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 == null ? void 0 : 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);
+      return;
+    }
+    const allowed = await checkRateLimit(ctx);
+    if (!allowed) {
+      logRequest(ctx, requestId, "-", "rate_limited", 0);
+      return;
+    }
+    const model = ((_a = ctx.request.body) == null ? void 0 : _a.model) ?? "-";
+    const t0 = Date.now();
+    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);
+        return;
+      }
+      if (method === "POST" && subPath === "/embeddings") {
+        await (0, import_embeddings.handleEmbeddings)(ctx, plugin);
+        logRequest(ctx, requestId, model, "ok", Date.now() - t0);
+        return;
+      }
+      if (method === "POST" && subPath === "/completions") {
+        await (0, import_completions.handleCompletions)(ctx, plugin);
+        logRequest(ctx, requestId, model, "ok", Date.now() - t0);
+        return;
+      }
+      if (method === "GET" && subPath === "/models") {
+        await (0, import_models.handleListModels)(ctx, plugin);
+        logRequest(ctx, requestId, "-", "ok", Date.now() - t0);
+        return;
+      }
+      if (method === "GET" && subPath.startsWith("/models/")) {
+        const modelId = subPath.substring("/models/".length);
+        if (modelId) {
+          await (0, import_models.handleGetModel)(ctx, decodeURIComponent(modelId), plugin);
+          logRequest(ctx, requestId, modelId, "ok", Date.now() - t0);
+          return;
+        }
+      }
+      if (method === "DELETE" && subPath.startsWith("/models/")) {
+        ctx.status = 501;
+        ctx.body = (0, import_openai_format.toOpenAIError)(
+          501,
+          "Model deletion is not supported by this API gateway. Use the NocoBase admin panel to manage LLM services.",
+          "invalid_request_error",
+          "not_implemented"
+        );
+        logRequest(ctx, requestId, "-", "not_implemented", Date.now() - t0);
+        return;
+      }
+      ctx.status = 404;
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        404,
+        `Unknown endpoint: ${method} ${path}. Supported: POST /v1/chat/completions, POST /v1/completions, POST /v1/embeddings, GET /v1/models`,
+        "invalid_request_error",
+        "unknown_url"
+      );
+      logRequest(ctx, requestId, "-", "not_found", Date.now() - t0);
+    } catch (err) {
+      ctx.log.error("AI API router error:", err);
+      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");
+      }
+    }
+  };
+}
+const MAX_BODY_BYTES = 10 * 1024 * 1024;
+function getRawBody(ctx) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    let byteCount = 0;
+    ctx.req.on("data", (chunk) => {
+      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 }));
+        return;
+      }
+      body += chunk.toString();
+    });
+    ctx.req.on("end", () => resolve(body));
+    ctx.req.on("error", reject);
+  });
+}
+async function resolveMode(ctx) {
+  var _a;
+  const headerMode = (_a = ctx.get("X-AI-Mode")) == null ? void 0 : _a.toLowerCase();
+  if (headerMode === "agent" || headerMode === "llm") {
+    return headerMode;
+  }
+  try {
+    const config = await ctx.db.getRepository("aiApiConfig").findOne();
+    if ((config == null ? void 0 : config.mode) === "agent" || (config == null ? void 0 : config.mode) === "llm") {
+      return config.mode;
+    }
+  } catch {
+  }
+  return "llm";
+}
+function logRequest(ctx, requestId, model, status, durationMs) {
+  var _a, _b;
+  const userId = ((_a = ctx.state.currentUser) == null ? void 0 : _a.id) ?? "anon";
+  (_b = ctx.app.logger) == null ? void 0 : _b.info(
+    `[ai-api] ${ctx.method} ${ctx.path} requestId=${requestId} userId=${userId} model=${model} status=${status} duration=${durationMs}ms`
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAiLlmRouter
+});

package/dist/server/utils/openai-format.d.ts

@@ -0,0 +1,99 @@
+export interface ParsedModel {
+    llmService: string;
+    modelId: string;
+}
+/**
+ * Parse OpenAI-style model string into NocoBase llmService + modelId.
+ * Format: "llmServiceName/modelId" (e.g. "my-openai/gpt-4o")
+ * If no "/" is present, the entire string is treated as modelId and llmService is empty.
+ */
+export declare function parseModelString(model: string): ParsedModel;
+export declare function generateCompletionId(): string;
+export declare function toOpenAIError(statusCode: number, message: string, type?: string, code?: string): {
+    error: {
+        message: string;
+        type: string;
+        param: any;
+        code: string;
+    };
+};
+export declare function toOpenAIResponse(options: {
+    id: string;
+    model: string;
+    content: string;
+    finishReason?: string;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    system_fingerprint: any;
+    choices: {
+        index: number;
+        message: {
+            role: string;
+            content: string;
+        };
+        logprobs: any;
+        finish_reason: string;
+    }[];
+    usage: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+};
+export declare function toOpenAIStreamChunk(options: {
+    id: string;
+    model: string;
+    delta: {
+        role?: string;
+        content?: string;
+    };
+    finishReason?: string | null;
+}): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    system_fingerprint: any;
+    choices: {
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+        };
+        logprobs: any;
+        finish_reason: string;
+    }[];
+};
+export declare function toOpenAIEmbeddingsResponse(options: {
+    model: string;
+    embeddings: number[][];
+    promptTokens?: number;
+}): {
+    object: "list";
+    data: {
+        object: "embedding";
+        embedding: number[];
+        index: number;
+    }[];
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+};
+/**
+ * Format a streaming chunk as an SSE data line.
+ */
+export declare function formatSSE(data: any): string;
+/**
+ * Format the terminal SSE [DONE] signal.
+ */
+export declare function formatSSEDone(): string;

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

@@ -0,0 +1,140 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var openai_format_exports = {};
+__export(openai_format_exports, {
+  formatSSE: () => formatSSE,
+  formatSSEDone: () => formatSSEDone,
+  generateCompletionId: () => generateCompletionId,
+  parseModelString: () => parseModelString,
+  toOpenAIEmbeddingsResponse: () => toOpenAIEmbeddingsResponse,
+  toOpenAIError: () => toOpenAIError,
+  toOpenAIResponse: () => toOpenAIResponse,
+  toOpenAIStreamChunk: () => toOpenAIStreamChunk
+});
+module.exports = __toCommonJS(openai_format_exports);
+var import_crypto = __toESM(require("crypto"));
+function parseModelString(model) {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) {
+    return { llmService: "", modelId: model };
+  }
+  return {
+    llmService: model.substring(0, slashIndex),
+    modelId: model.substring(slashIndex + 1)
+  };
+}
+function generateCompletionId() {
+  return `chatcmpl-${import_crypto.default.randomBytes(16).toString("hex").substring(0, 29)}`;
+}
+function toOpenAIError(statusCode, message, type = "invalid_request_error", code) {
+  return {
+    error: {
+      message,
+      type,
+      param: null,
+      code: code || null
+    }
+  };
+}
+function toOpenAIResponse(options) {
+  const { id, model, content, finishReason = "stop", usage } = options;
+  return {
+    id,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    system_fingerprint: null,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content
+        },
+        logprobs: null,
+        finish_reason: finishReason
+      }
+    ],
+    usage: usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+}
+function toOpenAIStreamChunk(options) {
+  const { id, model, delta, finishReason = null } = options;
+  return {
+    id,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    system_fingerprint: null,
+    choices: [
+      {
+        index: 0,
+        delta,
+        logprobs: null,
+        finish_reason: finishReason
+      }
+    ]
+  };
+}
+function toOpenAIEmbeddingsResponse(options) {
+  const { model, embeddings, promptTokens = 0 } = options;
+  return {
+    object: "list",
+    data: embeddings.map((embedding, index) => ({
+      object: "embedding",
+      embedding,
+      index
+    })),
+    model,
+    usage: {
+      prompt_tokens: promptTokens,
+      total_tokens: promptTokens
+    }
+  };
+}
+function formatSSE(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function formatSSEDone() {
+  return `data: [DONE]
+
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatSSE,
+  formatSSEDone,
+  generateCompletionId,
+  parseModelString,
+  toOpenAIEmbeddingsResponse,
+  toOpenAIError,
+  toOpenAIResponse,
+  toOpenAIStreamChunk
+});

package/dist/server/utils/rate-limiter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * In-memory sliding window rate limiter.
+ *
+ * Stores per-user request timestamps. On each check: prunes timestamps
+ * older than the window, counts the remainder, and accepts/rejects.
+ *
+ * Single-process safe (Node.js event loop). Not distributed.
+ * For multi-process deployments, replace with a Redis-backed implementation.
+ */
+export declare class RateLimiter {
+    private readonly windowMs;
+    /** Map<userId, sorted array of request timestamps in ms> */
+    private readonly store;
+    constructor(windowMs?: number);
+    /**
+     * Check and record a request for a user.
+     *
+     * @param userId  The user ID (string or numeric)
+     * @param limit   Max allowed requests per window (from aiApiConfig.rateLimitPerMinute)
+     * @returns { allowed: true } or { allowed: false, retryAfterMs: number }
+     */
+    check(userId: string | number, limit: number): {
+        allowed: true;
+    } | {
+        allowed: false;
+        retryAfterMs: number;
+    };
+    /**
+     * Garbage collect entries for inactive users.
+     * Call every ~5 minutes to prevent unbounded memory growth in long-running servers.
+     */
+    gc(): void;
+    /** Clear all state (useful in tests). */
+    clear(): void;
+}

package/dist/server/utils/rate-limiter.js

@@ -0,0 +1,81 @@
+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 rate_limiter_exports = {};
+__export(rate_limiter_exports, {
+  RateLimiter: () => RateLimiter
+});
+module.exports = __toCommonJS(rate_limiter_exports);
+class RateLimiter {
+  constructor(windowMs = 6e4) {
+    this.windowMs = windowMs;
+  }
+  /** Map<userId, sorted array of request timestamps in ms> */
+  store = /* @__PURE__ */ new Map();
+  /**
+   * Check and record a request for a user.
+   *
+   * @param userId  The user ID (string or numeric)
+   * @param limit   Max allowed requests per window (from aiApiConfig.rateLimitPerMinute)
+   * @returns { allowed: true } or { allowed: false, retryAfterMs: number }
+   */
+  check(userId, limit) {
+    const now = Date.now();
+    const windowStart = now - this.windowMs;
+    let timestamps = this.store.get(userId);
+    if (!timestamps) {
+      timestamps = [];
+      this.store.set(userId, timestamps);
+    }
+    let lo = 0, hi = timestamps.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (timestamps[mid] < windowStart) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    if (lo > 0) timestamps.splice(0, lo);
+    if (timestamps.length >= limit) {
+      const retryAfterMs = Math.max(0, timestamps[0] + this.windowMs - now);
+      return { allowed: false, retryAfterMs };
+    }
+    timestamps.push(now);
+    return { allowed: true };
+  }
+  /**
+   * Garbage collect entries for inactive users.
+   * Call every ~5 minutes to prevent unbounded memory growth in long-running servers.
+   */
+  gc() {
+    const cutoff = Date.now() - this.windowMs;
+    for (const [userId, timestamps] of this.store) {
+      if (!timestamps.length || timestamps[timestamps.length - 1] < cutoff) {
+        this.store.delete(userId);
+      }
+    }
+  }
+  /** Clear all state (useful in tests). */
+  clear() {
+    this.store.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RateLimiter
+});

package/dist/server/utils/resolve-service.d.ts

@@ -0,0 +1,19 @@
+import { Context } from '@nocobase/actions';
+/**
+ * Resolve an LLM service by name or title.
+ */
+export declare function resolveLlmService(ctx: Context, serviceKey: string): Promise<any>;
+/**
+ * Resolve a model string to a service + modelId.
+ *
+ * Strategy (priority order):
+ * 1. Try splitting at each "/" position and match the left part against DB (name or title).
+ *    This handles cases like "Custom LLM (OpenAI Compatible)/qwen/qwen3.6-plus-preview:free"
+ * 2. If no service match, use the defaultLlmService from config and treat the ENTIRE
+ *    model string as the modelId. This allows clients to send just "qwen/qwen3.6-plus-preview:free"
+ *    or "gpt-4o" without knowing the service name.
+ */
+export declare function resolveModelString(ctx: Context, modelString: string): Promise<{
+    service: any;
+    modelId: string;
+} | null>;

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

@@ -0,0 +1,71 @@
+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 resolve_service_exports = {};
+__export(resolve_service_exports, {
+  resolveLlmService: () => resolveLlmService,
+  resolveModelString: () => resolveModelString
+});
+module.exports = __toCommonJS(resolve_service_exports);
+async function resolveLlmService(ctx, serviceKey) {
+  const repo = ctx.db.getRepository("llmServices");
+  let service = await repo.findOne({ filter: { name: serviceKey } });
+  if (!service) {
+    service = await repo.findOne({ filter: { title: serviceKey } });
+  }
+  return service;
+}
+async function resolveModelString(ctx, modelString) {
+  const repo = ctx.db.getRepository("llmServices");
+  const slashPositions = [];
+  for (let i = 0; i < modelString.length; i++) {
+    if (modelString[i] === "/") {
+      slashPositions.push(i);
+    }
+  }
+  if (slashPositions.length > 0) {
+    for (const pos of slashPositions) {
+      const serviceKey = modelString.substring(0, pos);
+      const modelId = modelString.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 };
+      }
+    }
+  }
+  const config = await ctx.db.getRepository("aiApiConfig").findOne();
+  if (config == null ? void 0 : config.defaultLlmService) {
+    const service = await repo.findOne({ filter: { name: config.defaultLlmService } });
+    if (service) {
+      return { service, modelId: modelString };
+    }
+  }
+  const enabledServices = await repo.find({ filter: { enabled: true } });
+  if (enabledServices.length === 1) {
+    return { service: enabledServices[0], modelId: modelString };
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveLlmService,
+  resolveModelString
+});

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "plugin-ai-api",
+  "version": "1.0.0",
+  "main": "dist/server/index.js",
+  "dependencies": {},
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/database": "2.x",
+    "@nocobase/plugin-ai": "2.x",
+    "@nocobase/plugin-api-keys": "2.x"
+  }
+}

package/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');