koishi-plugin-chatluna-anuneko-api-adapter 1.0.0

package/lib/anuneko-client.d.ts

@@ -0,0 +1,16 @@
+import { Context } from 'koishi';
+import { PlatformModelAndEmbeddingsClient } from 'koishi-plugin-chatluna/llm-core/platform/client';
+import { ChatLunaBaseEmbeddings, ChatLunaChatModel } from 'koishi-plugin-chatluna/llm-core/platform/model';
+import { ModelInfo } from 'koishi-plugin-chatluna/llm-core/platform/types';
+import { Config } from './index';
+import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
+import { RunnableConfig } from '@langchain/core/runnables';
+export declare class AnunekoClient extends PlatformModelAndEmbeddingsClient {
+    private _config;
+    plugin: ChatLunaPlugin;
+    platform: string;
+    private _requester;
+    constructor(ctx: Context, _config: Config, plugin: ChatLunaPlugin);
+    refreshModels(config?: RunnableConfig): Promise<ModelInfo[]>;
+    protected _createModel(model: string): ChatLunaChatModel | ChatLunaBaseEmbeddings;
+}

package/lib/anuneko-requester.d.ts

@@ -0,0 +1,20 @@
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { ModelRequester, ModelRequestParams } from 'koishi-plugin-chatluna/llm-core/platform/api';
+import { ClientConfig, ClientConfigPool } from 'koishi-plugin-chatluna/llm-core/platform/config';
+import { Config } from './index';
+import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
+import { Context } from 'koishi';
+export declare class AnunekoRequester extends ModelRequester {
+    _pluginConfig: Config;
+    private sessionMap;
+    private modelMap;
+    constructor(ctx: Context, _configPool: ClientConfigPool<ClientConfig>, _pluginConfig: Config, _plugin: ChatLunaPlugin);
+    clearSession(userId: string): boolean;
+    clearAllSessions(): number;
+    buildHeaders(): Record<string, string>;
+    private createNewSession;
+    private switchModel;
+    private sendChoice;
+    completionStreamInternal(params: ModelRequestParams): AsyncGenerator<ChatGenerationChunk>;
+    get logger(): import("reggol");
+}

package/lib/index.d.ts

@@ -0,0 +1,16 @@
+import { Context, Logger, Schema } from 'koishi';
+import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
+export declare let logger: Logger;
+export declare let anunekoClient: any;
+export declare const reusable = true;
+export declare const usage = "\n<p><strong>\u96F6\u6210\u672C\u3001\u5FEB\u901F\u4F53\u9A8CChatluna</strong>\u3002</p>\n<ul>\n<li><strong>API\u6765\u6E90\uFF1A</strong> anuneko.com</li>\n<li>\n<strong>\u63A5\u53E3\u5730\u5740\uFF1A</strong>\n<a href=\"https://anuneko.com\" target=\"_blank\" rel=\"noopener noreferrer\">https://anuneko.com</a>\n</li>\n</ul>\n<p><strong>\u8BF7\u6CE8\u610F\uFF1A</strong></p>\n<p>\u8BE5\u670D\u52A1\u9700\u8981\u914D\u7F6E\u6709\u6548\u7684 x-token \u624D\u80FD\u4F7F\u7528\u3002\u652F\u6301\u6A58\u732B(Orange Cat)\u548C\u9ED1\u732B(Exotic Shorthair)\u4E24\u79CD\u6A21\u578B\u3002</p>\n";
+export declare function apply(ctx: Context, config: Config): void;
+export interface Config extends ChatLunaPlugin.Config {
+    platform: string;
+    xToken: string;
+    cookie?: string;
+    loggerinfo: boolean;
+}
+export declare const Config: Schema<Config>;
+export declare const inject: string[];
+export declare const name = "chatluna-anuneko-api-adapter";

package/lib/index.js

@@ -0,0 +1,594 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], 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);
+
+// src/locales/zh-CN.schema.yml
+var require_zh_CN_schema = __commonJS({
+  "src/locales/zh-CN.schema.yml"(exports2, module2) {
+    module2.exports = { platform: "平台名称", xToken: "anuneko API 的 x-token", cookie: "anuneko API 的 Cookie（可选）", loggerinfo: "日志调试模式" };
+  }
+});
+
+// src/locales/en-US.schema.yml
+var require_en_US_schema = __commonJS({
+  "src/locales/en-US.schema.yml"(exports2, module2) {
+    module2.exports = { platform: "Platform name", xToken: "x-token for anuneko API", cookie: "Cookie for anuneko API (optional)", loggerinfo: "Logger debug mode" };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config2,
+  anunekoClient: () => anunekoClient,
+  apply: () => apply,
+  inject: () => inject,
+  logger: () => logger2,
+  name: () => name,
+  reusable: () => reusable,
+  usage: () => usage
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_chat = require("koishi-plugin-chatluna/services/chat");
+var import_error2 = require("koishi-plugin-chatluna/utils/error");
+var import_logger3 = require("koishi-plugin-chatluna/utils/logger");
+
+// src/anuneko-client.ts
+var import_client = require("koishi-plugin-chatluna/llm-core/platform/client");
+var import_model = require("koishi-plugin-chatluna/llm-core/platform/model");
+var import_types = require("koishi-plugin-chatluna/llm-core/platform/types");
+var import_error = require("koishi-plugin-chatluna/utils/error");
+
+// src/anuneko-requester.ts
+var import_outputs = require("@langchain/core/outputs");
+var import_api = require("koishi-plugin-chatluna/llm-core/platform/api");
+
+// src/logger.ts
+var logger;
+var config;
+function initializeLogger(newLogger, newConfig) {
+  logger = newLogger;
+  config = newConfig;
+}
+__name(initializeLogger, "initializeLogger");
+function logInfo(...args) {
+  if (config?.loggerinfo) {
+    logger?.info?.(...args);
+  }
+}
+__name(logInfo, "logInfo");
+
+// src/anuneko-requester.ts
+var import_messages = require("@langchain/core/messages");
+var sleep = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
+var AnunekoRequester = class extends import_api.ModelRequester {
+  constructor(ctx, _configPool, _pluginConfig, _plugin) {
+    super(ctx, _configPool, _pluginConfig, _plugin);
+    this._pluginConfig = _pluginConfig;
+  }
+  static {
+    __name(this, "AnunekoRequester");
+  }
+  // 存储每个用户的会话ID
+  sessionMap = /* @__PURE__ */ new Map();
+  // 存储每个用户的当前模型
+  modelMap = /* @__PURE__ */ new Map();
+  // 清理指定用户的会话
+  clearSession(userId) {
+    const hasSession = this.sessionMap.has(userId);
+    this.sessionMap.delete(userId);
+    this.modelMap.delete(userId);
+    return hasSession;
+  }
+  // 清理所有会话
+  clearAllSessions() {
+    const count = this.sessionMap.size;
+    this.sessionMap.clear();
+    this.modelMap.clear();
+    return count;
+  }
+  // 构建请求头
+  buildHeaders() {
+    const headers = {
+      "accept": "*/*",
+      "content-type": "application/json",
+      "origin": "https://anuneko.com",
+      "referer": "https://anuneko.com/",
+      "user-agent": "Mozilla/5.0",
+      "x-app_id": "com.anuttacon.neko",
+      "x-client_type": "4",
+      "x-device_id": "7b75a432-6b24-48ad-b9d3-3dc57648e3e3",
+      "x-token": this._pluginConfig.xToken
+    };
+    if (this._pluginConfig.cookie) {
+      headers["Cookie"] = this._pluginConfig.cookie;
+    }
+    return headers;
+  }
+  // 创建新会话
+  async createNewSession(userId, modelName) {
+    const headers = this.buildHeaders();
+    const data = { model: modelName };
+    try {
+      logInfo("Creating new session with model:", modelName);
+      const response = await fetch("https://anuneko.com/api/v1/chat", {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data)
+      });
+      const responseData = await response.json();
+      const chatId = responseData.chat_id || responseData.id;
+      if (chatId) {
+        this.sessionMap.set(userId, chatId);
+        this.modelMap.set(userId, modelName);
+        logInfo("New session created with ID:", chatId);
+        await this.switchModel(userId, chatId, modelName);
+        return chatId;
+      }
+    } catch (error) {
+      this.logger.error("Failed to create new session:", error);
+    }
+    return null;
+  }
+  // 切换模型
+  async switchModel(userId, chatId, modelName) {
+    const headers = this.buildHeaders();
+    const data = { chat_id: chatId, model: modelName };
+    try {
+      logInfo("Switching model to:", modelName);
+      const response = await fetch("https://anuneko.com/api/v1/user/select_model", {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data)
+      });
+      if (response.ok) {
+        this.modelMap.set(userId, modelName);
+        logInfo("Model switched successfully");
+        return true;
+      }
+    } catch (error) {
+      this.logger.error("Failed to switch model:", error);
+    }
+    return false;
+  }
+  // 自动选择分支
+  async sendChoice(msgId) {
+    const headers = this.buildHeaders();
+    const data = { msg_id: msgId, choice_idx: 0 };
+    try {
+      await fetch("https://anuneko.com/api/v1/msg/select-choice", {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data)
+      });
+      logInfo("Choice sent for msg_id:", msgId);
+    } catch (error) {
+      this.logger.error("Failed to send choice:", error);
+    }
+  }
+  // 流式回复
+  async *completionStreamInternal(params) {
+    const internalParams = params;
+    const humanMessages = internalParams.input.filter(
+      (message) => message instanceof import_messages.HumanMessage
+    );
+    const lastMessage = humanMessages.at(-1);
+    logInfo("Receive params from chatluna", JSON.stringify(params, null, 2));
+    if (!lastMessage) {
+      this.logger.warn("No human message found in the input.");
+      return;
+    }
+    const prompt = lastMessage.content;
+    const sessionKey = lastMessage.channelId || lastMessage.id || "default";
+    logInfo("使用会话标识:", sessionKey);
+    let modelName = "Orange Cat";
+    if (params.model.includes("exotic") || params.model.includes("shorthair")) {
+      modelName = "Exotic Shorthair";
+    }
+    let sessionId = this.sessionMap.get(sessionKey);
+    const currentModel = this.modelMap.get(sessionKey);
+    if (!sessionId || currentModel !== modelName) {
+      sessionId = await this.createNewSession(sessionKey, modelName);
+      if (!sessionId) {
+        const errorText = "创建会话失败，请稍后再试。";
+        yield new import_outputs.ChatGenerationChunk({
+          text: errorText,
+          message: new import_messages.AIMessageChunk({ content: errorText })
+        });
+        return;
+      }
+    }
+    const headers = this.buildHeaders();
+    const url = `https://anuneko.com/api/v1/msg/${sessionId}/stream`;
+    const data = { contents: [prompt] };
+    let retries = 3;
+    while (retries > 0) {
+      try {
+        logInfo("Sending request to API:", url, JSON.stringify(data, null, 2));
+        let result = "";
+        let currentMsgId = null;
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(data)
+        });
+        if (!response.ok) {
+          throw new Error(`Request failed with status ${response.status}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const chunkStr = decoder.decode(value, { stream: true });
+          const lines = chunkStr.split("\n");
+          for (const line of lines) {
+            if (!line || !line.startsWith("data: ")) {
+              if (line.trim()) {
+                try {
+                  const errorJson = JSON.parse(line);
+                  if (errorJson.code === "chat_choice_shown") {
+                    const errorText = "⚠️ 检测到对话分支未选择，请重试或新建会话。";
+                    yield new import_outputs.ChatGenerationChunk({
+                      text: errorText,
+                      message: new import_messages.AIMessageChunk({ content: errorText })
+                    });
+                    return;
+                  }
+                } catch {
+                }
+              }
+              continue;
+            }
+            const rawJson = line.substring(6).trim();
+            if (!rawJson) continue;
+            try {
+              const j = JSON.parse(rawJson);
+              if (j.msg_id) {
+                currentMsgId = j.msg_id;
+              }
+              if (j.c && Array.isArray(j.c)) {
+                for (const choice of j.c) {
+                  const idx = choice.c ?? 0;
+                  if (idx === 0 && choice.v) {
+                    result += choice.v;
+                  }
+                }
+              } else if (j.v && typeof j.v === "string") {
+                result += j.v;
+              }
+            } catch (error) {
+              logInfo("Failed to parse JSON:", rawJson, error);
+            }
+          }
+        }
+        if (currentMsgId) {
+          await this.sendChoice(currentMsgId);
+        }
+        logInfo("Received complete response:", result);
+        yield new import_outputs.ChatGenerationChunk({
+          text: result,
+          message: new import_messages.AIMessageChunk({ content: result })
+        });
+        return;
+      } catch (error) {
+        this.logger.error(`Request failed, ${retries - 1} retries left.`, error);
+        retries--;
+        if (retries === 0) {
+          const errorText = `请求失败，请稍后再试: ${error.message}`;
+          yield new import_outputs.ChatGenerationChunk({
+            text: errorText,
+            message: new import_messages.AIMessageChunk({ content: errorText })
+          });
+        } else {
+          await sleep(1e3);
+        }
+      }
+    }
+  }
+  get logger() {
+    return logger2;
+  }
+};
+
+// src/anuneko-client.ts
+var import_v1_shared_adapter = require("@chatluna/v1-shared-adapter");
+var AnunekoClient = class extends import_client.PlatformModelAndEmbeddingsClient {
+  constructor(ctx, _config, plugin) {
+    super(ctx, plugin.platformConfigPool);
+    this._config = _config;
+    this.plugin = plugin;
+    this.platform = _config.platform;
+    this._requester = new AnunekoRequester(
+      ctx,
+      plugin.platformConfigPool,
+      _config,
+      plugin
+    );
+  }
+  static {
+    __name(this, "AnunekoClient");
+  }
+  platform = "anuneko";
+  _requester;
+  async refreshModels(config2) {
+    return [
+      {
+        name: "orange-cat",
+        type: import_types.ModelType.llm,
+        capabilities: [],
+        maxTokens: 128e3
+      },
+      {
+        name: "exotic-shorthair",
+        type: import_types.ModelType.llm,
+        capabilities: [],
+        maxTokens: 128e3
+      }
+    ];
+  }
+  _createModel(model) {
+    logInfo("[anuneko] _createModel called for model:", model);
+    logInfo("[anuneko] _modelInfos keys:", Object.keys(this._modelInfos));
+    const info = this._modelInfos[model];
+    logInfo("[anuneko] Model info:", JSON.stringify(info));
+    if (info == null) {
+      this.ctx.logger.error("[anuneko] Model info is null!");
+      throw new import_error.ChatLunaError(
+        import_error.ChatLunaErrorCode.MODEL_NOT_FOUND,
+        new Error(
+          `The model ${model} is not found in the models: ${JSON.stringify(Object.keys(this._modelInfos))}`
+        )
+      );
+    }
+    logInfo("[anuneko] Model type:", info.type, "Expected:", import_types.ModelType.llm);
+    logInfo("[anuneko] Type check:", info.type === import_types.ModelType.llm);
+    if (info.type === import_types.ModelType.llm) {
+      logInfo("[anuneko] Creating ChatLunaChatModel...");
+      const modelMaxContextSize = (0, import_v1_shared_adapter.getModelMaxContextSize)(info);
+      const chatModel = new import_model.ChatLunaChatModel({
+        modelInfo: info,
+        requester: this._requester,
+        model,
+        maxTokenLimit: info.maxTokens || modelMaxContextSize || 128e3,
+        modelMaxContextSize,
+        timeout: this._config.timeout,
+        maxRetries: this._config.maxRetries,
+        llmType: "openai",
+        isThinkModel: false
+      });
+      logInfo("[anuneko] ChatLunaChatModel created successfully");
+      logInfo("[anuneko] Instance check:", chatModel instanceof import_model.ChatLunaChatModel);
+      return chatModel;
+    }
+    this.ctx.logger.error("[anuneko] Model type is not LLM!");
+    throw new import_error.ChatLunaError(
+      import_error.ChatLunaErrorCode.MODEL_NOT_FOUND,
+      new Error(
+        `The model ${model} is not a chat model, type is ${info.type}`
+      )
+    );
+  }
+};
+
+// src/index.ts
+var logger2;
+var anunekoClient = null;
+var reusable = true;
+var usage = `
+<p><strong>零成本、快速体验Chatluna</strong>。</p>
+<ul>
+<li><strong>API来源：</strong> anuneko.com</li>
+<li>
+<strong>接口地址：</strong>
+<a href="https://anuneko.com" target="_blank" rel="noopener noreferrer">https://anuneko.com</a>
+</li>
+</ul>
+<p><strong>请注意：</strong></p>
+<p>该服务需要配置有效的 x-token 才能使用。支持橘猫(Orange Cat)和黑猫(Exotic Shorthair)两种模型。</p>
+`;
+function apply(ctx, config2) {
+  logger2 = (0, import_logger3.createLogger)(ctx, "chatluna-anuneko-api-adapter");
+  initializeLogger(logger2, config2);
+  ctx.command("anuneko <message:text>", "测试 anuneko API").action(async ({ session }, message) => {
+    if (!message) {
+      return "请输入消息内容，例如：/anuneko 你好";
+    }
+    try {
+      const headers = {
+        "accept": "*/*",
+        "content-type": "application/json",
+        "origin": "https://anuneko.com",
+        "referer": "https://anuneko.com/",
+        "user-agent": "Mozilla/5.0",
+        "x-app_id": "com.anuttacon.neko",
+        "x-client_type": "4",
+        "x-device_id": "7b75a432-6b24-48ad-b9d3-3dc57648e3e3",
+        "x-token": config2.xToken
+      };
+      if (config2.cookie) {
+        headers["Cookie"] = config2.cookie;
+      }
+      logger2.info("创建新会话...");
+      const createResponse = await fetch("https://anuneko.com/api/v1/chat", {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ model: "Orange Cat" })
+      });
+      const createData = await createResponse.json();
+      const chatId = createData.chat_id || createData.id;
+      if (!chatId) {
+        return "❌ 创建会话失败";
+      }
+      logger2.info("会话创建成功，ID:", chatId);
+      const url = `https://anuneko.com/api/v1/msg/${chatId}/stream`;
+      const data = { contents: [message] };
+      logger2.info("发送消息...");
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        return `❌ 请求失败: ${response.status} ${response.statusText}`;
+      }
+      let result = "";
+      let currentMsgId = null;
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunkStr = decoder.decode(value, { stream: true });
+        logger2.info("收到数据块:", chunkStr.substring(0, 200));
+        const lines = chunkStr.split("\n");
+        for (const line of lines) {
+          if (!line.trim()) {
+            continue;
+          }
+          logger2.info("处理行:", line.substring(0, 100));
+          if (!line.startsWith("data: ")) {
+            logger2.warn("非 data: 格式的行:", line);
+            continue;
+          }
+          const rawJson = line.substring(6).trim();
+          if (!rawJson) continue;
+          try {
+            const j = JSON.parse(rawJson);
+            logger2.info("解析的 JSON:", JSON.stringify(j));
+            if (j.msg_id) {
+              currentMsgId = j.msg_id;
+              logger2.info("更新 msg_id:", currentMsgId);
+            }
+            if (j.c && Array.isArray(j.c)) {
+              logger2.info("处理多分支内容");
+              for (const choice of j.c) {
+                const idx = choice.c ?? 0;
+                if (idx === 0 && choice.v) {
+                  result += choice.v;
+                  logger2.info("添加内容:", choice.v);
+                }
+              }
+            } else if (j.v && typeof j.v === "string") {
+              result += j.v;
+              logger2.info("添加常规内容:", j.v);
+            }
+          } catch (error) {
+            logger2.error("解析 JSON 失败:", rawJson, error);
+          }
+        }
+      }
+      logger2.info("最终结果长度:", result.length);
+      logger2.info("最终结果内容:", result);
+      if (currentMsgId) {
+        await fetch("https://anuneko.com/api/v1/msg/select-choice", {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ msg_id: currentMsgId, choice_idx: 0 })
+        });
+      }
+      logger2.info("收到完整响应");
+      return result || "❌ 未收到响应";
+    } catch (error) {
+      logger2.error("请求失败:", error);
+      return `❌ 请求失败: ${error.message}`;
+    }
+  });
+  ctx.command("anuneko-clean", "清理当前频道的 anuneko 对话记录").action(async ({ session }) => {
+    try {
+      if (!anunekoClient) {
+        return "❌ anuneko 客户端未初始化";
+      }
+      const sessionKey = session.channelId || session.userId;
+      const requester = anunekoClient._requester;
+      if (requester && typeof requester.clearSession === "function") {
+        const cleared = requester.clearSession(sessionKey);
+        if (cleared) {
+          return "✅ 已清理当前频道的对话记录，下次对话将创建新会话";
+        } else {
+          return "✅ 当前频道还没有对话记录";
+        }
+      }
+      return "❌ 无法访问会话管理器";
+    } catch (error) {
+      logger2.error("清理失败:", error);
+      return `❌ 清理失败: ${error.message}`;
+    }
+  });
+  ctx.on("ready", async () => {
+    if (config2.platform == null || config2.platform.length < 1) {
+      throw new import_error2.ChatLunaError(
+        import_error2.ChatLunaErrorCode.UNKNOWN_ERROR,
+        new Error("Cannot find any platform")
+      );
+    }
+    const platform = config2.platform;
+    const plugin = new import_chat.ChatLunaPlugin(ctx, config2, platform);
+    plugin.parseConfig((config3) => {
+      return [
+        {
+          apiKey: config3.xToken || "any",
+          apiEndpoint: "https://anuneko.com",
+          platform,
+          chatLimit: config3.chatTimeLimit,
+          timeout: config3.timeout,
+          maxRetries: config3.maxRetries,
+          concurrentMaxSize: config3.chatConcurrentMaxSize
+        }
+      ];
+    });
+    plugin.registerClient(() => {
+      const client = new AnunekoClient(ctx, config2, plugin);
+      if (!anunekoClient) {
+        anunekoClient = client;
+      }
+      return client;
+    });
+    await plugin.initClient();
+  });
+}
+__name(apply, "apply");
+var Config2 = import_koishi.Schema.intersect([
+  import_chat.ChatLunaPlugin.Config,
+  import_koishi.Schema.object({
+    platform: import_koishi.Schema.string().default("anuneko"),
+    xToken: import_koishi.Schema.string().required().role("textarea", { rows: [2, 4] }).description("anuneko API 的 x-token"),
+    cookie: import_koishi.Schema.string().role("textarea", { rows: [2, 4] }).description("anuneko API 的 Cookie（可选）"),
+    loggerinfo: import_koishi.Schema.boolean().default(false).description("日志调试模式").experimental()
+  })
+]).i18n({
+  "zh-CN": require_zh_CN_schema(),
+  "en-US": require_en_US_schema()
+});
+var inject = ["chatluna"];
+var name = "chatluna-anuneko-api-adapter";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  anunekoClient,
+  apply,
+  inject,
+  logger,
+  name,
+  reusable,
+  usage
+});

package/lib/logger.d.ts

@@ -0,0 +1,6 @@
+import { Logger } from 'koishi';
+import { Config } from './index';
+export declare let logger: Logger;
+export declare let config: Config;
+export declare function initializeLogger(newLogger: Logger, newConfig: Config): void;
+export declare function logInfo(...args: any[]): void;