mioku-plugin-chat 2.6.0 → 2.7.0

package/index.ts

@@ -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,
@@ -41,31 +42,11 @@ import { buildHistoryMediaOptions } from "./core/media/segment";
 import type { ChatConfigProvider } from "./humanize";
 import type { ChatPluginContext, ChatHandlerState } from "./context";
 import { mergeGroupOverrides } from "./utils/group-config";
-
-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),
-    ),
-  );
-}
-
-function shallowMergeTopLevel<T extends Record<string, any>>(
-  defaults: T,
-  overrides: Record<string, any>,
-): T {
-  const result: Record<string, any> = { ...defaults };
-  for (const key of Object.keys(overrides)) {
-    const value = overrides[key];
-    if (value !== undefined && value !== null) {
-      result[key] = value;
-    }
-  }
-  return result as T;
-}
+import {
+  mergeChatConfig,
+  normalizeIdList,
+  normalizeMediaAnalysisBlacklist,
+} from "./utils/config";
 
 export default definePlugin({
   name: "chat",
@@ -91,9 +72,9 @@ export default definePlugin({
 
     const buildGlobalConfig = async (): Promise<ChatConfig> => {
       if (!configService) {
-        return shallowMergeTopLevel(
-          shallowMergeTopLevel(
-            shallowMergeTopLevel({} as ChatConfig, BASE_CONFIG),
+        return mergeChatConfig(
+          mergeChatConfig(
+            mergeChatConfig({} as ChatConfig, BASE_CONFIG),
             SETTINGS_CONFIG,
           ),
           PERSONALIZATION_CONFIG,
@@ -103,15 +84,19 @@ export default definePlugin({
       const settings = (await configService.getConfig("chat", "settings")) ?? {};
       const personalization =
         (await configService.getConfig("chat", "personalization")) ?? {};
-      const merged = shallowMergeTopLevel(
-        shallowMergeTopLevel(
-          shallowMergeTopLevel({} as ChatConfig, BASE_CONFIG),
+      const mergedDefaults = mergeChatConfig(
+        mergeChatConfig(
+          mergeChatConfig({} as ChatConfig, BASE_CONFIG),
           SETTINGS_CONFIG,
         ),
-        shallowMergeTopLevel(
-          shallowMergeTopLevel({} as ChatConfig, personalization),
-          base,
+        PERSONALIZATION_CONFIG,
+      );
+      const merged = mergeChatConfig(
+        mergeChatConfig(
+          mergeChatConfig(mergedDefaults, settings),
+          personalization,
         ),
+        base,
       ) as ChatConfig;
 
       if (typeof merged.stream !== "boolean") merged.stream = true;
@@ -127,9 +112,8 @@ export default definePlugin({
       }
       merged.whitelistGroups = normalizeIdList(merged.whitelistGroups);
       merged.blacklistGroups = normalizeIdList(merged.blacklistGroups);
-      merged.mediaAnalysisBlacklistUsers = normalizeIdList(
-        (merged as any).mediaAnalysisBlacklistUsers ?? (merged as any).imageAnalysisBlacklistUsers,
-      );
+      merged.mediaAnalysisBlacklistUsers =
+        normalizeMediaAnalysisBlacklist(merged as Record<string, any>);
       delete (merged as any).imageAnalysisBlacklistUsers;
       return merged;
     };
@@ -257,11 +241,12 @@ export default definePlugin({
       });
     }
 
-    const humanize = new HumanizeEngine(mainAIInstance, workAIInstance, db, configProvider);
+    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);
@@ -276,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,
@@ -342,16 +328,18 @@ 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

@@ -6,23 +6,20 @@ 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,6 +36,8 @@ 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 configProvider: ChatConfigProvider;
@@ -49,9 +48,7 @@ export class CooldownManager {
   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,
@@ -60,14 +57,13 @@ 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.configProvider = pluginCtx.configProvider;
     this.defaultConfig = pluginCtx.defaultConfig;
@@ -77,17 +73,12 @@ export class CooldownManager {
     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;
@@ -102,47 +93,51 @@ export class CooldownManager {
     if (existingTimer) clearTimeout(existingTimer);
 
     const cfg = this.configProvider(groupId);
-    const cooldownMs = cfg.cooldownAfterReplyMs ?? this.defaultConfig.cooldownAfterReplyMs ?? 20_000;
+    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(
@@ -285,36 +280,18 @@ export class CooldownManager {
     );
     if (!result) return;
 
-    await this.sendAIResponse(
-      {
-        ctx: this.ctx,
-        groupId,
-        messages: result.messages,
-        config: cfg,
-        sentIndices: toolCtx.sentMessageIndices,
-      },
-      selfId,
-    );
-    await this.sendEmoji(this.ctx, groupId, result.emojiPath, selfId);
-
-    const now = Date.now();
-    this.saveBotMessages(
-      groupId,
-      groupSessionId,
-      result.messages,
-      now,
+    await finalizeChatTurn(this.pluginCtx, {
+      event: firstMsg.event,
       cfg,
-      this.db,
-      this.ctx,
-      selfId,
-    );
-    this.idleCheckManager.recordBotMessages(
+      result,
+      groupId,
       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(
@@ -444,34 +421,17 @@ export class CooldownManager {
       return;
     }
 
-    await this.sendAIResponse(
-      {
-        ctx: this.ctx,
-        groupId,
-        messages: result.messages,
-        config: cfg,
-        sentIndices: toolCtx.sentMessageIndices,
-      },
-      selfId,
-    );
-    await this.sendEmoji(this.ctx, groupId, result.emojiPath, selfId);
-    const now = Date.now();
-    this.saveBotMessages(
-      groupId,
-      groupSessionId,
-      result.messages,
-      now,
+    await finalizeChatTurn(this.pluginCtx, {
+      event: firstMsg.event,
       cfg,
-      this.db,
-      this.ctx,
-      selfId,
-    );
-    this.idleCheckManager.recordBotMessages(
+      result,
+      groupId,
       groupSessionId,
-      result.messages.length,
+      userId: targetMessage.userId,
       selfId,
-    );
-    this.sessionManager.touch(groupSessionId);
-    this.startCooldownTimer(groupSessionId, groupId, selfId);
+      toolCtx,
+      send: true,
+      isLive: true,
+    });
   }
 }