mioku-plugin-chat 2.5.2 → 2.6.0

package/humanize/topic.ts

@@ -2,25 +2,28 @@ import type { AIInstance } from "mioku";
 import { logger } from "mioki";
 import { extractJsonObject } from "../utils/json";
 import type { ChatDatabase } from "../db";
-import type { ChatConfig } from "../types";
+import type { ChatMessage } from "../types";
+import { extractGroupIdFromSession } from "../utils/group-config";
+import type { ChatConfigProvider } from "./index";
 
 export class TopicTracker {
   private ai: AIInstance;
-  private config: ChatConfig;
+  private getConfig: ChatConfigProvider;
   private db: ChatDatabase;
   private lastAnalyzedWindowEnd: Map<string, number> = new Map();
 
-  constructor(ai: AIInstance, config: ChatConfig, db: ChatDatabase) {
+  constructor(ai: AIInstance, configProvider: ChatConfigProvider, db: ChatDatabase) {
     this.ai = ai;
-    this.config = config;
+    this.getConfig = configProvider;
     this.db = db;
   }
 
   async onMessage(sessionId: string): Promise<void> {
-    if (!this.config.topic?.enabled) return;
+    const cfg = this.getConfig(extractGroupIdFromSession(sessionId));
+    if (!cfg.topic?.enabled) return;
     if (!sessionId.startsWith("group:")) return;
 
-    const windowMs = this.getWindowMs();
+    const windowMs = this.getWindowMs(cfg);
     const completedWindowEnd = Math.floor(Date.now() / windowMs) * windowMs;
     if (completedWindowEnd <= 0) return;
 
@@ -32,18 +35,19 @@ export class TopicTracker {
     this.lastAnalyzedWindowEnd.set(sessionId, completedWindowEnd);
     const windowStartAt = completedWindowEnd - windowMs;
 
-    this.analyzeWindow(sessionId, windowStartAt, completedWindowEnd).catch(
+    this.analyzeWindow(sessionId, windowStartAt, completedWindowEnd, cfg).catch(
       (err) => logger.warn(`[TopicTracker] Analysis failed: ${err}`),
     );
   }
 
   getTopicContext(sessionId: string, historyStartAt?: number): string {
-    if (!this.config.topic?.enabled) return "";
+    const cfg = this.getConfig(extractGroupIdFromSession(sessionId));
+    if (!cfg.topic?.enabled) return "";
     if (!sessionId.startsWith("group:")) return "";
     if (!historyStartAt) return "";
 
-    const windowMs = this.getWindowMs();
-    const windowCount = this.getHistoryWindowCount();
+    const windowMs = this.getWindowMs(cfg);
+    const windowCount = this.getHistoryWindowCount(cfg);
     const firstWindowEnd = Math.floor(historyStartAt / windowMs) * windowMs;
     if (firstWindowEnd <= 0) return "";
 
@@ -79,6 +83,7 @@ export class TopicTracker {
     sessionId: string,
     windowStartAt: number,
     windowEndAt: number,
+    cfg = this.getConfig(extractGroupIdFromSession(sessionId)),
   ): Promise<void> {
     if (windowEndAt <= windowStartAt) return;
 
@@ -119,7 +124,7 @@ Output strictly in JSON format:
   "summary": "one concise abstract summary sentence"
 }`,
         messages: [],
-        model: this.config.workingModel || this.config.model,
+        model: cfg.workingModel || cfg.model,
         temperature: 0.2,
         max_tokens: 300,
       });
@@ -163,14 +168,14 @@ Output strictly in JSON format:
     }
   }
 
-  private getWindowMs(): number {
-    const hours = Number(this.config.topic?.windowHours);
+  private getWindowMs(cfg = this.getConfig()): number {
+    const hours = Number(cfg.topic?.windowHours);
     const safeHours = Number.isFinite(hours) && hours > 0 ? hours : 5;
     return Math.max(1, Math.floor(safeHours)) * 3600_000;
   }
 
-  private getHistoryWindowCount(): number {
-    const count = Number(this.config.topic?.historyWindowCount);
+  private getHistoryWindowCount(cfg = this.getConfig()): number {
+    const count = Number(cfg.topic?.historyWindowCount);
     if (!Number.isFinite(count) || count <= 0) return 3;
     return Math.max(1, Math.floor(count));
   }
@@ -202,3 +207,5 @@ Output strictly in JSON format:
     return `${year}-${month}-${day} ${hour}:${minute}`;
   }
 }
+
+export type { ChatMessage };

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";
@@ -32,12 +32,15 @@ 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";
+import { mergeGroupOverrides } from "./utils/group-config";
 
 function normalizeIdList(input: unknown): number[] {
   if (!Array.isArray(input)) return [];
@@ -50,6 +53,20 @@ function normalizeIdList(input: unknown): number[] {
   );
 }
 
+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;
+}
+
 export default definePlugin({
   name: "chat",
   version: "1.0.0",
@@ -66,27 +83,36 @@ 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 shallowMergeTopLevel(
+          shallowMergeTopLevel(
+            shallowMergeTopLevel({} 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 merged = shallowMergeTopLevel(
+        shallowMergeTopLevel(
+          shallowMergeTopLevel({} as ChatConfig, BASE_CONFIG),
+          SETTINGS_CONFIG,
+        ),
+        shallowMergeTopLevel(
+          shallowMergeTopLevel({} as ChatConfig, personalization),
+          base,
+        ),
+      ) as ChatConfig;
 
       if (typeof merged.stream !== "boolean") merged.stream = true;
       if (typeof merged.enableMarkdownScreenshot !== "boolean") {
@@ -102,13 +128,69 @@ export default definePlugin({
       merged.whitelistGroups = normalizeIdList(merged.whitelistGroups);
       merged.blacklistGroups = normalizeIdList(merged.blacklistGroups);
       merged.mediaAnalysisBlacklistUsers = normalizeIdList(
-        merged.mediaAnalysisBlacklistUsers ?? merged.imageAnalysisBlacklistUsers,
+        (merged as any).mediaAnalysisBlacklistUsers ?? (merged as any).imageAnalysisBlacklistUsers,
       );
-      delete merged.imageAnalysisBlacklistUsers;
-      return merged as ChatConfig;
+      delete (merged as any).imageAnalysisBlacklistUsers;
+      return merged;
+    };
+
+    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 config = await getConfig();
+    const defaultConfig = configProvider();
+    const config = defaultConfig;
 
     if (!config.apiKey) {
       ctx.logger.warn("聊天插件未配置 API Key，请在 config/chat/base.json 中配置");
@@ -119,9 +201,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,7 +257,7 @@ export default definePlugin({
       });
     }
 
-    const humanize = new HumanizeEngine(mainAIInstance, workAIInstance, config, db);
+    const humanize = new HumanizeEngine(mainAIInstance, workAIInstance, db, configProvider);
     await humanize.init();
 
     const pokeCooldowns = new Map<number, number>();
@@ -182,7 +267,8 @@ export default definePlugin({
     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,
@@ -209,12 +295,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,
           );
         }
       },
@@ -267,4 +354,4 @@ export default definePlugin({
       ctx.logger.info("聊天插件已卸载");
     };
   },
-});
+});

package/manage/cooldown.ts

@@ -2,7 +2,7 @@ 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";
@@ -41,7 +41,8 @@ export class CooldownManager {
   private cooldownTimeoutIds = new Map<string, NodeJS.Timeout>();
 
   private ctx: MiokiContext;
-  private cfg: ChatConfig;
+  private configProvider: ChatConfigProvider;
+  private defaultConfig: ChatConfig;
   private db: ChatDatabase;
   private humanize: HumanizeEngine;
   private aiInstance: AIInstance;
@@ -68,7 +69,8 @@ export class CooldownManager {
 
   constructor(pluginCtx: ChatPluginContext) {
     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;
@@ -99,7 +101,8 @@ 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 () => {
       this.cooldownTimeoutIds.delete(groupSessionId);
@@ -196,17 +199,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 +225,7 @@ export class CooldownManager {
       groupSessionId,
       groupId,
       userId: targetMessage.userId,
-      config: this.cfg,
+      config: cfg,
       aiService: this.aiService,
       db: this.db,
       botRole,
@@ -245,7 +250,7 @@ export class CooldownManager {
           history,
           targetMessage,
           {
-            config: this.cfg,
+            config: cfg,
             groupName,
             memberCount,
             botNickname,
@@ -266,7 +271,7 @@ export class CooldownManager {
           this.skillManager,
           {
             manager: this.groupStructuredHistory,
-            ttlMs: this.cfg.groupStructuredHistoryTtlMs,
+            ttlMs: cfg.groupStructuredHistoryTtlMs,
             currentUserInputs: collected.map((msg) =>
               this.buildStructuredUserInputFromEvent(
                 msg.event,
@@ -285,7 +290,7 @@ export class CooldownManager {
         ctx: this.ctx,
         groupId,
         messages: result.messages,
-        config: this.cfg,
+        config: cfg,
         sentIndices: toolCtx.sentMessageIndices,
       },
       selfId,
@@ -298,7 +303,7 @@ export class CooldownManager {
       groupSessionId,
       result.messages,
       now,
-      this.cfg,
+      cfg,
       this.db,
       this.ctx,
       selfId,
@@ -321,17 +326,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 +369,7 @@ export class CooldownManager {
       groupSessionId,
       groupId,
       userId: targetMessage.userId,
-      config: this.cfg,
+      config: cfg,
       aiService: this.aiService,
       db: this.db,
       botRole,
@@ -392,7 +399,7 @@ export class CooldownManager {
           history,
           targetMessage,
           {
-            config: this.cfg,
+            config: cfg,
             groupName,
             memberCount,
             botNickname,
@@ -418,7 +425,7 @@ export class CooldownManager {
           this.skillManager,
           {
             manager: this.groupStructuredHistory,
-            ttlMs: this.cfg.groupStructuredHistoryTtlMs,
+            ttlMs: cfg.groupStructuredHistoryTtlMs,
             currentUserInputs: collected.map((msg) =>
               this.buildStructuredUserInputFromEvent(
                 msg.event,
@@ -442,7 +449,7 @@ export class CooldownManager {
         ctx: this.ctx,
         groupId,
         messages: result.messages,
-        config: this.cfg,
+        config: cfg,
         sentIndices: toolCtx.sentMessageIndices,
       },
       selfId,
@@ -454,7 +461,7 @@ export class CooldownManager {
       groupSessionId,
       result.messages,
       now,
-      this.cfg,
+      cfg,
       this.db,
       this.ctx,
       selfId,
@@ -467,4 +474,4 @@ export class CooldownManager {
     this.sessionManager.touch(groupSessionId);
     this.startCooldownTimer(groupSessionId, groupId, selfId);
   }
-}
+}

package/manage/idle-check.ts

@@ -2,7 +2,7 @@ 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 type { SessionManager } from "./session";
@@ -30,7 +30,8 @@ export class IdleCheckManager {
   private intervalHandle: NodeJS.Timeout | null = null;
 
   private ctx: MiokiContext;
-  private cfg: ChatConfig;
+  private configProvider: ChatConfigProvider;
+  private defaultConfig: ChatConfig;
   private db: ChatDatabase;
   private humanize: HumanizeEngine;
   private aiInstance: AIInstance;
@@ -50,7 +51,8 @@ export class IdleCheckManager {
 
   constructor(pluginCtx: ChatPluginContext) {
     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;
@@ -106,24 +108,27 @@ export class IdleCheckManager {
 
   private async tick(): Promise<void> {
     try {
-      const cfg = this.cfg;
-      if (!cfg.apiKey || !cfg.planner?.enabled) return;
+      const baseCfg = this.defaultConfig;
+      if (!baseCfg.apiKey) return;
 
       const now = Date.now();
-      const idleThreshold = cfg.planner.idleThresholdMs ?? 30 * 60_000;
-      const messageCountThreshold = cfg.planner.idleMessageCount ?? 100;
       const checkInterval = 60_000;
       const allBotIds = Array.from(this.ctx.bots).map((bot) => bot.uin);
-      const idleCheckBotIds = cfg.planner.idleCheckBotIds ?? allBotIds;
-      const enabledBotIds = idleCheckBotIds.filter((id) => allBotIds.includes(id));
 
       for (const [groupSessionId, lastTime] of this.groupLastActivityTime) {
         const lastCheckTime = this.groupLastIdleCheckTime.get(groupSessionId) ?? 0;
         if (now - lastCheckTime < checkInterval) continue;
 
         const groupId = parseInt(groupSessionId.split(":")[1], 10);
+        const cfg = this.configProvider(groupId);
+        if (!cfg.planner?.enabled) continue;
         if (!isGroupAllowed(groupId, cfg)) continue;
 
+        const idleThreshold = cfg.planner.idleThresholdMs ?? baseCfg.planner?.idleThresholdMs ?? 30 * 60_000;
+        const messageCountThreshold = cfg.planner.idleMessageCount ?? baseCfg.planner?.idleMessageCount ?? 100;
+        const idleCheckBotIds = cfg.planner.idleCheckBotIds ?? baseCfg.planner?.idleCheckBotIds ?? allBotIds;
+        const enabledBotIds = idleCheckBotIds.filter((id: number) => allBotIds.includes(id));
+
         let lastBotTime = this.groupLastBotMessageTime.get(groupSessionId) ?? 0;
         if (lastBotTime === 0) {
           const botMsgs = this.db.getBotMessages(groupId, 1);