koishi-plugin-chatluna-mcp-server 1.0.0

package/lib/index.mjs

@@ -0,0 +1,838 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { createLogger } from "koishi-plugin-chatluna/utils/logger";
+
+// src/plugins/config.ts
+import { Schema } from "koishi";
+import { computed, watch } from "koishi-plugin-chatluna";
+import {
+  embeddingsSchema,
+  modelSchema
+} from "koishi-plugin-chatluna/utils/schema";
+async function apply(ctx, config) {
+  modelSchema(ctx);
+  embeddingsSchema(ctx);
+  const tools = ctx.chatluna.platform.getTools();
+  const toolSchema = computed(() => {
+    const names = tools.value;
+    if (names.length === 0) {
+      return [Schema.const("无").description("无")];
+    }
+    return names.map((name2) => Schema.const(name2).description(name2));
+  });
+  const watcher = watch(
+    toolSchema,
+    (schemas) => {
+      ctx.schema.set("chatluna-tool", Schema.union(schemas));
+    },
+    { immediate: true }
+  );
+  ctx.effect(() => () => watcher.stop());
+}
+__name(apply, "apply");
+
+// src/plugins.ts
+async function plugins(ctx, parent) {
+  const middlewares = [apply];
+  for (const middleware of middlewares) {
+    await middleware(ctx, parent);
+  }
+}
+__name(plugins, "plugins");
+
+// src/service/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import {
+  isInitializeRequest
+} from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "crypto";
+import { emptyEmbeddings } from "koishi-plugin-chatluna/llm-core/model/in_memory";
+
+// src/utils.ts
+import { getMessageContent } from "koishi-plugin-chatluna/utils/string";
+function normalizeEndpointPath(path) {
+  const trimmed = (path || "").trim();
+  if (!trimmed) {
+    return "/mcp";
+  }
+  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  if (withSlash.length > 1 && withSlash.endsWith("/")) {
+    return withSlash.slice(0, -1);
+  }
+  return withSlash;
+}
+__name(normalizeEndpointPath, "normalizeEndpointPath");
+function getHeaderValue(headers, name2) {
+  const key = Object.keys(headers).find(
+    (header) => header.toLowerCase() === name2.toLowerCase()
+  );
+  if (!key) {
+    return void 0;
+  }
+  const value = headers[key];
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+__name(getHeaderValue, "getHeaderValue");
+function parseJsonPayload(value) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value === "object") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+  }
+  try {
+    const decoded = Buffer.from(value, "base64").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+  }
+  return null;
+}
+__name(parseJsonPayload, "parseJsonPayload");
+function formatToolOutput(output) {
+  if (output == null) {
+    return "";
+  }
+  if (typeof output === "string") {
+    return output;
+  }
+  if (Array.isArray(output)) {
+    return getMessageContent(output);
+  }
+  if (typeof output === "object" && "content" in output) {
+    return getMessageContent(
+      output.content
+    );
+  }
+  if (typeof output === "object" && "text" in output) {
+    const text = output.text;
+    if (typeof text === "string") {
+      return text;
+    }
+  }
+  try {
+    return JSON.stringify(output, null, 2);
+  } catch {
+    return String(output);
+  }
+}
+__name(formatToolOutput, "formatToolOutput");
+
+// src/service/mcp.ts
+import { isZodSchemaV3 } from "@langchain/core/utils/types";
+import { z } from "zod/v3";
+var PLACEHOLDER_TOOL = "chatluna_placeholder";
+var TOOL_META_FIELD = "_meta_chatluna";
+var McpServerBridge = class {
+  constructor(ctx, config, logger2) {
+    this.ctx = ctx;
+    this.config = config;
+    this.logger = logger2;
+    this.endpointPath = normalizeEndpointPath(config.endpointPath);
+    this.registerRoutes();
+    this.bindEvents();
+    this.ctx.logger.success("available at %c", this.buildAccessUrl());
+  }
+  static {
+    __name(this, "McpServerBridge");
+  }
+  endpointPath;
+  tools = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  refreshing = false;
+  refreshQueued = false;
+  modelCache = /* @__PURE__ */ new Map();
+  embeddingsCache = /* @__PURE__ */ new Map();
+  async init() {
+    await this.refreshTools();
+  }
+  async dispose() {
+    for (const [sessionId, state] of this.sessions) {
+      try {
+        await state.transport.close();
+      } catch (error) {
+        this.logger.warn(
+          `Failed to close MCP transport ${sessionId}`,
+          error
+        );
+      }
+      try {
+        await state.server.close();
+      } catch (error) {
+        this.logger.warn(
+          `Failed to close MCP server ${sessionId}`,
+          error
+        );
+      }
+    }
+    this.sessions.clear();
+  }
+  bindEvents() {
+    this.ctx.on("ready", async () => {
+      await this.refreshTools();
+    });
+    this.ctx.on("chatluna/tool-updated", async () => {
+      try {
+        await this.refreshTools();
+      } catch (error) {
+      }
+    });
+  }
+  registerRoutes() {
+    const isRequestAuthorized = /* @__PURE__ */ __name((req) => {
+      if (!this.config.auth?.enabled) {
+        return true;
+      }
+      const url = new URL(req.url ?? "", "http://localhost");
+      const key = url.searchParams.get("key");
+      return !!key && key === this.config.auth.key;
+    }, "isRequestAuthorized");
+    const handleSessionRequest = /* @__PURE__ */ __name(async (koa) => {
+      const { req, res } = koa;
+      try {
+        if (!isRequestAuthorized(req)) {
+          res.statusCode = 401;
+          res.end("Unauthorized");
+          return;
+        }
+        const sessionHeader = req.headers["mcp-session-id"];
+        const sessionId = Array.isArray(sessionHeader) ? sessionHeader[0] : sessionHeader;
+        if (!sessionId || !this.sessions.has(sessionId)) {
+          res.statusCode = 400;
+          res.end("Invalid or missing session ID");
+          return;
+        }
+        const state = this.sessions.get(sessionId);
+        await state.transport.handleRequest(req, res);
+      } catch (error) {
+        this.logger.warn("Failed to handle MCP request", error);
+        if (!res.headersSent) {
+          res.statusCode = 500;
+          res.end("Internal server error");
+        }
+      }
+    }, "handleSessionRequest");
+    this.ctx.server.post(this.endpointPath, async (koa) => {
+      koa.respond = false;
+      const { req, res } = koa;
+      try {
+        if (!isRequestAuthorized(req)) {
+          res.statusCode = 401;
+          res.end("Unauthorized");
+          return;
+        }
+        const sessionHeader = req.headers["mcp-session-id"];
+        const sessionId = Array.isArray(sessionHeader) ? sessionHeader[0] : sessionHeader;
+        const parsedBody = koa.request?.body;
+        if (sessionId && this.sessions.has(sessionId)) {
+          const state = this.sessions.get(sessionId);
+          await state.transport.handleRequest(req, res, parsedBody);
+          return;
+        }
+        if (parsedBody && isInitializeRequest(parsedBody)) {
+          const state = this.createSessionState();
+          await state.server.connect(state.transport);
+          await state.transport.handleRequest(req, res, parsedBody);
+          return;
+        }
+        res.writeHead(400).end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Bad Request: No valid session ID provided"
+            },
+            id: null
+          })
+        );
+      } catch (error) {
+        this.logger.warn("Failed to handle MCP POST request", error);
+        if (!res.headersSent) {
+          res.writeHead(500).end(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32603,
+                message: "Internal server error"
+              },
+              id: null
+            })
+          );
+        }
+      }
+    });
+    this.ctx.server.get(this.endpointPath, async (koa) => {
+      koa.respond = false;
+      await handleSessionRequest(koa);
+    });
+    this.ctx.server.delete(
+      this.endpointPath,
+      async (koa) => {
+        koa.respond = false;
+        await handleSessionRequest(koa);
+      }
+    );
+  }
+  buildAccessUrl() {
+    const base = this.ctx.server.selfUrl + this.config.endpointPath;
+    if (!this.config.auth?.enabled) {
+      return base;
+    }
+    const key = this.config.auth.key;
+    return `${base}?key=${encodeURIComponent(key)}`;
+  }
+  async refreshTools() {
+    if (this.refreshing) {
+      this.refreshQueued = true;
+      return;
+    }
+    this.refreshing = true;
+    try {
+      const nextTools = await this.collectTools();
+      this.tools = nextTools;
+      for (const state of this.sessions.values()) {
+        this.syncSessionTools(state);
+      }
+    } finally {
+      this.refreshing = false;
+      if (this.refreshQueued) {
+        this.refreshQueued = false;
+        await this.refreshTools();
+      }
+    }
+  }
+  async collectTools() {
+    const toolNames = this.ctx.chatluna.platform.getTools().value;
+    const blacklist = new Set(this.config.toolBlacklist ?? []);
+    const embeddings = await this.getEmbeddings();
+    const nextTools = /* @__PURE__ */ new Map();
+    for (const name2 of toolNames) {
+      if (blacklist.has(name2)) {
+        continue;
+      }
+      try {
+        const toolCreator = this.ctx.chatluna.platform.getTool(name2);
+        const tool = toolCreator.createTool({ embeddings });
+        nextTools.set(name2, {
+          name: name2,
+          description: tool.description ?? "",
+          schema: tool.schema,
+          tool
+        });
+      } catch (error) {
+        this.logger.warn(
+          `Failed to create ChatLuna tool ${name2}`,
+          error
+        );
+      }
+    }
+    return nextTools;
+  }
+  createSessionState() {
+    const server = new McpServer(
+      {
+        name: "chatluna-mcp-server",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          logging: {}
+        }
+      }
+    );
+    const state = {
+      server,
+      transport: new StreamableHTTPServerTransport({
+        sessionIdGenerator: /* @__PURE__ */ __name(() => randomUUID(), "sessionIdGenerator"),
+        onsessioninitialized: /* @__PURE__ */ __name((sessionId) => {
+          this.sessions.set(sessionId, state);
+        }, "onsessioninitialized"),
+        onsessionclosed: /* @__PURE__ */ __name((sessionId) => {
+          if (sessionId) {
+            this.sessions.delete(sessionId);
+          }
+        }, "onsessionclosed")
+      }),
+      tools: /* @__PURE__ */ new Map()
+    };
+    state.transport.onclose = async () => {
+      if (state.transport.sessionId) {
+        this.sessions.delete(state.transport.sessionId);
+      }
+    };
+    this.registerInitialTools(state);
+    return state;
+  }
+  registerInitialTools(state) {
+    if (this.tools.size === 0) {
+      const placeholder = state.server.registerTool(
+        PLACEHOLDER_TOOL,
+        {
+          description: "internal placeholder",
+          inputSchema: this.extendToolSchema()
+        },
+        async () => ({
+          content: [
+            {
+              type: "text",
+              text: "No tools available"
+            }
+          ]
+        })
+      );
+      placeholder.disable();
+      state.tools.set(PLACEHOLDER_TOOL, placeholder);
+      return;
+    }
+    for (const entry of this.tools.values()) {
+      this.registerTool(state, entry);
+    }
+  }
+  syncSessionTools(state) {
+    if (this.tools.size === 0) {
+      if (!state.tools.has(PLACEHOLDER_TOOL)) {
+        const placeholder = state.server.registerTool(
+          PLACEHOLDER_TOOL,
+          {
+            description: "internal placeholder",
+            inputSchema: this.extendToolSchema()
+          },
+          async () => ({
+            content: [
+              {
+                type: "text",
+                text: "No tools available"
+              }
+            ]
+          })
+        );
+        placeholder.disable();
+        state.tools.set(PLACEHOLDER_TOOL, placeholder);
+      }
+      for (const name2 of Array.from(state.tools.keys())) {
+        if (name2 !== PLACEHOLDER_TOOL) {
+          const registered = state.tools.get(name2);
+          registered?.remove?.();
+          state.tools.delete(name2);
+        }
+      }
+      return;
+    }
+    if (state.tools.has(PLACEHOLDER_TOOL)) {
+      const placeholder = state.tools.get(PLACEHOLDER_TOOL);
+      placeholder?.remove?.();
+      state.tools.delete(PLACEHOLDER_TOOL);
+    }
+    for (const entry of this.tools.values()) {
+      if (!state.tools.has(entry.name)) {
+        this.registerTool(state, entry);
+        continue;
+      }
+      const registered = state.tools.get(entry.name);
+      registered?.update?.({
+        description: entry.description,
+        paramsSchema: this.extendToolSchema(entry.schema)
+      });
+    }
+    for (const name2 of Array.from(state.tools.keys())) {
+      if (!this.tools.has(name2)) {
+        const registered = state.tools.get(name2);
+        registered?.remove?.();
+        state.tools.delete(name2);
+      }
+    }
+  }
+  registerTool(state, entry) {
+    const registered = state.server.registerTool(
+      entry.name,
+      {
+        description: entry.description,
+        inputSchema: this.extendToolSchema(entry.schema)
+      },
+      async (argsOrExtra, extraMaybe) => {
+        const extra = extraMaybe ?? argsOrExtra;
+        const args = extraMaybe == null ? {} : argsOrExtra;
+        return await this.handleToolCall(entry.name, args, extra);
+      }
+    );
+    state.tools.set(entry.name, registered);
+  }
+  async handleToolCall(toolName, args, extra) {
+    const entry = this.tools.get(toolName);
+    if (!entry) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Tool ${toolName} not available`
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      const {
+        args: cleanedArgs,
+        meta: inputMeta,
+        hasMeta: hasInputMeta
+      } = this.extractToolInputMeta(args);
+      const { payload: extraMeta, hasMeta: hasExtraMeta } = this.extractMeta(extra);
+      const meta = this.applyMetaDefaults(
+        hasExtraMeta ? extraMeta : hasInputMeta ? inputMeta : {}
+      );
+      const session = this.buildSession(meta.session);
+      const model = await this.getModel();
+      if (!model) {
+        throw new Error("Model not available");
+      }
+      const runnableConfig = {
+        configurable: {
+          model,
+          session,
+          conversationId: session.guildId ?? session.channelId,
+          userId: meta.userId ?? session.userId
+        }
+      };
+      const result = await entry.tool.invoke(
+        cleanedArgs ?? {},
+        runnableConfig
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatToolOutput(result)
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: error instanceof Error ? error.message : String(error)
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  extractMeta(extra) {
+    const extraObj = extra;
+    const metaRoot = extraObj?._meta ?? null;
+    const headers = extraObj?.requestInfo?.headers ?? {};
+    const headerSession = parseJsonPayload(getHeaderValue(headers, "x-chatluna-session")) ?? parseJsonPayload(getHeaderValue(headers, "x-koishi-session"));
+    return this.extractMetaFromRoot(metaRoot, headerSession);
+  }
+  extractMetaFromRoot(metaRoot, headerSession) {
+    const payload = {};
+    const meta = this.normalizeMetaRoot(metaRoot);
+    const sessionMeta = parseJsonPayload(meta.session);
+    const session = sessionMeta ?? headerSession;
+    if (session) {
+      payload.session = session;
+    }
+    if (typeof meta.userId === "string") {
+      payload.userId = meta.userId;
+    }
+    const hasMeta = Object.keys(payload).length > 0;
+    return { payload, hasMeta };
+  }
+  normalizeMetaRoot(metaRoot) {
+    if (!metaRoot) {
+      return {};
+    }
+    return metaRoot;
+  }
+  extractToolInputMeta(args) {
+    if (!args || typeof args !== "object") {
+      return { args: {}, meta: {}, hasMeta: false };
+    }
+    if (!Object.prototype.hasOwnProperty.call(args, TOOL_META_FIELD)) {
+      return { args, meta: {}, hasMeta: false };
+    }
+    const cleanedArgs = { ...args };
+    const metaContainer = cleanedArgs[TOOL_META_FIELD];
+    delete cleanedArgs[TOOL_META_FIELD];
+    const metaRoot = parseJsonPayload(metaContainer);
+    const { payload, hasMeta } = this.extractMetaFromRoot(metaRoot, null);
+    return { args: cleanedArgs, meta: payload, hasMeta };
+  }
+  applyMetaDefaults(meta) {
+    const payload = { ...meta };
+    if (!payload.session) {
+      payload.session = this.buildDefaultSessionPayload();
+      return payload;
+    }
+    if (typeof payload.session === "string") {
+      const parsed = parseJsonPayload(payload.session);
+      if (parsed && Object.keys(parsed).length > 0) {
+        payload.session = parsed;
+      } else {
+        payload.session = this.buildDefaultSessionPayload();
+      }
+      return payload;
+    }
+    if (Object.keys(payload.session).length === 0) {
+      payload.session = this.buildDefaultSessionPayload();
+    }
+    return payload;
+  }
+  buildSession(sessionPayload) {
+    const payload = parseJsonPayload(sessionPayload) ?? sessionPayload ?? this.buildDefaultSessionPayload();
+    const bot = this.resolveBot(payload);
+    if (!bot) {
+      throw new Error("No bot available for MCP session");
+    }
+    const event = {
+      type: "message"
+    };
+    if (payload.userId) {
+      event.user = { id: payload.userId };
+    }
+    if (payload.channelId) {
+      event.channel = { id: payload.channelId, type: 0 };
+    }
+    if (payload.guildId) {
+      event.guild = { id: payload.guildId };
+    }
+    const session = bot.session(event);
+    if (payload.message) {
+      session.content = payload.message;
+    }
+    return session;
+  }
+  buildDefaultSessionPayload() {
+    const defaults = this.config.session ?? {
+      defaultBot: "",
+      userId: "",
+      channelId: "",
+      guildId: "",
+      message: ""
+    };
+    const botTarget = this.parseBotTarget(defaults.defaultBot);
+    return {
+      platform: botTarget?.platform,
+      selfId: botTarget?.selfId,
+      userId: defaults.userId || void 0,
+      channelId: defaults.channelId || void 0,
+      guildId: defaults.guildId || void 0,
+      message: defaults.message || void 0
+    };
+  }
+  resolveBot(payload) {
+    const fallback = this.parseBotTarget(this.config.session?.defaultBot);
+    const targetPlatform = payload.platform ?? fallback?.platform;
+    const targetSelfId = payload.selfId ?? fallback?.selfId;
+    const bots = this.getBotList();
+    let bot = bots.find(
+      (candidate) => (!targetPlatform || candidate.platform === targetPlatform) && (!targetSelfId || candidate.selfId === targetSelfId)
+    );
+    if (!bot && targetPlatform) {
+      bot = bots.find(
+        (candidate) => candidate.platform === targetPlatform
+      );
+    }
+    return bot ?? bots[0];
+  }
+  getBotList() {
+    if (Array.isArray(this.ctx.bots)) {
+      return this.ctx.bots;
+    }
+    return Object.values(this.ctx.bots);
+  }
+  parseBotTarget(value) {
+    if (!value) {
+      return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const parts = trimmed.split(":");
+    if (parts.length >= 2) {
+      return {
+        platform: parts[0],
+        selfId: parts.slice(1).join(":")
+      };
+    }
+    return { selfId: trimmed };
+  }
+  resolveModelName(override) {
+    if (override && override !== "无") {
+      return override;
+    }
+    if (this.config.defaultModel && this.config.defaultModel !== "无") {
+      return this.config.defaultModel;
+    }
+    if (this.ctx.chatluna.config.defaultModel && this.ctx.chatluna.config.defaultModel !== "无") {
+      return this.ctx.chatluna.config.defaultModel;
+    }
+    return void 0;
+  }
+  resolveEmbeddingsName() {
+    if (this.config.defaultEmbeddings && this.config.defaultEmbeddings !== "无") {
+      return this.config.defaultEmbeddings;
+    }
+    if (this.ctx.chatluna.config.defaultEmbeddings && this.ctx.chatluna.config.defaultEmbeddings !== "无") {
+      return this.ctx.chatluna.config.defaultEmbeddings;
+    }
+    return void 0;
+  }
+  async getModel(override) {
+    const modelName = this.resolveModelName(override);
+    if (!modelName) {
+      return void 0;
+    }
+    const cached = this.modelCache.get(modelName);
+    if (cached) {
+      return cached.value;
+    }
+    const modelRef = await this.ctx.chatluna.createChatModel(modelName);
+    this.modelCache.set(modelName, modelRef);
+    return modelRef.value;
+  }
+  async getEmbeddings() {
+    const embeddingsName = this.resolveEmbeddingsName();
+    if (!embeddingsName) {
+      return emptyEmbeddings;
+    }
+    const cached = this.embeddingsCache.get(embeddingsName);
+    if (cached) {
+      return cached.value ?? emptyEmbeddings;
+    }
+    const embeddingsRef = await this.ctx.chatluna.createEmbeddings(embeddingsName);
+    this.embeddingsCache.set(embeddingsName, embeddingsRef);
+    return embeddingsRef.value ?? emptyEmbeddings;
+  }
+  extendToolSchema(schema) {
+    const sessionSchema = z.object({
+      platform: z.string().optional().describe('Bot platform name, e.g. "discord".'),
+      selfId: z.string().optional().describe("Bot self ID on the target platform."),
+      userId: z.string().optional().describe("User ID for the tool call session."),
+      channelId: z.string().optional().describe("Channel ID for the tool call session."),
+      guildId: z.string().optional().describe("Guild ID for the tool call session."),
+      message: z.string().optional().describe("Message content injected into the session.")
+    }).strict().describe("Structured session data for the tool call.");
+    const metaSchema = z.object({
+      session: sessionSchema.describe("Session payload."),
+      userId: z.string().optional().describe("User ID override for tool runtime.")
+    }).strict().optional().describe(
+      "Meta payload for ChatLuna tool execution. (If needed the userId/guildId)"
+    );
+    if (!schema) {
+      return z.object({ [TOOL_META_FIELD]: metaSchema });
+    }
+    if (!isZodSchemaV3(schema)) {
+      return schema;
+    }
+    const typeName = schema._def?.typeName;
+    if (typeName !== "ZodObject") {
+      return schema;
+    }
+    const objectSchema = schema;
+    const shape = typeof objectSchema._def.shape === "function" ? objectSchema._def.shape() : objectSchema._def.shape;
+    const mergedShape = {
+      ...shape,
+      [TOOL_META_FIELD]: metaSchema
+    };
+    let merged = z.object(mergedShape);
+    const unknownKeys = objectSchema._def.unknownKeys;
+    if (unknownKeys === "passthrough") {
+      merged = merged.passthrough();
+    } else if (unknownKeys === "strict") {
+      merged = merged.strict();
+    }
+    const catchall = objectSchema._def.catchall;
+    if (catchall) {
+      merged = merged.catchall(catchall);
+    }
+    return merged;
+  }
+};
+
+// src/config.ts
+import { createHash } from "crypto";
+import { Schema as Schema2 } from "koishi";
+var DEFAULT_AUTH_KEY = (() => {
+  const seed = `${process.cwd()}|chatluna-mcp-server`;
+  const hash = createHash("sha256").update(seed).digest("hex");
+  const value = BigInt(`0x${hash}`) % BigInt(36 ** 8);
+  return value.toString(36).padStart(8, "0").toUpperCase();
+})();
+var Config = Schema2.intersect([
+  Schema2.object({
+    endpointPath: Schema2.string().description("MCP 服务端路径（例如 /mcp 或 /mcp-foo）").default("/mcp"),
+    auth: Schema2.object({
+      enabled: Schema2.boolean().description("是否启用 URL 鉴权（/mcp?key=xxxxxx）").default(true),
+      key: Schema2.string().description("URL 鉴权密钥（默认固定的八位字母数字）").default(DEFAULT_AUTH_KEY)
+    })
+  }).description("服务端配置"),
+  Schema2.object({
+    defaultModel: Schema2.dynamic("model").description("默认使用的模型（选“无”则使用 ChatLuna 默认模型）").default("无"),
+    defaultEmbeddings: Schema2.dynamic("embeddings").description("默认使用的向量模型（选“无”则使用 ChatLuna 默认值）").default("无"),
+    toolBlacklist: Schema2.array(Schema2.dynamic("chatluna-tool")).description("不公开到 MCP 的工具").default([
+      "built_question",
+      "built_user_confirm",
+      "built_user_toast",
+      "file_read",
+      "file_write",
+      "file_list",
+      "file_grep",
+      "file_glob",
+      "file_rename",
+      "file_multi_rename",
+      "file_multi_write",
+      "file_update",
+      "web_fetcher",
+      "web_poster"
+    ])
+  }).description("工具配置"),
+  Schema2.object({
+    session: Schema2.object({
+      defaultBot: Schema2.string().description("默认 Bot（格式 platform:selfId）").default(""),
+      userId: Schema2.string().description("默认用户 ID").default(""),
+      channelId: Schema2.string().description("默认频道 ID").default(""),
+      guildId: Schema2.string().description("默认群组 ID").default(""),
+      message: Schema2.string().description("默认消息内容").default("")
+    })
+  }).description("会话配置")
+]);
+var name = "chatluna-mcp-server";
+
+// src/index.ts
+var logger;
+function apply2(ctx, config) {
+  logger = createLogger(ctx, "chatluna-mcp-server");
+  ctx.inject(["chatluna"], async (ctx2) => {
+    await plugins(ctx2, config);
+  });
+  ctx.inject(["chatluna", "server"], async (ctx2) => {
+    const bridge = new McpServerBridge(ctx2, config, logger);
+    await bridge.init();
+    ctx2.effect(() => () => bridge.dispose());
+  });
+}
+__name(apply2, "apply");
+var inject = {
+  required: ["chatluna", "server"]
+};
+export {
+  Config,
+  apply2 as apply,
+  inject,
+  logger,
+  name
+};