plugin-ai-api 1.0.0

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

@@ -0,0 +1,300 @@
+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 agent_completions_exports = {};
+__export(agent_completions_exports, {
+  handleAgentCompletions: () => handleAgentCompletions
+});
+module.exports = __toCommonJS(agent_completions_exports);
+var import_openai_format = require("../utils/openai-format");
+var import_resolve_service = require("../utils/resolve-service");
+async function handleAgentCompletions(ctx, plugin) {
+  var _a;
+  const body = ctx.request.body;
+  if (!(body == null ? void 0 : body.model)) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'model' is required", "invalid_request_error", "missing_model");
+    return;
+  }
+  if (!(body == null ? void 0 : body.messages) || !Array.isArray(body.messages) || body.messages.length === 0) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'messages' must be a non-empty array", "invalid_request_error", "missing_messages");
+    return;
+  }
+  if (body.n !== void 0 && body.n !== null && body.n !== 1) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `The 'n' parameter value ${body.n} is not supported. This gateway always returns n=1.`,
+      "invalid_request_error",
+      "unsupported_parameter"
+    );
+    return;
+  }
+  const config = await ctx.db.getRepository("aiApiConfig").findOne();
+  if (!(config == null ? void 0 : config.defaultAiEmployee)) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      "Agent mode requires a Default AI Employee. Configure one in Settings > AI API Gateway.",
+      "invalid_request_error",
+      "missing_config"
+    );
+    return;
+  }
+  const resolved = await (0, import_resolve_service.resolveModelString)(ctx, body.model);
+  if (!resolved) {
+    ctx.status = 404;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      404,
+      `Could not resolve model '${body.model}'. Use GET /v1/models to see available models.`,
+      "invalid_request_error",
+      "model_not_found"
+    );
+    return;
+  }
+  const { service, modelId } = resolved;
+  if (service.enabled === false) {
+    ctx.status = 404;
+    ctx.body = (0, import_openai_format.toOpenAIError)(404, "LLM service is disabled", "invalid_request_error", "model_not_found");
+    return;
+  }
+  const employeeUsername = config.defaultAiEmployee;
+  const wantStream = body.stream === true;
+  try {
+    const employeeRecord = await ctx.db.getRepository("aiEmployees").findOne({
+      filter: { username: employeeUsername }
+    });
+    if (!employeeRecord) {
+      ctx.status = 400;
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        400,
+        `AI employee '${employeeUsername}' not found. Check Settings > AI API Gateway.`,
+        "invalid_request_error",
+        "missing_config"
+      );
+      return;
+    }
+    const userId = (_a = ctx.state.currentUser) == null ? void 0 : _a.id;
+    const conversation = await ctx.db.getRepository("aiConversations").create({
+      values: {
+        userId,
+        aiEmployee: { username: employeeUsername },
+        options: {},
+        thread: 1
+      }
+    });
+    const sessionId = conversation.sessionId ?? conversation.id ?? String(conversation.get("id"));
+    const userMessages = body.messages.map((msg) => ({
+      // 'assistant' role maps to the AI employee's username in NocoBase's system
+      role: msg.role === "assistant" ? employeeUsername : msg.role,
+      content: {
+        type: "text",
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      }
+    }));
+    const completionId = (0, import_openai_format.generateCompletionId)();
+    let AIEmployee;
+    try {
+      const mod = await import(
+        /* webpackIgnore: true */
+        "@nocobase/plugin-ai/src/server/ai-employees/ai-employee"
+      );
+      AIEmployee = mod.AIEmployee;
+    } catch (importErr) {
+      ctx.log.error("AI API: Failed to import AIEmployee from plugin-ai. Ensure plugin-ai is installed and built.", importErr);
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, "Agent mode unavailable: plugin-ai not found or not built", "server_error");
+      return;
+    }
+    if (!AIEmployee) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, "Agent mode unavailable: AIEmployee class not exported by plugin-ai", "server_error");
+      return;
+    }
+    if (wantStream) {
+      ctx.set({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no"
+      });
+      ctx.status = 200;
+      ctx.res.write(
+        (0, import_openai_format.formatSSE)(
+          (0, import_openai_format.toOpenAIStreamChunk)({
+            id: completionId,
+            model: body.model,
+            delta: { role: "assistant", content: "" }
+          })
+        )
+      );
+      const originalWrite = ctx.res.write.bind(ctx.res);
+      const originalEnd = ctx.res.end.bind(ctx.res);
+      ctx.res.end = (...args) => {
+        if (args[0]) {
+          ctx.res.write(args[0]);
+        }
+      };
+      ctx.res.write = (data) => {
+        const text = typeof data === "string" ? data : data.toString("utf8");
+        for (const line of text.split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const jsonStr = trimmed.substring(6);
+          if (!jsonStr) continue;
+          try {
+            const event = JSON.parse(jsonStr);
+            if (event.type === "content" && event.body) {
+              originalWrite(
+                (0, import_openai_format.formatSSE)(
+                  (0, import_openai_format.toOpenAIStreamChunk)({
+                    id: completionId,
+                    model: body.model,
+                    delta: { content: String(event.body) }
+                  })
+                )
+              );
+            } else if (event.type === "error" && event.body) {
+              originalWrite(
+                (0, import_openai_format.formatSSE)({
+                  error: {
+                    message: String(event.body),
+                    type: "server_error",
+                    code: "agent_error"
+                  }
+                })
+              );
+            }
+          } catch {
+          }
+        }
+        return true;
+      };
+      try {
+        const aiEmployee = new AIEmployee(
+          ctx,
+          employeeRecord,
+          sessionId,
+          void 0,
+          // systemMessage — use AI employee's default
+          void 0,
+          // skillSettings
+          false,
+          // webSearch
+          { llmService: service.name, model: modelId },
+          false
+          // legacy — use LangGraph (thread: 1)
+        );
+        await aiEmployee.stream({ userMessages });
+      } finally {
+        ctx.res.write = originalWrite;
+        ctx.res.end = originalEnd;
+        originalWrite(
+          (0, import_openai_format.formatSSE)(
+            (0, import_openai_format.toOpenAIStreamChunk)({
+              id: completionId,
+              model: body.model,
+              delta: {},
+              finishReason: "stop"
+            })
+          )
+        );
+        originalWrite((0, import_openai_format.formatSSEDone)());
+        originalEnd();
+      }
+    } else {
+      const aiEmployee = new AIEmployee(
+        ctx,
+        employeeRecord,
+        sessionId,
+        void 0,
+        void 0,
+        false,
+        { llmService: service.name, model: modelId },
+        false
+      );
+      const result = await aiEmployee.invoke({ userMessages });
+      const content = extractLastAiMessageContent(result);
+      ctx.status = 200;
+      ctx.set("Content-Type", "application/json");
+      ctx.body = {
+        id: completionId,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1e3),
+        model: body.model,
+        system_fingerprint: null,
+        choices: [
+          {
+            index: 0,
+            message: { role: "assistant", content },
+            logprobs: null,
+            finish_reason: "stop"
+          }
+        ],
+        // NOTE: Token usage is unavailable in agent mode.
+        // ResponseMetadataCollector is private inside AIEmployee and not exposed publicly.
+        // Clients can detect agent mode by checking usage.total_tokens === 0.
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+      };
+    }
+    setImmediate(async () => {
+      try {
+        await ctx.db.getRepository("aiConversations").destroy({
+          filterByTk: sessionId
+        });
+      } catch {
+      }
+    });
+  } catch (err) {
+    ctx.log.error("AI API agent 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");
+    }
+  }
+}
+function extractLastAiMessageContent(result) {
+  var _a;
+  if (!(result == null ? void 0 : result.messages) || !Array.isArray(result.messages)) return "";
+  for (let i = result.messages.length - 1; i >= 0; i--) {
+    const msg = result.messages[i];
+    if (!msg) continue;
+    const className = (_a = msg == null ? void 0 : msg.constructor) == null ? void 0 : _a.name;
+    if (className === "HumanMessage" || className === "ToolMessage") continue;
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      const textBlock = msg.content.find((c) => c.type === "text");
+      return (textBlock == null ? void 0 : textBlock.text) || "";
+    }
+  }
+  return "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleAgentCompletions
+});

package/dist/server/routes/auth.d.ts

@@ -0,0 +1,8 @@
+import { Context } from '@nocobase/actions';
+/**
+ * Authentication middleware for /api/ai-llm/v1/* routes.
+ *
+ * Validates Bearer token against NocoBase's apiKeys collection.
+ * Sets ctx.state.currentUser for downstream handlers.
+ */
+export declare function authenticateBearer(ctx: Context): Promise<boolean>;

package/dist/server/routes/auth.js

@@ -0,0 +1,110 @@
+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 auth_exports = {};
+__export(auth_exports, {
+  authenticateBearer: () => authenticateBearer
+});
+module.exports = __toCommonJS(auth_exports);
+var import_openai_format = require("../utils/openai-format");
+async function authenticateBearer(ctx) {
+  var _a, _b;
+  const authHeader = ctx.get("Authorization") || "";
+  if (!authHeader.startsWith("Bearer ")) {
+    ctx.status = 401;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      401,
+      "Missing or invalid Authorization header. Expected: Bearer <api-key>",
+      "invalid_request_error",
+      "invalid_api_key"
+    );
+    return false;
+  }
+  const token = authHeader.substring(7).trim();
+  if (!token) {
+    ctx.status = 401;
+    ctx.body = (0, import_openai_format.toOpenAIError)(401, "API key is empty", "invalid_request_error", "invalid_api_key");
+    return false;
+  }
+  try {
+    const auth = ctx.app["authManager"];
+    if (!auth) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, "Auth system not available", "server_error");
+      return false;
+    }
+    const jwt = (_a = ctx.app["authManager"]) == null ? void 0 : _a.jwt;
+    if (!jwt) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, "JWT system not available", "server_error");
+      return false;
+    }
+    let decoded;
+    try {
+      decoded = await jwt.decode(token);
+    } catch (e) {
+      ctx.status = 401;
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        401,
+        "Incorrect API key provided",
+        "invalid_request_error",
+        "invalid_api_key"
+      );
+      return false;
+    }
+    if (!decoded || !decoded.userId) {
+      ctx.status = 401;
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        401,
+        "Invalid or expired API key",
+        "invalid_request_error",
+        "invalid_api_key"
+      );
+      return false;
+    }
+    const user = await ctx.db.getRepository("users").findOne({
+      filterByTk: decoded.userId
+    });
+    if (!user) {
+      ctx.status = 401;
+      ctx.body = (0, import_openai_format.toOpenAIError)(401, "User not found for this API key", "invalid_request_error", "invalid_api_key");
+      return false;
+    }
+    ctx.state.currentUser = user;
+    ctx.state.currentRoles = decoded.roleName ? [decoded.roleName] : ["member"];
+    if (!ctx.auth) {
+      ctx.auth = {};
+    }
+    const SAFE_USER_FIELDS = /* @__PURE__ */ new Set(["id", "username", "nickname", "email", "createdAt", "updatedAt"]);
+    const rawUser = ((_b = user.toJSON) == null ? void 0 : _b.call(user)) ?? {};
+    const safeUser = { id: user.id };
+    for (const field of SAFE_USER_FIELDS) {
+      if (rawUser[field] !== void 0) safeUser[field] = rawUser[field];
+    }
+    ctx.auth.user = safeUser;
+    return true;
+  } catch (err) {
+    ctx.log.error("AI API auth error:", err);
+    ctx.status = 401;
+    ctx.body = (0, import_openai_format.toOpenAIError)(401, "Authentication failed", "invalid_request_error", "invalid_api_key");
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authenticateBearer
+});

package/dist/server/routes/chat-completions.d.ts

@@ -0,0 +1,9 @@
+import { Context } from '@nocobase/actions';
+import type PluginAiApiServer from '../plugin';
+/**
+ * POST /api/ai-llm/v1/chat/completions
+ *
+ * Handles OpenAI-compatible chat completion requests.
+ * Supports both streaming (SSE) and non-streaming modes.
+ */
+export declare function handleChatCompletions(ctx: Context, plugin: PluginAiApiServer): Promise<void>;

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

@@ -0,0 +1,237 @@
+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 chat_completions_exports = {};
+__export(chat_completions_exports, {
+  handleChatCompletions: () => handleChatCompletions
+});
+module.exports = __toCommonJS(chat_completions_exports);
+var import_openai_format = require("../utils/openai-format");
+var import_resolve_service = require("../utils/resolve-service");
+async function handleChatCompletions(ctx, plugin) {
+  var _a;
+  const body = ctx.request.body;
+  if (!(body == null ? void 0 : body.model)) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'model' is required", "invalid_request_error", "missing_model");
+    return;
+  }
+  if (!(body == null ? void 0 : body.messages) || !Array.isArray(body.messages) || body.messages.length === 0) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'messages' must be a non-empty array", "invalid_request_error", "missing_messages");
+    return;
+  }
+  if (body.n !== void 0 && body.n !== null && body.n !== 1) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `The 'n' parameter value ${body.n} is not supported. This API gateway always returns exactly one completion (n=1). Please omit 'n' or set it to 1.`,
+      "invalid_request_error",
+      "unsupported_parameter"
+    );
+    return;
+  }
+  const stream = body.stream === true;
+  const resolved = await (0, import_resolve_service.resolveModelString)(ctx, body.model);
+  if (!resolved) {
+    ctx.status = 404;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      404,
+      `Could not resolve model '${body.model}'. Format: 'serviceName/modelId'. Use GET /v1/models to see available models.`,
+      "invalid_request_error",
+      "model_not_found"
+    );
+    return;
+  }
+  const { service, modelId } = resolved;
+  try {
+    const aiPlugin = ctx.app.pm.get("ai");
+    if (!aiPlugin) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, "AI plugin not available", "server_error");
+      return;
+    }
+    if (service.enabled === false) {
+      ctx.status = 404;
+      ctx.body = (0, import_openai_format.toOpenAIError)(404, `LLM service '${service.title || service.name}' is disabled`, "invalid_request_error", "model_not_found");
+      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;
+      }
+    }
+    const providerMeta = aiPlugin.aiManager.llmProviders.get(service.provider);
+    if (!providerMeta) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, `Provider '${service.provider}' not registered`, "server_error");
+      return;
+    }
+    const modelOptions = {
+      model: modelId,
+      llmService: service.name
+    };
+    if (body.temperature !== void 0) modelOptions.temperature = body.temperature;
+    if (body.top_p !== void 0) modelOptions.topP = body.top_p;
+    if (body.max_tokens !== void 0) modelOptions.maxTokens = body.max_tokens;
+    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) {
+      const employee = await ctx.db.getRepository("aiEmployees").findOne({
+        filter: { username: config.defaultAiEmployee }
+      });
+      if (employee) {
+        systemPrompt = employee.about || employee.defaultPrompt || "";
+      }
+    }
+    const messages = [...body.messages];
+    const hasSystemMessage = messages.some((m) => m.role === "system");
+    if (systemPrompt && !hasSystemMessage) {
+      messages.unshift({ role: "system", content: systemPrompt });
+    }
+    const langchainMessages = messages.map((msg) => {
+      const role = msg.role === "assistant" ? "ai" : msg.role;
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return [role, content];
+    });
+    const completionId = (0, import_openai_format.generateCompletionId)();
+    const chatModel = provider.createModel();
+    if (stream) {
+      await handleStreamingCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+    } else {
+      await handleNonStreamingCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+    }
+  } catch (err) {
+    ctx.log.error("AI API chat 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");
+    }
+  }
+}
+async function handleNonStreamingCompletion(ctx, chatModel, messages, completionId, modelName) {
+  const result = await chatModel.invoke(messages);
+  let content = "";
+  if (typeof result.content === "string") {
+    content = result.content;
+  } else if (Array.isArray(result.content)) {
+    const textPart = result.content.find((c) => c.type === "text");
+    content = (textPart == null ? void 0 : textPart.text) || JSON.stringify(result.content);
+  }
+  const usage = result.usage_metadata ? {
+    prompt_tokens: result.usage_metadata.input_tokens || 0,
+    completion_tokens: result.usage_metadata.output_tokens || 0,
+    total_tokens: result.usage_metadata.total_tokens || 0
+  } : { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+  ctx.status = 200;
+  ctx.body = (0, import_openai_format.toOpenAIResponse)({
+    id: completionId,
+    model: modelName,
+    content,
+    usage
+  });
+}
+async function handleStreamingCompletion(ctx, chatModel, messages, completionId, modelName) {
+  ctx.set({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+    // Disable nginx buffering
+  });
+  ctx.status = 200;
+  ctx.res.write(
+    (0, import_openai_format.formatSSE)(
+      (0, import_openai_format.toOpenAIStreamChunk)({
+        id: completionId,
+        model: modelName,
+        delta: { role: "assistant", content: "" }
+      })
+    )
+  );
+  try {
+    const stream = await chatModel.stream(messages);
+    for await (const chunk of stream) {
+      let content = "";
+      if (typeof chunk.content === "string") {
+        content = chunk.content;
+      } else if (Array.isArray(chunk.content)) {
+        const textPart = chunk.content.find((c) => c.type === "text");
+        content = (textPart == null ? void 0 : textPart.text) || "";
+      }
+      if (content) {
+        ctx.res.write(
+          (0, import_openai_format.formatSSE)(
+            (0, import_openai_format.toOpenAIStreamChunk)({
+              id: completionId,
+              model: modelName,
+              delta: { content }
+            })
+          )
+        );
+      }
+    }
+    ctx.res.write(
+      (0, import_openai_format.formatSSE)(
+        (0, import_openai_format.toOpenAIStreamChunk)({
+          id: completionId,
+          model: modelName,
+          delta: {},
+          finishReason: "stop"
+        })
+      )
+    );
+    ctx.res.write((0, import_openai_format.formatSSEDone)());
+  } catch (err) {
+    ctx.log.error("AI API streaming error:", err);
+    ctx.res.write(
+      (0, import_openai_format.formatSSE)({
+        error: {
+          message: err.message || "Streaming error",
+          type: "server_error"
+        }
+      })
+    );
+  } finally {
+    ctx.res.end();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleChatCompletions
+});

package/dist/server/routes/completions.d.ts

@@ -0,0 +1,10 @@
+import { Context } from '@nocobase/actions';
+import type PluginAiApiServer from '../plugin';
+/**
+ * POST /api/ai-llm/v1/completions
+ *
+ * Handles legacy OpenAI text completions API.
+ * Converts prompt to messages and delegates to the chat model.
+ * Required by LiteLLM and other tools that test via legacy completions endpoint.
+ */
+export declare function handleCompletions(ctx: Context, plugin: PluginAiApiServer): Promise<void>;