plugin-ai-api 1.0.0

package/dist/server/routes/completions.js

@@ -0,0 +1,245 @@
+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 completions_exports = {};
+__export(completions_exports, {
+  handleCompletions: () => handleCompletions
+});
+module.exports = __toCommonJS(completions_exports);
+var import_openai_format = require("../utils/openai-format");
+var import_resolve_service = require("../utils/resolve-service");
+async function handleCompletions(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.prompt) && body.prompt !== "") {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'prompt' is required", "invalid_request_error", "missing_prompt");
+    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.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 = [];
+    if (config == null ? void 0 : config.defaultAiEmployee) {
+      const employee = await ctx.db.getRepository("aiEmployees").findOne({
+        filter: { username: config.defaultAiEmployee }
+      });
+      if (employee) {
+        const systemPrompt = employee.about || employee.defaultPrompt || "";
+        if (systemPrompt) {
+          langchainMessages.push(["system", systemPrompt]);
+        }
+      }
+    }
+    langchainMessages.push(["human", prompt]);
+    const completionId = (0, import_openai_format.generateCompletionId)().replace("chatcmpl-", "cmpl-");
+    const chatModel = provider.createModel();
+    if (stream) {
+      await handleStreamingTextCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+    } else {
+      await handleNonStreamingTextCompletion(ctx, chatModel, langchainMessages, completionId, body.model);
+    }
+  } catch (err) {
+    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");
+    }
+  }
+}
+async function handleNonStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName) {
+  const result = await chatModel.invoke(messages);
+  let text = "";
+  if (typeof result.content === "string") {
+    text = result.content;
+  } else if (Array.isArray(result.content)) {
+    const textPart = result.content.find((c) => c.type === "text");
+    text = (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 = {
+    id: completionId,
+    object: "text_completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: modelName,
+    system_fingerprint: null,
+    choices: [
+      {
+        text,
+        index: 0,
+        logprobs: null,
+        finish_reason: "stop"
+      }
+    ],
+    usage
+  };
+}
+async function handleStreamingTextCompletion(ctx, chatModel, messages, completionId, modelName) {
+  ctx.set({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  ctx.status = 200;
+  try {
+    const stream = await chatModel.stream(messages);
+    for await (const chunk of stream) {
+      let text = "";
+      if (typeof chunk.content === "string") {
+        text = chunk.content;
+      } else if (Array.isArray(chunk.content)) {
+        const textPart = chunk.content.find((c) => c.type === "text");
+        text = (textPart == null ? void 0 : textPart.text) || "";
+      }
+      if (text) {
+        ctx.res.write(
+          (0, import_openai_format.formatSSE)({
+            id: completionId,
+            object: "text_completion",
+            created: Math.floor(Date.now() / 1e3),
+            model: modelName,
+            system_fingerprint: null,
+            choices: [
+              {
+                text,
+                index: 0,
+                logprobs: null,
+                finish_reason: null
+              }
+            ]
+          })
+        );
+      }
+    }
+    ctx.res.write(
+      (0, import_openai_format.formatSSE)({
+        id: completionId,
+        object: "text_completion",
+        created: Math.floor(Date.now() / 1e3),
+        model: modelName,
+        system_fingerprint: null,
+        choices: [
+          {
+            text: "",
+            index: 0,
+            logprobs: null,
+            finish_reason: "stop"
+          }
+        ]
+      })
+    );
+    ctx.res.write((0, import_openai_format.formatSSEDone)());
+  } 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"
+        }
+      })
+    );
+  } finally {
+    ctx.res.end();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleCompletions
+});

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

@@ -0,0 +1,22 @@
+import { Context } from '@nocobase/actions';
+import type PluginAiApiServer from '../plugin';
+/**
+ * POST /api/ai-llm/v1/embeddings
+ *
+ * OpenAI-compatible embeddings endpoint.
+ *
+ * Supported providers (those with an `embedding` field in LLMProviderMeta):
+ *   - openai            → OpenAiEmbeddingProvider
+ *   - openai-completions → OpenAiEmbeddingProvider
+ *   - dashscope         → DashscopeEmbeddingProvider
+ *   - google-genai      → GoogleGenAIEmbeddingProvider
+ *   - ollama            → OllamaEmbeddingProvider
+ *
+ * Not supported: anthropic, deepseek, kimi (no embedding provider registered).
+ *
+ * Limitations:
+ * - encoding_format 'base64' is not supported (always returns float arrays)
+ * - Token counts always return 0 (LangChain embeddings API doesn't expose this)
+ * - Token array input (integer[]) is not supported, only string input
+ */
+export declare function handleEmbeddings(ctx: Context, plugin: PluginAiApiServer): Promise<void>;

package/dist/server/routes/embeddings.js

@@ -0,0 +1,166 @@
+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 embeddings_exports = {};
+__export(embeddings_exports, {
+  handleEmbeddings: () => handleEmbeddings
+});
+module.exports = __toCommonJS(embeddings_exports);
+var import_openai_format = require("../utils/openai-format");
+var import_resolve_service = require("../utils/resolve-service");
+async function handleEmbeddings(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.input === void 0 || body.input === null) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'input' is required", "invalid_request_error", "missing_input");
+    return;
+  }
+  if (body.encoding_format === "base64") {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      "encoding_format 'base64' is not supported. Use 'float' (default) or omit the parameter.",
+      "invalid_request_error",
+      "unsupported_encoding_format"
+    );
+    return;
+  }
+  let inputs;
+  if (typeof body.input === "string") {
+    inputs = [body.input];
+  } else if (Array.isArray(body.input)) {
+    if (body.input.length === 0) {
+      ctx.status = 400;
+      ctx.body = (0, import_openai_format.toOpenAIError)(400, "'input' array must not be empty", "invalid_request_error");
+      return;
+    }
+    if (typeof body.input[0] === "number") {
+      ctx.status = 400;
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        400,
+        "Token array input is not supported. Please provide string input.",
+        "invalid_request_error",
+        "unsupported_input_type"
+      );
+      return;
+    }
+    inputs = body.input;
+  } else {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'input' must be a string or array of strings", "invalid_request_error");
+    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 list 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 '${service.title || service.name}' is disabled`,
+      "invalid_request_error",
+      "model_not_found"
+    );
+    return;
+  }
+  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;
+      }
+    }
+  } catch {
+  }
+  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;
+  }
+  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;
+  }
+  if (!providerMeta.embedding) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `Provider '${providerMeta.title || service.provider}' does not support embeddings. Embedding-capable providers: openai, openai-completions, dashscope, google-genai, ollama.`,
+      "invalid_request_error",
+      "model_not_supported"
+    );
+    return;
+  }
+  try {
+    const EmbeddingClass = providerMeta.embedding;
+    const embeddingProvider = new EmbeddingClass({
+      app: ctx.app,
+      serviceOptions: service.options,
+      // Contains apiKey, baseURL, etc.
+      modelOptions: { model: modelId }
+      // The specific embedding model
+    });
+    const embeddingModel = embeddingProvider.createEmbedding();
+    const vectors = await embeddingModel.embedDocuments(inputs);
+    ctx.status = 200;
+    ctx.set("Content-Type", "application/json");
+    ctx.body = (0, import_openai_format.toOpenAIEmbeddingsResponse)({
+      model: body.model,
+      embeddings: vectors,
+      // LangChain's EmbeddingsInterface does not expose token counts.
+      promptTokens: 0
+    });
+  } catch (err) {
+    ctx.log.error("AI API embeddings error:", err);
+    if (!ctx.res.headersSent) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, err.message || "Failed to generate embeddings", "server_error");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleEmbeddings
+});

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

@@ -0,0 +1,21 @@
+import { Context } from '@nocobase/actions';
+import type PluginAiApiServer from '../plugin';
+/**
+ * GET /api/ai-llm/v1/models
+ *
+ * Lists all available models from enabled LLM services.
+ * Model IDs use the "serviceName/modelId" format (e.g. "my-openai/gpt-4o")
+ * so clients can copy-paste the ID directly into POST /v1/chat/completions
+ * without needing to configure a defaultLlmService.
+ *
+ * Backward compatibility: resolveModelString() in resolve-service.ts still
+ * accepts bare model IDs via its 3-tier fallback (defaultLlmService / single service).
+ */
+export declare function handleListModels(ctx: Context, plugin: PluginAiApiServer): Promise<void>;
+/**
+ * GET /api/ai-llm/v1/models/:model
+ *
+ * Retrieve a single model by ID.
+ * Accepts both "serviceName/modelId" format (new) and bare "modelId" (backward compat).
+ */
+export declare function handleGetModel(ctx: Context, modelId: string, plugin: PluginAiApiServer): Promise<void>;

package/dist/server/routes/models.js

@@ -0,0 +1,154 @@
+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 models_exports = {};
+__export(models_exports, {
+  handleGetModel: () => handleGetModel,
+  handleListModels: () => handleListModels
+});
+module.exports = __toCommonJS(models_exports);
+var import_openai_format = require("../utils/openai-format");
+async function handleListModels(ctx, plugin) {
+  var _a;
+  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;
+    }
+    const config = await getPluginConfig(ctx);
+    const filter = {};
+    if ((_a = config == null ? void 0 : config.enabledLlmServices) == null ? void 0 : _a.length) {
+      filter.$or = [
+        { name: { $in: config.enabledLlmServices } },
+        { title: { $in: config.enabledLlmServices } }
+      ];
+    }
+    const services = await ctx.db.getRepository("llmServices").find({
+      filter,
+      sort: "sort"
+    });
+    const now = Math.floor(Date.now() / 1e3);
+    const models = [];
+    for (const service of services) {
+      if (service.enabled === false) continue;
+      const enabledModels = resolveEnabledModels(service);
+      const serviceLabel = service.title || service.name;
+      for (const model of enabledModels) {
+        models.push({
+          // Use "serviceName/modelId" format so the ID can be used directly in
+          // POST /v1/chat/completions without ambiguity in multi-service setups.
+          id: `${service.name}/${model.value}`,
+          object: "model",
+          created: now,
+          owned_by: serviceLabel
+        });
+      }
+    }
+    ctx.status = 200;
+    ctx.body = {
+      object: "list",
+      data: models
+    };
+  } catch (err) {
+    ctx.log.error("AI API list models error:", err);
+    ctx.status = 500;
+    ctx.body = (0, import_openai_format.toOpenAIError)(500, "Failed to list models", "server_error");
+  }
+}
+async function handleGetModel(ctx, modelId, plugin) {
+  var _a;
+  try {
+    const config = await getPluginConfig(ctx);
+    const filter = {};
+    if ((_a = config == null ? void 0 : config.enabledLlmServices) == null ? void 0 : _a.length) {
+      filter.$or = [
+        { name: { $in: config.enabledLlmServices } },
+        { title: { $in: config.enabledLlmServices } }
+      ];
+    }
+    const services = await ctx.db.getRepository("llmServices").find({
+      filter,
+      sort: "sort"
+    });
+    const now = Math.floor(Date.now() / 1e3);
+    let found = null;
+    for (const service of services) {
+      if (service.enabled === false) 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) {
+          found = {
+            id: fullId,
+            object: "model",
+            created: now,
+            owned_by: serviceLabel
+          };
+          break;
+        }
+      }
+      if (found) break;
+    }
+    if (!found) {
+      ctx.status = 404;
+      ctx.body = (0, import_openai_format.toOpenAIError)(404, `Model '${modelId}' not found`, "invalid_request_error", "model_not_found");
+      return;
+    }
+    ctx.status = 200;
+    ctx.body = found;
+  } catch (err) {
+    ctx.log.error("AI API get model error:", err);
+    ctx.status = 500;
+    ctx.body = (0, import_openai_format.toOpenAIError)(500, "Failed to retrieve model", "server_error");
+  }
+}
+async function getPluginConfig(ctx) {
+  return ctx.db.getRepository("aiApiConfig").findOne();
+}
+function resolveEnabledModels(service) {
+  const raw = service.enabledModels;
+  if (raw && typeof raw === "object" && !Array.isArray(raw) && raw.mode) {
+    if (raw.mode === "recommended") {
+      return getRecommendedModelsForProvider(service.provider);
+    }
+    return (raw.models || []).filter((m) => m.value).map((m) => ({ label: m.label || m.value, value: m.value }));
+  }
+  if (Array.isArray(raw)) {
+    if (raw.length === 0) {
+      return getRecommendedModelsForProvider(service.provider);
+    }
+    return raw.map((id) => ({ label: id, value: id }));
+  }
+  return getRecommendedModelsForProvider(service.provider);
+}
+function getRecommendedModelsForProvider(provider) {
+  try {
+    const { getRecommendedModels } = require("@nocobase/plugin-ai/src/common/recommended-models");
+    const models = getRecommendedModels(provider);
+    return Array.isArray(models) ? models : [];
+  } catch {
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleGetModel,
+  handleListModels
+});

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

@@ -0,0 +1,25 @@
+import type PluginAiApiServer from '../plugin';
+/**
+ * Main Koa middleware router for OpenAI-compatible endpoints.
+ *
+ * Intercepts all requests to /api/ai-llm/v1/* and routes them
+ * to the appropriate handler. Runs before NocoBase's resourcer
+ * so the URL paths follow OpenAI convention.
+ *
+ * Features:
+ * - CORS support (Access-Control-Allow-Origin: *)
+ * - OPTIONS preflight handling (204)
+ * - X-Request-Id on every response
+ * - Bearer token authentication
+ * - Sliding window rate limiting (enforces rateLimitPerMinute from config)
+ * - Structured request logging via app.logger
+ *
+ * Supported endpoints:
+ *   POST /v1/chat/completions  — OpenAI chat completions (LLM or agent mode)
+ *   POST /v1/completions       — Legacy text completions (LiteLLM compat)
+ *   POST /v1/embeddings        — OpenAI embeddings
+ *   GET  /v1/models            — List available models
+ *   GET  /v1/models/:id        — Get a single model
+ *   DELETE /v1/models/:id      — Not implemented (501 stub)
+ */
+export declare function createAiLlmRouter(plugin: PluginAiApiServer): (ctx: Context, next: Next) => Promise<any>;