koishi-plugin-chatluna-anuneko-api-adapter 1.0.4 → 1.2.0

package/lib/anuneko-requester.d.ts

@@ -6,14 +6,10 @@ 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 getOrCreateSession;
     private sendChoice;
     completionStreamInternal(params: ModelRequestParams): AsyncGenerator<ChatGenerationChunk>;
     get logger(): import("reggol");

package/lib/index.d.ts

@@ -1,8 +1,10 @@
 import { Context, Logger, Schema } from 'koishi';
 import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
+import { SessionManager } from './session-manager';
 export declare let logger: Logger;
 export declare let anunekoClient: any;
-export declare const reusable = true;
+export declare let sessionManager: SessionManager | null;
+export declare const reusable = false;
 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</p>\n<p>\u8BE5\u670D\u52A1\u53EF\u80FD\u9700\u8981\u79D1\u5B66\u4E0A\u7F51\u3002</p>\n<p>\u652F\u6301\u6A58\u732B(Orange Cat)\u548C\u9ED1\u732B(Exotic Shorthair)\u4E24\u79CD\u6A21\u578B\u3002</p>\n\n---\n\nx-token \u83B7\u53D6\u65B9\u6CD5\u89C1\u4ED3\u5E93\u6587\u4EF6 https://github.com/koishi-shangxue-plugins/koishi-shangxue-apps/blob/main/plugins/chatluna-anuneko-api-adapter/data/2025-12-23_19-01-43.png\n";
 export declare function apply(ctx: Context, config: Config): void;
 export interface Config extends ChatLunaPlugin.Config {
@@ -11,6 +13,7 @@ export interface Config extends ChatLunaPlugin.Config {
     cookie?: string;
     loggerinfo: boolean;
     requestTimeout: number;
+    sessionMode: 'shared' | 'per-user' | 'always-new';
 }
 export declare const Config: Schema<Config>;
 export declare const inject: string[];

package/lib/index.js

@@ -23,14 +23,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // 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: "日志调试模式" };
+    module2.exports = { platform: "平台名称", xToken: "anuneko API 的 x-token", cookie: "anuneko API 的 Cookie（可选）", sessionMode: "会话管理模式", loggerinfo: "日志调试模式", requestTimeout: "请求超时时间" };
   }
 });
 
 // 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" };
+    module2.exports = { platform: "Platform name", xToken: "x-token for anuneko API", cookie: "Cookie for anuneko API (optional)", sessionMode: "Session management mode", loggerinfo: "Logger debug mode", requestTimeout: "Request timeout" };
   }
 });
 
@@ -44,13 +44,14 @@ __export(src_exports, {
   logger: () => logger2,
   name: () => name,
   reusable: () => reusable,
+  sessionManager: () => sessionManager,
   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");
+var import_logger4 = require("koishi-plugin-chatluna/utils/logger");
 
 // src/anuneko-client.ts
 var import_client = require("koishi-plugin-chatluna/llm-core/platform/client");
@@ -88,24 +89,6 @@ var AnunekoRequester = class extends import_api.ModelRequester {
   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 = {
@@ -125,7 +108,7 @@ var AnunekoRequester = class extends import_api.ModelRequester {
     return headers;
   }
   // 创建新会话
-  async createNewSession(userId, modelName) {
+  async createNewSession(modelName) {
     const headers = this.buildHeaders();
     const data = { model: modelName };
     try {
@@ -140,10 +123,7 @@ var AnunekoRequester = class extends import_api.ModelRequester {
       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) {
@@ -151,28 +131,38 @@ var AnunekoRequester = class extends import_api.ModelRequester {
     }
     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 signal = AbortSignal.timeout(this._pluginConfig.requestTimeout * 1e3);
-      const response = await fetch("https://anuneko.com/api/v1/user/select_model", {
-        method: "POST",
-        headers,
-        body: JSON.stringify(data),
-        signal
-      });
-      if (response.ok) {
-        this.modelMap.set(userId, modelName);
-        logInfo("Model switched successfully");
-        return true;
-      }
-    } catch (error) {
-      this.logger.error("Failed to switch model:", error);
+  // 根据配置获取或创建会话
+  async getOrCreateSession(modelName, conversationId) {
+    if (!sessionManager) {
+      logInfo("Session manager not initialized, creating new session");
+      return await this.createNewSession(modelName);
+    }
+    const mode = this._pluginConfig.sessionMode;
+    let sessionKey;
+    switch (mode) {
+      case "shared":
+        sessionKey = `shared-${modelName}`;
+        break;
+      case "per-user":
+        sessionKey = `user-${conversationId}-${modelName}`;
+        break;
+      case "always-new":
+        logInfo("Mode: always-new, creating new session");
+        return await this.createNewSession(modelName);
+      default:
+        sessionKey = `user-${conversationId}-${modelName}`;
+    }
+    const existingSession = sessionManager.getSession(sessionKey);
+    if (existingSession) {
+      logInfo("Using existing session:", existingSession, "for key:", sessionKey);
+      return existingSession;
     }
-    return false;
+    const newSession = await this.createNewSession(modelName);
+    if (newSession) {
+      sessionManager.setSession(sessionKey, newSession, modelName);
+      logInfo("Created and saved new session:", newSession, "for key:", sessionKey);
+    }
+    return newSession;
   }
   // 自动选择分支
   async sendChoice(msgId) {
@@ -204,24 +194,20 @@ var AnunekoRequester = class extends import_api.ModelRequester {
       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 conversationId = params.id || "default";
+    logInfo("Conversation ID from chatluna:", conversationId);
+    const sessionId = await this.getOrCreateSession(modelName, conversationId);
+    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`;
@@ -398,10 +384,147 @@ var AnunekoClient = class extends import_client.PlatformModelAndEmbeddingsClient
   }
 };
 
+// src/session-manager.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var SessionManager = class {
+  constructor(ctx, dataDir) {
+    this.ctx = ctx;
+    this.dataDir = dataDir;
+    this.tempFilePath = (0, import_node_path.join)(dataDir, "temp.json");
+    this.ensureDataDir();
+    this.loadSessions();
+  }
+  static {
+    __name(this, "SessionManager");
+  }
+  sessions = /* @__PURE__ */ new Map();
+  tempFilePath;
+  saveTimeout = null;
+  disposed = false;
+  // 确保数据目录存在
+  async ensureDataDir() {
+    try {
+      await import_node_fs.promises.mkdir(this.dataDir, { recursive: true });
+      logInfo("数据目录已确保存在:", this.dataDir);
+    } catch (error) {
+      this.ctx.logger.error("创建数据目录失败:", error);
+    }
+  }
+  // 从文件加载会话数据
+  async loadSessions() {
+    try {
+      const data = await import_node_fs.promises.readFile(this.tempFilePath, "utf-8");
+      const storage = JSON.parse(data);
+      this.sessions = new Map(Object.entries(storage.sessions || {}));
+      logInfo("会话数据加载成功，共", this.sessions.size, "个会话");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        logInfo("会话文件不存在，将创建新文件");
+        this.sessions = /* @__PURE__ */ new Map();
+      } else {
+        this.ctx.logger.error("加载会话数据失败:", error);
+        this.sessions = /* @__PURE__ */ new Map();
+      }
+    }
+  }
+  // 保存会话数据到文件（带防抖）
+  scheduleSave() {
+    if (this.disposed) return;
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+    }
+    this.saveTimeout = setTimeout(() => {
+      this.saveSessions();
+    }, 500);
+  }
+  // 实际保存到文件
+  async saveSessions() {
+    if (this.disposed) return;
+    try {
+      const storage = {
+        sessions: Object.fromEntries(this.sessions)
+      };
+      await import_node_fs.promises.writeFile(
+        this.tempFilePath,
+        JSON.stringify(storage, null, 2),
+        "utf-8"
+      );
+      logInfo("会话数据已保存");
+    } catch (error) {
+      this.ctx.logger.error("保存会话数据失败:", error);
+    }
+  }
+  // 获取会话 ID
+  getSession(key) {
+    const session = this.sessions.get(key);
+    if (session) {
+      session.lastUsed = Date.now();
+      this.scheduleSave();
+      logInfo("获取已存在的会话:", key, "->", session.chatId);
+      return session.chatId;
+    }
+    logInfo("未找到会话:", key);
+    return null;
+  }
+  // 设置会话 ID
+  setSession(key, chatId, modelName) {
+    this.sessions.set(key, {
+      chatId,
+      modelName,
+      lastUsed: Date.now()
+    });
+    this.scheduleSave();
+    logInfo("保存新会话:", key, "->", chatId);
+  }
+  // 删除会话
+  deleteSession(key) {
+    const deleted = this.sessions.delete(key);
+    if (deleted) {
+      this.scheduleSave();
+      logInfo("删除会话:", key);
+    }
+    return deleted;
+  }
+  // 清理过期会话（超过 24 小时未使用）
+  cleanExpiredSessions() {
+    const now = Date.now();
+    const expireTime = 24 * 60 * 60 * 1e3;
+    let cleaned = 0;
+    for (const [key, session] of this.sessions.entries()) {
+      if (now - session.lastUsed > expireTime) {
+        this.sessions.delete(key);
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      this.scheduleSave();
+      logInfo("清理了", cleaned, "个过期会话");
+    }
+  }
+  // 清空所有会话
+  clearAll() {
+    this.sessions.clear();
+    this.scheduleSave();
+    logInfo("已清空所有会话");
+  }
+  // 销毁时保存并清理
+  dispose() {
+    this.disposed = true;
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = null;
+    }
+    this.saveSessions();
+  }
+};
+
 // src/index.ts
+var import_node_path2 = require("node:path");
 var logger2;
 var anunekoClient = null;
-var reusable = true;
+var sessionManager = null;
+var reusable = false;
 var usage = `
 <p><strong>零成本、快速体验Chatluna</strong>。</p>
 <ul>
@@ -421,8 +544,18 @@ var usage = `
 x-token 获取方法见仓库文件 https://github.com/koishi-shangxue-plugins/koishi-shangxue-apps/blob/main/plugins/chatluna-anuneko-api-adapter/data/2025-12-23_19-01-43.png
 `;
 function apply(ctx, config2) {
-  logger2 = (0, import_logger3.createLogger)(ctx, "chatluna-anuneko-api-adapter");
+  logger2 = (0, import_logger4.createLogger)(ctx, "chatluna-anuneko-api-adapter");
   initializeLogger(logger2, config2);
+  const dataDir = (0, import_node_path2.join)(ctx.baseDir, "data", "chatluna-anuneko-api-adapter");
+  sessionManager = new SessionManager(ctx, dataDir);
+  const cleanupInterval = setInterval(() => {
+    sessionManager?.cleanExpiredSessions();
+  }, 60 * 60 * 1e3);
+  ctx.on("dispose", () => {
+    clearInterval(cleanupInterval);
+    sessionManager?.dispose();
+    sessionManager = null;
+  });
   ctx.command("anuneko <message:text>", "测试 anuneko API").action(async ({ session }, message) => {
     if (!message) {
       return "请输入消息内容，例如：/anuneko 你好";
@@ -531,26 +664,39 @@ function apply(ctx, config2) {
       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.command("anuneko-clean", "清理当前频道的对话记录").action(async ({ session }) => {
+    return `对话历史由 ChatLuna 管理，请使用以下命令清理：
+• chatluna room clear - 清空当前房间的对话历史
+• chatluna room delete <房间名称> - 删除指定房间
+• chatluna room list - 查看所有房间`;
+  });
+  ctx.command("anuneko-session", "管理 Anuneko 会话").action(async () => {
+    return `Anuneko 会话管理命令：
+• anuneko-session.clear - 清空所有会话
+• anuneko-session.cleanup - 清理过期会话（24小时未使用）
+• anuneko-session.mode - 查看当前会话模式`;
+  });
+  ctx.command("anuneko-session.clear", "清空所有 Anuneko 会话").action(async () => {
+    if (!sessionManager) {
+      return "❌ 会话管理器未初始化";
     }
+    sessionManager.clearAll();
+    return "✅ 已清空所有 Anuneko 会话";
+  });
+  ctx.command("anuneko-session.cleanup", "清理过期的 Anuneko 会话").action(async () => {
+    if (!sessionManager) {
+      return "❌ 会话管理器未初始化";
+    }
+    sessionManager.cleanExpiredSessions();
+    return "✅ 已清理过期会话";
+  });
+  ctx.command("anuneko-session.mode", "查看当前会话模式").action(async () => {
+    const modeText = {
+      "shared": "所有用户共享同一个会话",
+      "per-user": "根据用户 ID 区分会话",
+      "always-new": "每次对话都新建会话"
+    };
+    return `当前会话模式：${modeText[config2.sessionMode] || config2.sessionMode}`;
   });
   ctx.on("ready", async () => {
     if (config2.platform == null || config2.platform.length < 1) {
@@ -590,6 +736,11 @@ var Config2 = import_koishi.Schema.intersect([
     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（可选）"),
+    sessionMode: import_koishi.Schema.union([
+      import_koishi.Schema.const("shared").description("所有用户共享同一个会话"),
+      import_koishi.Schema.const("per-user").description("根据用户 ID 区分会话"),
+      import_koishi.Schema.const("always-new").description("每次对话都新建会话")
+    ]).default("per-user").description("会话管理模式"),
     loggerinfo: import_koishi.Schema.boolean().default(false).description("日志调试模式").experimental(),
     requestTimeout: import_koishi.Schema.number().default(120).description("请求 API 的超时时间，单位为秒。")
   }).description("基础设置"),
@@ -609,5 +760,6 @@ var name = "chatluna-anuneko-api-adapter";
   logger,
   name,
   reusable,
+  sessionManager,
   usage
 });

package/lib/session-manager.d.ts

@@ -0,0 +1,20 @@
+import { Context } from 'koishi';
+export declare class SessionManager {
+    private ctx;
+    private dataDir;
+    private sessions;
+    private tempFilePath;
+    private saveTimeout;
+    private disposed;
+    constructor(ctx: Context, dataDir: string);
+    private ensureDataDir;
+    private loadSessions;
+    private scheduleSave;
+    private saveSessions;
+    getSession(key: string): string | null;
+    setSession(key: string, chatId: string, modelName: string): void;
+    deleteSession(key: string): boolean;
+    cleanExpiredSessions(): void;
+    clearAll(): void;
+    dispose(): void;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chatluna-anuneko-api-adapter",
   "description": "anuneko API adapter for ChatLuna, using pearktrue API.",
-  "version": "1.0.4",
+  "version": "1.2.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/src/anuneko-requester.ts

@@ -7,7 +7,7 @@ import {
   ClientConfig,
   ClientConfigPool
 } from 'koishi-plugin-chatluna/llm-core/platform/config'
-import { Config, logger } from './index'
+import { Config, logger, sessionManager } from './index'
 import { logInfo } from './logger'
 import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat'
 import { Context } from 'koishi'
@@ -19,20 +19,11 @@ import {
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
-interface KoishiHumanMessage extends HumanMessage {
-  channelId?: string
-}
-
 interface InternalModelRequestParams extends ModelRequestParams {
   input: (HumanMessage | SystemMessage)[]
 }
 
 export class AnunekoRequester extends ModelRequester {
-  // 存储每个用户的会话ID
-  private sessionMap = new Map<string, string>()
-  // 存储每个用户的当前模型
-  private modelMap = new Map<string, string>()
-
   constructor(
     ctx: Context,
     _configPool: ClientConfigPool<ClientConfig>,
@@ -42,22 +33,6 @@ export class AnunekoRequester extends ModelRequester {
     super(ctx, _configPool, _pluginConfig, _plugin)
   }
 
-  // 清理指定用户的会话
-  public clearSession(userId: string): boolean {
-    const hasSession = this.sessionMap.has(userId)
-    this.sessionMap.delete(userId)
-    this.modelMap.delete(userId)
-    return hasSession
-  }
-
-  // 清理所有会话
-  public clearAllSessions(): number {
-    const count = this.sessionMap.size
-    this.sessionMap.clear()
-    this.modelMap.clear()
-    return count
-  }
-
   // 构建请求头
   public buildHeaders() {
     const headers: Record<string, string> = {
@@ -80,7 +55,7 @@ export class AnunekoRequester extends ModelRequester {
   }
 
   // 创建新会话
-  private async createNewSession(userId: string, modelName: string): Promise<string | null> {
+  private async createNewSession(modelName: string): Promise<string | null> {
     const headers = this.buildHeaders()
     const data = { model: modelName }
 
@@ -97,12 +72,7 @@ export class AnunekoRequester extends ModelRequester {
       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) {
@@ -112,31 +82,52 @@ export class AnunekoRequester extends ModelRequester {
     return null
   }
 
-  // 切换模型
-  private async switchModel(userId: string, chatId: string, modelName: string): Promise<boolean> {
-    const headers = this.buildHeaders()
-    const data = { chat_id: chatId, model: modelName }
+  // 根据配置获取或创建会话
+  private async getOrCreateSession(
+    modelName: string,
+    conversationId: string
+  ): Promise<string | null> {
+    if (!sessionManager) {
+      logInfo('Session manager not initialized, creating new session')
+      return await this.createNewSession(modelName)
+    }
 
-    try {
-      logInfo('Switching model to:', modelName)
-      const signal = AbortSignal.timeout(this._pluginConfig.requestTimeout * 1000)
-      const response = await fetch('https://anuneko.com/api/v1/user/select_model', {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(data),
-        signal
-      })
+    const mode = this._pluginConfig.sessionMode
+
+    // 根据模式确定会话键
+    let sessionKey: string
+    switch (mode) {
+      case 'shared':
+        // 所有用户共享同一个会话
+        sessionKey = `shared-${modelName}`
+        break
+      case 'per-user':
+        // 根据 conversationId 区分会话
+        sessionKey = `user-${conversationId}-${modelName}`
+        break
+      case 'always-new':
+        // 每次都创建新会话
+        logInfo('Mode: always-new, creating new session')
+        return await this.createNewSession(modelName)
+      default:
+        sessionKey = `user-${conversationId}-${modelName}`
+    }
 
-      if (response.ok) {
-        this.modelMap.set(userId, modelName)
-        logInfo('Model switched successfully')
-        return true
-      }
-    } catch (error) {
-      this.logger.error('Failed to switch model:', error)
+    // 尝试获取已存在的会话
+    const existingSession = sessionManager.getSession(sessionKey)
+    if (existingSession) {
+      logInfo('Using existing session:', existingSession, 'for key:', sessionKey)
+      return existingSession
+    }
+
+    // 创建新会话并保存
+    const newSession = await this.createNewSession(modelName)
+    if (newSession) {
+      sessionManager.setSession(sessionKey, newSession, modelName)
+      logInfo('Created and saved new session:', newSession, 'for key:', sessionKey)
     }
 
-    return false
+    return newSession
   }
 
   // 自动选择分支
@@ -166,7 +157,7 @@ export class AnunekoRequester extends ModelRequester {
     // 过滤掉所有非 HumanMessage 的消息，并只取最后一条
     const humanMessages = internalParams.input.filter(
       (message) => message instanceof HumanMessage
-    ) as KoishiHumanMessage[]
+    )
     const lastMessage = humanMessages.at(-1)
 
     logInfo('Receive params from chatluna', JSON.stringify(params, null, 2))
@@ -177,10 +168,6 @@ export class AnunekoRequester extends ModelRequester {
     }
 
     const prompt = lastMessage.content as string
-    // 使用 channelId 作为会话标识，如果没有则使用 userId
-    const sessionKey = lastMessage.channelId || lastMessage.id || 'default'
-
-    logInfo('使用会话标识:', sessionKey)
 
     // 从模型名称推断使用的模型
     let modelName = 'Orange Cat' // 默认橘猫
@@ -188,21 +175,19 @@ export class AnunekoRequester extends ModelRequester {
       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 ChatGenerationChunk({
-          text: errorText,
-          message: new AIMessageChunk({ content: errorText })
-        })
-        return
-      }
+    // 从 params.id 获取 conversationId（这是 chatluna 提供的会话 ID）
+    const conversationId = params.id || 'default'
+    logInfo('Conversation ID from chatluna:', conversationId)
+
+    // 根据配置获取或创建会话
+    const sessionId = await this.getOrCreateSession(modelName, conversationId)
+    if (!sessionId) {
+      const errorText = '获取会话失败，请稍后再试。'
+      yield new ChatGenerationChunk({
+        text: errorText,
+        message: new AIMessageChunk({ content: errorText })
+      })
+      return
     }
 
     const headers = this.buildHeaders()

package/src/index.ts

@@ -7,10 +7,13 @@ import {
 import { createLogger } from 'koishi-plugin-chatluna/utils/logger'
 import { AnunekoClient } from './anuneko-client'
 import { initializeLogger, logInfo } from './logger'
+import { SessionManager } from './session-manager'
+import { join } from 'node:path'
 
 export let logger: Logger
 export let anunekoClient: any = null
-export const reusable = true
+export let sessionManager: SessionManager | null = null
+export const reusable = false
 export const usage = `
 <p><strong>零成本、快速体验Chatluna</strong>。</p>
 <ul>
@@ -34,6 +37,22 @@ export function apply(ctx: Context, config: Config) {
   logger = createLogger(ctx, 'chatluna-anuneko-api-adapter')
   initializeLogger(logger, config)
 
+  // 初始化会话管理器
+  const dataDir = join(ctx.baseDir, 'data', 'chatluna-anuneko-api-adapter')
+  sessionManager = new SessionManager(ctx, dataDir)
+  
+  // 定期清理过期会话（每小时执行一次）
+  const cleanupInterval = setInterval(() => {
+    sessionManager?.cleanExpiredSessions()
+  }, 60 * 60 * 1000)
+
+  // 在插件卸载时清理
+  ctx.on('dispose', () => {
+    clearInterval(cleanupInterval)
+    sessionManager?.dispose()
+    sessionManager = null
+  })
+
   // 测试命令
   ctx.command('anuneko <message:text>', '测试 anuneko API')
     .action(async ({ session }, message) => {
@@ -176,31 +195,49 @@ export function apply(ctx: Context, config: Config) {
     })
 
   // 清理命令
-  ctx.command('anuneko-clean', '清理当前频道的 anuneko 对话记录')
+  ctx.command('anuneko-clean', '清理当前频道的对话记录')
     .action(async ({ session }) => {
-      try {
-        if (!anunekoClient) {
-          return '❌ anuneko 客户端未初始化'
-        }
+      return `对话历史由 ChatLuna 管理，请使用以下命令清理：
+• chatluna room clear - 清空当前房间的对话历史
+• chatluna room delete <房间名称> - 删除指定房间
+• chatluna room list - 查看所有房间`
+    })
 
-        // 使用 channelId 作为会话标识
-        const sessionKey = session.channelId || session.userId
-        const requester = anunekoClient._requester
+  // 会话管理命令
+  ctx.command('anuneko-session', '管理 Anuneko 会话')
+    .action(async () => {
+      return `Anuneko 会话管理命令：
+• anuneko-session.clear - 清空所有会话
+• anuneko-session.cleanup - 清理过期会话（24小时未使用）
+• anuneko-session.mode - 查看当前会话模式`
+    })
 
-        if (requester && typeof requester.clearSession === 'function') {
-          const cleared = requester.clearSession(sessionKey)
-          if (cleared) {
-            return '✅ 已清理当前频道的对话记录，下次对话将创建新会话'
-          } else {
-            return '✅ 当前频道还没有对话记录'
-          }
-        }
+  ctx.command('anuneko-session.clear', '清空所有 Anuneko 会话')
+    .action(async () => {
+      if (!sessionManager) {
+        return '❌ 会话管理器未初始化'
+      }
+      sessionManager.clearAll()
+      return '✅ 已清空所有 Anuneko 会话'
+    })
 
-        return '❌ 无法访问会话管理器'
-      } catch (error) {
-        logger.error('清理失败:', error)
-        return `❌ 清理失败: ${error.message}`
+  ctx.command('anuneko-session.cleanup', '清理过期的 Anuneko 会话')
+    .action(async () => {
+      if (!sessionManager) {
+        return '❌ 会话管理器未初始化'
+      }
+      sessionManager.cleanExpiredSessions()
+      return '✅ 已清理过期会话'
+    })
+
+  ctx.command('anuneko-session.mode', '查看当前会话模式')
+    .action(async () => {
+      const modeText = {
+        'shared': '所有用户共享同一个会话',
+        'per-user': '根据用户 ID 区分会话',
+        'always-new': '每次对话都新建会话'
       }
+      return `当前会话模式：${modeText[config.sessionMode] || config.sessionMode}`
     })
 
   ctx.on('ready', async () => {
@@ -248,6 +285,7 @@ export interface Config extends ChatLunaPlugin.Config {
   cookie?: string
   loggerinfo: boolean
   requestTimeout: number
+  sessionMode: 'shared' | 'per-user' | 'always-new'
 }
 
 export const Config: Schema<Config> = Schema.intersect([
@@ -260,6 +298,13 @@ export const Config: Schema<Config> = Schema.intersect([
     cookie: Schema.string()
       .role('textarea', { rows: [2, 4] })
       .description('anuneko API 的 Cookie（可选）'),
+    sessionMode: Schema.union([
+      Schema.const('shared').description('所有用户共享同一个会话'),
+      Schema.const('per-user').description('根据用户 ID 区分会话'),
+      Schema.const('always-new').description('每次对话都新建会话')
+    ])
+      .default('per-user')
+      .description('会话管理模式'),
     loggerinfo: Schema.boolean()
       .default(false)
       .description('日志调试模式')

package/src/locales/en-US.schema.yml

@@ -1,4 +1,6 @@
 platform: Platform name
 xToken: x-token for anuneko API
 cookie: Cookie for anuneko API (optional)
+sessionMode: Session management mode
 loggerinfo: Logger debug mode
+requestTimeout: Request timeout

package/src/locales/zh-CN.schema.yml

@@ -1,4 +1,6 @@
 platform: 平台名称
 xToken: anuneko API 的 x-token
 cookie: anuneko API 的 Cookie（可选）
+sessionMode: 会话管理模式
 loggerinfo: 日志调试模式
+requestTimeout: 请求超时时间

package/src/session-manager.ts

@@ -0,0 +1,166 @@
+import { Context } from 'koishi'
+import { promises as fs } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { logInfo } from './logger'
+
+// 会话数据结构
+interface SessionData {
+  chatId: string
+  modelName: string
+  lastUsed: number
+}
+
+// 会话存储结构
+interface SessionStorage {
+  sessions: Record<string, SessionData>
+}
+
+export class SessionManager {
+  private sessions: Map<string, SessionData> = new Map()
+  private tempFilePath: string
+  private saveTimeout: NodeJS.Timeout | null = null
+  private disposed = false
+
+  constructor(
+    private ctx: Context,
+    private dataDir: string
+  ) {
+    this.tempFilePath = join(dataDir, 'temp.json')
+    this.ensureDataDir()
+    this.loadSessions()
+  }
+
+  // 确保数据目录存在
+  private async ensureDataDir() {
+    try {
+      await fs.mkdir(this.dataDir, { recursive: true })
+      logInfo('数据目录已确保存在:', this.dataDir)
+    } catch (error) {
+      this.ctx.logger.error('创建数据目录失败:', error)
+    }
+  }
+
+  // 从文件加载会话数据
+  private async loadSessions() {
+    try {
+      const data = await fs.readFile(this.tempFilePath, 'utf-8')
+      const storage: SessionStorage = JSON.parse(data)
+      this.sessions = new Map(Object.entries(storage.sessions || {}))
+      logInfo('会话数据加载成功，共', this.sessions.size, '个会话')
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        logInfo('会话文件不存在，将创建新文件')
+        this.sessions = new Map()
+      } else {
+        this.ctx.logger.error('加载会话数据失败:', error)
+        this.sessions = new Map()
+      }
+    }
+  }
+
+  // 保存会话数据到文件（带防抖）
+  private scheduleSave() {
+    if (this.disposed) return
+
+    // 清除之前的定时器
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout)
+    }
+
+    // 设置新的定时器，500ms 后保存
+    this.saveTimeout = setTimeout(() => {
+      this.saveSessions()
+    }, 500)
+  }
+
+  // 实际保存到文件
+  private async saveSessions() {
+    if (this.disposed) return
+
+    try {
+      const storage: SessionStorage = {
+        sessions: Object.fromEntries(this.sessions)
+      }
+      await fs.writeFile(
+        this.tempFilePath,
+        JSON.stringify(storage, null, 2),
+        'utf-8'
+      )
+      logInfo('会话数据已保存')
+    } catch (error) {
+      this.ctx.logger.error('保存会话数据失败:', error)
+    }
+  }
+
+  // 获取会话 ID
+  getSession(key: string): string | null {
+    const session = this.sessions.get(key)
+    if (session) {
+      // 更新最后使用时间
+      session.lastUsed = Date.now()
+      this.scheduleSave()
+      logInfo('获取已存在的会话:', key, '->', session.chatId)
+      return session.chatId
+    }
+    logInfo('未找到会话:', key)
+    return null
+  }
+
+  // 设置会话 ID
+  setSession(key: string, chatId: string, modelName: string) {
+    this.sessions.set(key, {
+      chatId,
+      modelName,
+      lastUsed: Date.now()
+    })
+    this.scheduleSave()
+    logInfo('保存新会话:', key, '->', chatId)
+  }
+
+  // 删除会话
+  deleteSession(key: string) {
+    const deleted = this.sessions.delete(key)
+    if (deleted) {
+      this.scheduleSave()
+      logInfo('删除会话:', key)
+    }
+    return deleted
+  }
+
+  // 清理过期会话（超过 24 小时未使用）
+  cleanExpiredSessions() {
+    const now = Date.now()
+    const expireTime = 24 * 60 * 60 * 1000 // 24 小时
+    let cleaned = 0
+
+    for (const [key, session] of this.sessions.entries()) {
+      if (now - session.lastUsed > expireTime) {
+        this.sessions.delete(key)
+        cleaned++
+      }
+    }
+
+    if (cleaned > 0) {
+      this.scheduleSave()
+      logInfo('清理了', cleaned, '个过期会话')
+    }
+  }
+
+  // 清空所有会话
+  clearAll() {
+    this.sessions.clear()
+    this.scheduleSave()
+    logInfo('已清空所有会话')
+  }
+
+  // 销毁时保存并清理
+  dispose() {
+    this.disposed = true
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout)
+      this.saveTimeout = null
+    }
+    // 立即保存
+    this.saveSessions()
+  }
+}