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

package/lib/anuneko-requester.d.ts

@@ -9,6 +9,7 @@ export declare class AnunekoRequester extends ModelRequester {
     constructor(ctx: Context, _configPool: ClientConfigPool<ClientConfig>, _pluginConfig: Config, _plugin: ChatLunaPlugin);
     buildHeaders(): Record<string, string>;
     private createNewSession;
+    private getOrCreateSession;
     private sendChoice;
     completionStreamInternal(params: ModelRequestParams): AsyncGenerator<ChatGenerationChunk>;
     get logger(): import("reggol");

package/lib/index.d.ts

@@ -1,7 +1,9 @@
 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 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;
@@ -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");
@@ -130,6 +131,39 @@ var AnunekoRequester = class extends import_api.ModelRequester {
     }
     return null;
   }
+  // 根据配置获取或创建会话
+  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;
+    }
+    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) {
     const headers = this.buildHeaders();
@@ -164,9 +198,11 @@ var AnunekoRequester = class extends import_api.ModelRequester {
     if (params.model.includes("exotic") || params.model.includes("shorthair")) {
       modelName = "Exotic Shorthair";
     }
-    const sessionId = await this.createNewSession(modelName);
+    const conversationId = params.id || "default";
+    logInfo("Conversation ID from chatluna:", conversationId);
+    const sessionId = await this.getOrCreateSession(modelName, conversationId);
     if (!sessionId) {
-      const errorText = "创建会话失败，请稍后再试。";
+      const errorText = "获取会话失败，请稍后再试。";
       yield new import_outputs.ChatGenerationChunk({
         text: errorText,
         message: new import_messages.AIMessageChunk({ content: errorText })
@@ -348,9 +384,146 @@ 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 sessionManager = null;
 var reusable = false;
 var usage = `
 <p><strong>零成本、快速体验Chatluna</strong>。</p>
@@ -371,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 你好";
@@ -487,6 +670,34 @@ function apply(ctx, config2) {
 • 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) {
       throw new import_error2.ChatLunaError(
@@ -525,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("基础设置"),
@@ -544,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.1.0",
+  "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'
@@ -82,6 +82,54 @@ export class AnunekoRequester extends ModelRequester {
     return null
   }
 
+  // 根据配置获取或创建会话
+  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)
+    }
+
+    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}`
+    }
+
+    // 尝试获取已存在的会话
+    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 newSession
+  }
+
   // 自动选择分支
   private async sendChoice(msgId: string): Promise<void> {
     const headers = this.buildHeaders()
@@ -127,10 +175,14 @@ export class AnunekoRequester extends ModelRequester {
       modelName = 'Exotic Shorthair'
     }
 
-    // 每次请求都创建新会话
-    const sessionId = await this.createNewSession(modelName)
+    // 从 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 = '创建会话失败，请稍后再试。'
+      const errorText = '获取会话失败，请稍后再试。'
       yield new ChatGenerationChunk({
         text: errorText,
         message: new AIMessageChunk({ content: errorText })

package/src/index.ts

@@ -7,9 +7,12 @@ 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 let sessionManager: SessionManager | null = null
 export const reusable = false
 export const usage = `
 <p><strong>零成本、快速体验Chatluna</strong>。</p>
@@ -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) => {
@@ -184,6 +203,43 @@ export function apply(ctx: Context, config: Config) {
 • 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[config.sessionMode] || config.sessionMode}`
+    })
+
   ctx.on('ready', async () => {
     if (config.platform == null || config.platform.length < 1) {
       throw new ChatLunaError(
@@ -229,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([
@@ -241,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()
+  }
+}