mioku-plugin-chat 2.5.2 → 2.7.0

package/index.ts

@@ -2,7 +2,7 @@ import { definePlugin } from "mioki";
 import type { MiokiContext } from "mioki";
 import type { AIInstance, AIService, ConfigService, ScreenshotService } from "mioku";
 import { getPluginRuntimeState } from "mioku";
-import type { ChatConfig, ChatMessage, TargetMessage } from "./types";
+import type { ChatConfig, ChatMessage, ChatGroupsFile, TargetMessage } from "./types";
 import { initDatabase } from "./db";
 import { SessionManager } from "./manage/session";
 import { RateLimiter } from "./manage/rate-limiter";
@@ -23,6 +23,7 @@ import {
 import { CooldownManager } from "./manage/cooldown";
 import { IdleCheckManager } from "./manage/idle-check";
 import { QueueProcessor } from "./manage/queue-processor";
+import { SessionTurnScheduler } from "./manage/session-turn-scheduler";
 import { ChatDatabaseCleanup, DEFAULT_CLEANUP_CONFIG } from "./manage/cleanup";
 import {
   GroupStructuredHistoryManager,
@@ -32,23 +33,20 @@ import {
 import { BASE_CONFIG } from "./configs/base";
 import { SETTINGS_CONFIG } from "./configs/settings";
 import { PERSONALIZATION_CONFIG } from "./configs/personalization";
+import { DEFAULT_GROUPS_CONFIG } from "./configs/groups";
 import { RateLimitGuard } from "./manage/rate-limit-guard";
 import { createChatRuntime } from "./runtime/chat-runtime";
 import { createMessageHandler } from "./handlers/message";
 import { createPokeHandler } from "./handlers/poke";
 import { buildHistoryMediaOptions } from "./core/media/segment";
+import type { ChatConfigProvider } from "./humanize";
 import type { ChatPluginContext, ChatHandlerState } from "./context";
-
-function normalizeIdList(input: unknown): number[] {
-  if (!Array.isArray(input)) return [];
-  return Array.from(
-    new Set(
-      input
-        .map((item) => Math.floor(Number(item)))
-        .filter((id) => Number.isFinite(id) && id > 0),
-    ),
-  );
-}
+import { mergeGroupOverrides } from "./utils/group-config";
+import {
+  mergeChatConfig,
+  normalizeIdList,
+  normalizeMediaAnalysisBlacklist,
+} from "./utils/config";
 
 export default definePlugin({
   name: "chat",
@@ -66,27 +64,40 @@ export default definePlugin({
       await configService.registerConfig("chat", "base", BASE_CONFIG);
       await configService.registerConfig("chat", "settings", SETTINGS_CONFIG);
       await configService.registerConfig("chat", "personalization", PERSONALIZATION_CONFIG);
+      await configService.registerConfig("chat", "groups", DEFAULT_GROUPS_CONFIG);
     }
 
-    const getConfig = async (): Promise<ChatConfig> => {
+    let cachedBaseConfig: ChatConfig | null = null;
+    let cachedGroupsConfig: ChatGroupsFile | null = null;
+
+    const buildGlobalConfig = async (): Promise<ChatConfig> => {
       if (!configService) {
-        return {
-          ...BASE_CONFIG,
-          ...SETTINGS_CONFIG,
-          ...PERSONALIZATION_CONFIG,
-        } as ChatConfig;
+        return mergeChatConfig(
+          mergeChatConfig(
+            mergeChatConfig({} as ChatConfig, BASE_CONFIG),
+            SETTINGS_CONFIG,
+          ),
+          PERSONALIZATION_CONFIG,
+        );
       }
-      const base = await configService.getConfig("chat", "base");
-      const settings = await configService.getConfig("chat", "settings");
-      const personalization = await configService.getConfig("chat", "personalization");
-      const merged = {
-        ...BASE_CONFIG,
-        ...SETTINGS_CONFIG,
-        ...PERSONALIZATION_CONFIG,
-        ...base,
-        ...settings,
-        ...personalization,
-      } as any;
+      const base = (await configService.getConfig("chat", "base")) ?? {};
+      const settings = (await configService.getConfig("chat", "settings")) ?? {};
+      const personalization =
+        (await configService.getConfig("chat", "personalization")) ?? {};
+      const mergedDefaults = mergeChatConfig(
+        mergeChatConfig(
+          mergeChatConfig({} as ChatConfig, BASE_CONFIG),
+          SETTINGS_CONFIG,
+        ),
+        PERSONALIZATION_CONFIG,
+      );
+      const merged = mergeChatConfig(
+        mergeChatConfig(
+          mergeChatConfig(mergedDefaults, settings),
+          personalization,
+        ),
+        base,
+      ) as ChatConfig;
 
       if (typeof merged.stream !== "boolean") merged.stream = true;
       if (typeof merged.enableMarkdownScreenshot !== "boolean") {
@@ -101,14 +112,69 @@ export default definePlugin({
       }
       merged.whitelistGroups = normalizeIdList(merged.whitelistGroups);
       merged.blacklistGroups = normalizeIdList(merged.blacklistGroups);
-      merged.mediaAnalysisBlacklistUsers = normalizeIdList(
-        merged.mediaAnalysisBlacklistUsers ?? merged.imageAnalysisBlacklistUsers,
-      );
-      delete merged.imageAnalysisBlacklistUsers;
-      return merged as ChatConfig;
+      merged.mediaAnalysisBlacklistUsers =
+        normalizeMediaAnalysisBlacklist(merged as Record<string, any>);
+      delete (merged as any).imageAnalysisBlacklistUsers;
+      return merged;
     };
 
-    const config = await getConfig();
+    const refreshGroupsCache = async (): Promise<void> => {
+      if (!configService) {
+        cachedGroupsConfig = DEFAULT_GROUPS_CONFIG;
+        return;
+      }
+      const raw = await configService.getConfig("chat", "groups");
+      cachedGroupsConfig =
+        raw && typeof raw === "object" && raw.groups && typeof raw.groups === "object"
+          ? (raw as ChatGroupsFile)
+          : DEFAULT_GROUPS_CONFIG;
+    };
+
+    const refreshBaseCache = async (): Promise<void> => {
+      cachedBaseConfig = await buildGlobalConfig();
+    };
+
+    await refreshBaseCache();
+    await refreshGroupsCache();
+
+    if (configService) {
+      configService.onConfigChange("chat", "base", () => {
+        refreshBaseCache().catch((err) =>
+          ctx.logger.error(`刷新 chat/base 缓存失败: ${err}`),
+        );
+      });
+      configService.onConfigChange("chat", "settings", () => {
+        refreshBaseCache().catch((err) =>
+          ctx.logger.error(`刷新 chat/settings 缓存失败: ${err}`),
+        );
+      });
+      configService.onConfigChange("chat", "personalization", () => {
+        refreshBaseCache().catch((err) =>
+          ctx.logger.error(`刷新 chat/personalization 缓存失败: ${err}`),
+        );
+      });
+      configService.onConfigChange("chat", "groups", () => {
+        refreshGroupsCache().catch((err) =>
+          ctx.logger.error(`刷新 chat/groups 缓存失败: ${err}`),
+        );
+      });
+    }
+
+    const configProvider: ChatConfigProvider = (groupId?: number) => {
+      const base = cachedBaseConfig;
+      if (!base) return PERSONALIZATION_CONFIG as unknown as ChatConfig;
+      if (groupId === undefined) return base;
+      const overrides = cachedGroupsConfig?.groups?.[String(groupId)];
+      return mergeGroupOverrides(base, overrides);
+    };
+
+    const getConfig = async (groupId?: number): Promise<ChatConfig> => {
+      if (!cachedBaseConfig) await refreshBaseCache();
+      return configProvider(groupId);
+    };
+
+    const defaultConfig = configProvider();
+    const config = defaultConfig;
 
     if (!config.apiKey) {
       ctx.logger.warn("聊天插件未配置 API Key，请在 config/chat/base.json 中配置");
@@ -119,9 +185,12 @@ export default definePlugin({
     const sessionManager = new SessionManager(db, config.maxSessions);
     const queueManager = new MessageQueueManager();
     const rateLimiter = new RateLimiter({
-      dynamicDelay: config.dynamicDelay,
-      aiRequestLimits: config.aiRequestLimits,
+      maxTriggersPerWindow: 5,
+      windowMs: 60_000,
+      dedupWindowMs: 30_000,
+      groupCooldownMs: 1_000,
     });
+    rateLimiter.setConfigProvider(configProvider);
     const skillManager = new SkillSessionManager();
 
     rateLimiter.setQueueLengthGetter((groupId: number) =>
@@ -172,17 +241,19 @@ export default definePlugin({
       });
     }
 
-    const humanize = new HumanizeEngine(mainAIInstance, workAIInstance, config, db);
+    const humanize = new HumanizeEngine(workAIInstance, db, configProvider);
     await humanize.init();
 
     const pokeCooldowns = new Map<number, number>();
     const processingSet = new Set<string>();
+    const sessionTurnScheduler = new SessionTurnScheduler();
     const groupStructuredHistory = new GroupStructuredHistoryManager();
     const rateLimitGuard = new RateLimitGuard(rateLimiter, ctx.logger);
     const runWithRateLimitGuard = rateLimitGuard.run.bind(rateLimitGuard);
 
     const pluginCtx = {
-      ctx, config, db,
+      ctx, defaultConfig, configProvider, getConfig,
+      db,
       aiInstance: mainAIInstance, workAIInstance, visionAIInstance,
       aiService, humanize,
       sessionManager, skillManager, rateLimiter, queueManager,
@@ -190,6 +261,7 @@ export default definePlugin({
       cooldownManager: undefined as unknown as CooldownManager,
       idleCheckManager: undefined as unknown as IdleCheckManager,
       queueProcessor: undefined as unknown as QueueProcessor,
+      sessionTurnScheduler,
       runWithRateLimitGuard,
       buildHistoryMediaOptions,
       getGroupHistoryMessages, getGroupInfoData, getHumanizeContexts,
@@ -209,12 +281,13 @@ export default definePlugin({
           humanize.topicTracker.onMessage(groupSessionId),
         ]);
         if (userMsg.groupId) {
+          const ttlMs = configProvider(userMsg.groupId).groupStructuredHistoryTtlMs;
           groupStructuredHistory.append(
             groupSessionId,
             buildStructuredUserMessages([
               buildStructuredUserInputFromTarget(userMsg as unknown as TargetMessage),
             ]),
-            config.groupStructuredHistoryTtlMs,
+            ttlMs,
           );
         }
       },
@@ -255,15 +328,17 @@ export default definePlugin({
     ctx.logger.info("聊天插件加载成功");
 
     return () => {
-      db.close();
-      rateLimiter.dispose();
-      clearInterval(cleanupInterval);
-      dbCleanup.stop();
-      cooldownManager.dispose();
       idleCheckManager.dispose();
+      cooldownManager.dispose();
       queueProcessor.dispose();
+      sessionTurnScheduler.dispose();
+      queueManager.dispose();
+      clearInterval(cleanupInterval);
+      dbCleanup.stop();
+      rateLimiter.dispose();
       processingSet.clear();
       pokeCooldowns.clear();
+      db.close();
       ctx.logger.info("聊天插件已卸载");
     };
   },

package/manage/cooldown.ts

@@ -2,27 +2,24 @@ import type { MiokiContext } from "mioki";
 import type { AIInstance } from "mioku";
 import type { ChatConfig, TargetMessage } from "../types";
 import type { ChatDatabase } from "../db";
-import type { HumanizeEngine } from "../humanize";
+import type { HumanizeEngine, ChatConfigProvider } from "../humanize";
 import type { SkillSessionManager } from "./skill-session";
 import type { GroupStructuredHistoryManager } from "./group-structured-history";
 import { buildStructuredUserInputFromEvent } from "./group-structured-history";
-import type { SessionManager } from "./session";
 import type { RateLimiter } from "./rate-limiter";
-import type { IdleCheckManager } from "./idle-check";
 import type {
   RunRateLimitGuard,
   HistoryMediaOptions,
   GetGroupHistoryMessages,
   GetGroupInfoData,
   GetHumanizeContexts,
-  SendAIResponse,
-  SaveBotMessages,
-  SendEmoji,
   RunChat,
   BuildToolContext,
   BuildStructuredUserInput,
 } from "./types";
 import type { ChatPluginContext } from "../context";
+import type { SessionTurnScheduler } from "./session-turn-scheduler";
+import { finalizeChatTurn } from "../core/chat-turn";
 import { getBotRole } from "../utils";
 
 interface CooldownMessage {
@@ -39,18 +36,19 @@ export class CooldownManager {
   private groupCooldownUntil = new Map<string, number>();
   private groupCooldownMessages = new Map<string, CooldownMessage[]>();
   private cooldownTimeoutIds = new Map<string, NodeJS.Timeout>();
+  private pluginCtx: ChatPluginContext;
+  private sessionTurnScheduler: SessionTurnScheduler;
 
   private ctx: MiokiContext;
-  private cfg: ChatConfig;
+  private configProvider: ChatConfigProvider;
+  private defaultConfig: ChatConfig;
   private db: ChatDatabase;
   private humanize: HumanizeEngine;
   private aiInstance: AIInstance;
   private aiService: import("mioku").AIService;
   private skillManager: SkillSessionManager;
   private groupStructuredHistory: GroupStructuredHistoryManager;
-  private sessionManager: SessionManager;
   private rateLimiter: RateLimiter;
-  private idleCheckManager: IdleCheckManager;
   private runWithRateLimitGuard: RunRateLimitGuard;
   private buildHistoryMediaOptions: (
     ai: AIInstance,
@@ -59,33 +57,28 @@ export class CooldownManager {
   private getGroupHistoryMessages: GetGroupHistoryMessages;
   private getGroupInfoData: GetGroupInfoData;
   private getHumanizeContexts: GetHumanizeContexts;
-  private sendAIResponse: SendAIResponse;
-  private saveBotMessages: SaveBotMessages;
-  private sendEmoji: SendEmoji;
   private runChat: RunChat;
   private buildToolContext: BuildToolContext;
   private buildStructuredUserInputFromEvent: BuildStructuredUserInput;
 
   constructor(pluginCtx: ChatPluginContext) {
+    this.pluginCtx = pluginCtx;
+    this.sessionTurnScheduler = pluginCtx.sessionTurnScheduler;
     this.ctx = pluginCtx.ctx;
-    this.cfg = pluginCtx.config;
+    this.configProvider = pluginCtx.configProvider;
+    this.defaultConfig = pluginCtx.defaultConfig;
     this.db = pluginCtx.db;
     this.humanize = pluginCtx.humanize;
     this.aiInstance = pluginCtx.aiInstance;
     this.aiService = pluginCtx.aiService;
     this.skillManager = pluginCtx.skillManager;
     this.groupStructuredHistory = pluginCtx.groupStructuredHistory;
-    this.sessionManager = pluginCtx.sessionManager;
     this.rateLimiter = pluginCtx.rateLimiter;
-    this.idleCheckManager = pluginCtx.idleCheckManager;
     this.runWithRateLimitGuard = pluginCtx.runWithRateLimitGuard;
     this.buildHistoryMediaOptions = pluginCtx.buildHistoryMediaOptions;
     this.getGroupHistoryMessages = pluginCtx.getGroupHistoryMessages;
     this.getGroupInfoData = pluginCtx.getGroupInfoData;
     this.getHumanizeContexts = pluginCtx.getHumanizeContexts;
-    this.sendAIResponse = pluginCtx.sendAIResponse;
-    this.saveBotMessages = pluginCtx.saveBotMessages;
-    this.sendEmoji = pluginCtx.sendEmoji;
     this.runChat = pluginCtx.runChat;
     this.buildToolContext = pluginCtx.buildToolContext;
     this.buildStructuredUserInputFromEvent = buildStructuredUserInputFromEvent;
@@ -99,47 +92,52 @@ export class CooldownManager {
     const existingTimer = this.cooldownTimeoutIds.get(groupSessionId);
     if (existingTimer) clearTimeout(existingTimer);
 
-    const cooldownMs = this.cfg.cooldownAfterReplyMs ?? 20_000;
+    const cfg = this.configProvider(groupId);
+    const cooldownMs =
+      cfg.cooldownAfterReplyMs ??
+      this.defaultConfig.cooldownAfterReplyMs ??
+      20_000;
 
-    const timer = setTimeout(async () => {
+    const timer = setTimeout(() => {
+      if (this.cooldownTimeoutIds.get(groupSessionId) !== timer) return;
       this.cooldownTimeoutIds.delete(groupSessionId);
+      this.groupCooldownUntil.delete(groupSessionId);
       const collected = this.groupCooldownMessages.get(groupSessionId) || [];
-      if (collected.length === 0) {
-        this.groupCooldownMessages.delete(groupSessionId);
-        this.groupCooldownUntil.delete(groupSessionId);
-        return;
-      }
+      this.groupCooldownMessages.delete(groupSessionId);
+      if (collected.length === 0) return;
 
-      const directAtMessages = collected.filter((m) => m.isDirectAt);
-      try {
-        if (directAtMessages.length > 0) {
-          await this.processReviewMessages(
-            groupSessionId,
-            groupId,
-            collected,
-            selfId,
-          );
-        } else {
-          await this.processCooldownWithPlanner(
-            groupSessionId,
-            groupId,
-            collected,
-            selfId,
-          );
-        }
-      } catch (err) {
-        this.ctx.logger.error(
-          `[Cooldown] Group ${groupId} processing failed: ${err}`,
+      const hasDirectAt = collected.some((message) => message.isDirectAt);
+      void this.sessionTurnScheduler
+        .run(
+          groupSessionId,
+          hasDirectAt ? "cooldown" : "cooldown-planner",
+          () =>
+            hasDirectAt
+              ? this.processReviewMessages(
+                  groupSessionId,
+                  groupId,
+                  collected,
+                  selfId,
+                )
+              : this.processCooldownWithPlanner(
+                  groupSessionId,
+                  groupId,
+                  collected,
+                  selfId,
+                ),
+        )
+        .catch((err) =>
+          this.ctx.logger.error(
+            `[Cooldown] Group ${groupId} processing failed: ${err}`,
+          ),
         );
-      } finally {
-        this.groupCooldownMessages.delete(groupSessionId);
-        this.groupCooldownUntil.delete(groupSessionId);
-      }
     }, cooldownMs);
 
     this.cooldownTimeoutIds.set(groupSessionId, timer);
     this.groupCooldownUntil.set(groupSessionId, Date.now() + cooldownMs);
-    this.groupCooldownMessages.set(groupSessionId, []);
+    if (!this.groupCooldownMessages.has(groupSessionId)) {
+      this.groupCooldownMessages.set(groupSessionId, []);
+    }
   }
 
   collectMessage(
@@ -196,17 +194,19 @@ export class CooldownManager {
       timestamp: Date.now(),
     };
 
+    const cfg = this.configProvider(groupId);
+
     const { history } = await this.getGroupHistoryMessages(
       groupId,
       groupSessionId,
       this.ctx,
-      this.cfg.historyCount,
+      cfg.historyCount,
       this.db,
       selfId,
-      this.buildHistoryMediaOptions(this.aiInstance, this.cfg),
+      this.buildHistoryMediaOptions(this.aiInstance, cfg),
     );
     const botNickname =
-      this.cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
+      cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
     const botRole = await getBotRole(groupId, this.ctx, selfId);
     const { groupName, memberCount } = await this.getGroupInfoData(
       this.ctx,
@@ -220,7 +220,7 @@ export class CooldownManager {
       groupSessionId,
       groupId,
       userId: targetMessage.userId,
-      config: this.cfg,
+      config: cfg,
       aiService: this.aiService,
       db: this.db,
       botRole,
@@ -245,7 +245,7 @@ export class CooldownManager {
           history,
           targetMessage,
           {
-            config: this.cfg,
+            config: cfg,
             groupName,
             memberCount,
             botNickname,
@@ -266,7 +266,7 @@ export class CooldownManager {
           this.skillManager,
           {
             manager: this.groupStructuredHistory,
-            ttlMs: this.cfg.groupStructuredHistoryTtlMs,
+            ttlMs: cfg.groupStructuredHistoryTtlMs,
             currentUserInputs: collected.map((msg) =>
               this.buildStructuredUserInputFromEvent(
                 msg.event,
@@ -280,36 +280,18 @@ export class CooldownManager {
     );
     if (!result) return;
 
-    await this.sendAIResponse(
-      {
-        ctx: this.ctx,
-        groupId,
-        messages: result.messages,
-        config: this.cfg,
-        sentIndices: toolCtx.sentMessageIndices,
-      },
-      selfId,
-    );
-    await this.sendEmoji(this.ctx, groupId, result.emojiPath, selfId);
-
-    const now = Date.now();
-    this.saveBotMessages(
+    await finalizeChatTurn(this.pluginCtx, {
+      event: firstMsg.event,
+      cfg,
+      result,
       groupId,
       groupSessionId,
-      result.messages,
-      now,
-      this.cfg,
-      this.db,
-      this.ctx,
-      selfId,
-    );
-    this.idleCheckManager.recordBotMessages(
-      groupSessionId,
-      result.messages.length,
+      userId: targetMessage.userId,
       selfId,
-    );
-    this.sessionManager.touch(groupSessionId);
-    this.startCooldownTimer(groupSessionId, groupId, selfId);
+      toolCtx,
+      send: true,
+      isLive: true,
+    });
   }
 
   private async processCooldownWithPlanner(
@@ -321,17 +303,19 @@ export class CooldownManager {
     const mergedContent = collected.map((m) => m.content).join("\n");
     const firstMsg = collected[0];
 
+    const cfg = this.configProvider(groupId);
+
     const { history } = await this.getGroupHistoryMessages(
       groupId,
       groupSessionId,
       this.ctx,
-      this.cfg.historyCount,
+      cfg.historyCount,
       this.db,
       selfId,
-      this.buildHistoryMediaOptions(this.aiInstance, this.cfg),
+      this.buildHistoryMediaOptions(this.aiInstance, cfg),
     );
     const botNickname =
-      this.cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
+      cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
 
     const planResult = await this.humanize.actionPlanner.plan(
       groupSessionId,
@@ -362,7 +346,7 @@ export class CooldownManager {
       groupSessionId,
       groupId,
       userId: targetMessage.userId,
-      config: this.cfg,
+      config: cfg,
       aiService: this.aiService,
       db: this.db,
       botRole,
@@ -392,7 +376,7 @@ export class CooldownManager {
           history,
           targetMessage,
           {
-            config: this.cfg,
+            config: cfg,
             groupName,
             memberCount,
             botNickname,
@@ -418,7 +402,7 @@ export class CooldownManager {
           this.skillManager,
           {
             manager: this.groupStructuredHistory,
-            ttlMs: this.cfg.groupStructuredHistoryTtlMs,
+            ttlMs: cfg.groupStructuredHistoryTtlMs,
             currentUserInputs: collected.map((msg) =>
               this.buildStructuredUserInputFromEvent(
                 msg.event,
@@ -437,34 +421,17 @@ export class CooldownManager {
       return;
     }
 
-    await this.sendAIResponse(
-      {
-        ctx: this.ctx,
-        groupId,
-        messages: result.messages,
-        config: this.cfg,
-        sentIndices: toolCtx.sentMessageIndices,
-      },
-      selfId,
-    );
-    await this.sendEmoji(this.ctx, groupId, result.emojiPath, selfId);
-    const now = Date.now();
-    this.saveBotMessages(
+    await finalizeChatTurn(this.pluginCtx, {
+      event: firstMsg.event,
+      cfg,
+      result,
       groupId,
       groupSessionId,
-      result.messages,
-      now,
-      this.cfg,
-      this.db,
-      this.ctx,
-      selfId,
-    );
-    this.idleCheckManager.recordBotMessages(
-      groupSessionId,
-      result.messages.length,
+      userId: targetMessage.userId,
       selfId,
-    );
-    this.sessionManager.touch(groupSessionId);
-    this.startCooldownTimer(groupSessionId, groupId, selfId);
+      toolCtx,
+      send: true,
+      isLive: true,
+    });
   }
-}
+}