mioku-plugin-chat 2.5.2 → 2.7.0

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";
@@ -11,26 +11,26 @@ import type {
   HistoryMediaOptions,
   GetGroupHistoryMessages,
   GetGroupInfoData,
-  SendAIResponse,
-  SaveBotMessages,
   RunChat,
   BuildToolContext,
 } from "./types";
 import type { ChatPluginContext } from "../context";
+import { finalizeChatTurn } from "../core/chat-turn";
 import { getBotRole, isGroupAllowed } from "../utils";
 
 export class IdleCheckManager {
+  private pluginCtx: ChatPluginContext;
   private groupLastActivityTime = new Map<string, number>();
   private groupMessageCount = new Map<string, number>();
   private groupLastBotMessageTime = new Map<string, number>();
   private groupMessageCountAfterBot = new Map<string, number>();
-  private idleCheckProcessing = new Set<string>();
   private groupLastIdleCheckTime = new Map<string, number>();
   private groupBotsMapping = new Map<string, Set<number>>();
   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;
@@ -42,15 +42,14 @@ export class IdleCheckManager {
   private buildHistoryMediaOptions: (ai: AIInstance, cfg: ChatConfig) => HistoryMediaOptions;
   private getGroupHistoryMessages: GetGroupHistoryMessages;
   private getGroupInfoData: GetGroupInfoData;
-  private sendAIResponse: SendAIResponse;
-  private saveBotMessages: SaveBotMessages;
   private runChat: RunChat;
   private buildToolContext: BuildToolContext;
-  private startCooldownTimer: (groupSessionId: string, groupId: number, selfId: number) => void;
 
   constructor(pluginCtx: ChatPluginContext) {
+    this.pluginCtx = pluginCtx;
     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;
@@ -62,11 +61,8 @@ export class IdleCheckManager {
     this.buildHistoryMediaOptions = pluginCtx.buildHistoryMediaOptions;
     this.getGroupHistoryMessages = pluginCtx.getGroupHistoryMessages;
     this.getGroupInfoData = pluginCtx.getGroupInfoData;
-    this.sendAIResponse = pluginCtx.sendAIResponse;
-    this.saveBotMessages = pluginCtx.saveBotMessages;
     this.runChat = pluginCtx.runChat;
     this.buildToolContext = pluginCtx.buildToolContext;
-    this.startCooldownTimer = pluginCtx.startCooldownTimer;
   }
 
   recordActivity(groupSessionId: string): void {
@@ -99,32 +95,47 @@ export class IdleCheckManager {
     this.groupMessageCount.clear();
     this.groupLastBotMessageTime.clear();
     this.groupMessageCountAfterBot.clear();
-    this.idleCheckProcessing.clear();
     this.groupLastIdleCheckTime.clear();
     this.groupBotsMapping.clear();
   }
 
   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;
+        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;
 
-        let lastBotTime = this.groupLastBotMessageTime.get(groupSessionId) ?? 0;
+        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);
           if (botMsgs.length > 0) {
@@ -136,71 +147,158 @@ export class IdleCheckManager {
         const lastActivityTime = Math.max(lastTime, lastBotTime);
         if (now - lastActivityTime < idleThreshold) continue;
 
-        const messageCountAfterBot = this.groupMessageCountAfterBot.get(groupSessionId) ?? 0;
-        const messageCount = lastBotTime > 0 ? messageCountAfterBot : (this.groupMessageCount.get(groupSessionId) ?? 0);
+        const messageCountAfterBot =
+          this.groupMessageCountAfterBot.get(groupSessionId) ?? 0;
+        const messageCount =
+          lastBotTime > 0
+            ? messageCountAfterBot
+            : (this.groupMessageCount.get(groupSessionId) ?? 0);
         if (messageCount < messageCountThreshold) continue;
 
         const botsInGroup = this.groupBotsMapping.get(groupSessionId);
         if (!botsInGroup || botsInGroup.size === 0) continue;
-        const availableBots = Array.from(botsInGroup).filter((id) => enabledBotIds.includes(id));
+        const availableBots = Array.from(botsInGroup).filter((id) =>
+          enabledBotIds.includes(id),
+        );
         if (availableBots.length === 0) continue;
 
-        const selfId = availableBots[Math.floor(Math.random() * availableBots.length)];
-        this.idleCheckProcessing.add(groupSessionId);
+        const selfId =
+          availableBots[Math.floor(Math.random() * availableBots.length)];
+        this.groupLastIdleCheckTime.set(groupSessionId, now);
+        void this.pluginCtx.sessionTurnScheduler
+          .run(
+            groupSessionId,
+            "idle-check",
+            () =>
+              this.processIdleCheckTurn(
+                groupSessionId,
+                groupId,
+                selfId,
+                cfg,
+                lastActivityTime,
+                now,
+              ),
+            { dedupeKey: "idle-check" },
+          )
+          .catch((err) =>
+            this.ctx.logger.error(
+              `[IdleCheck] group ${groupId} idle detection failed: ${err}`,
+            ),
+          );
+      }
+    } catch (err) {
+      this.ctx.logger.error(`[IdleCheck] tick failed: ${err}`);
+    }
+  }
 
-        try {
-          this.ctx.logger.info(`[IdleCheck] group ${groupId} triggers idle detection`);
+  private async processIdleCheckTurn(
+    groupSessionId: string,
+    groupId: number,
+    selfId: number,
+    cfg: ChatConfig,
+    scheduledLastActivity: number,
+    scheduledAt: number,
+  ): Promise<void> {
+    const latestActivity = Math.max(
+      this.groupLastActivityTime.get(groupSessionId) ?? 0,
+      this.groupLastBotMessageTime.get(groupSessionId) ?? 0,
+    );
+    if (latestActivity > scheduledLastActivity) return;
 
-          const { history } = await this.getGroupHistoryMessages(groupId, groupSessionId, this.ctx, cfg.historyCount, this.db, selfId, this.buildHistoryMediaOptions(this.aiInstance, cfg));
-          const botNickname = cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
+    this.ctx.logger.info(`[IdleCheck] group ${groupId} triggers idle detection`);
+    const { history } = await this.getGroupHistoryMessages(
+      groupId,
+      groupSessionId,
+      this.ctx,
+      cfg.historyCount,
+      this.db,
+      selfId,
+      this.buildHistoryMediaOptions(this.aiInstance, cfg),
+    );
+    const botNickname =
+      cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
+    const planResult = await this.humanize.actionPlanner.plan(
+      groupSessionId,
+      botNickname,
+      history,
+      "[Check if you want to answer the call]",
+      true,
+    );
 
-          const planResult = await this.humanize.actionPlanner.plan(groupSessionId, botNickname, history, "[Check if you want to answer the call]", true);
+    if (planResult.action !== "reply") {
+      this.groupMessageCount.set(groupSessionId, 0);
+      this.groupMessageCountAfterBot.set(groupSessionId, 0);
+      this.groupLastIdleCheckTime.set(groupSessionId, scheduledAt);
+      return;
+    }
 
-          if (planResult.action !== "reply") {
-            this.groupMessageCount.set(groupSessionId, 0);
-            this.groupMessageCountAfterBot.set(groupSessionId, 0);
-            this.groupLastIdleCheckTime.set(groupSessionId, now);
-            return;
-          }
+    const targetMessage: TargetMessage = {
+      userName: "system",
+      userId: 0,
+      userRole: "member",
+      content: "[No one in the group is talking? I'll answer!]",
+      messageId: 0,
+      timestamp: scheduledAt,
+    };
+    const botRole = await getBotRole(groupId, this.ctx, selfId);
+    const toolCtx = this.buildToolContext({
+      ctx: this.ctx,
+      event: null,
+      groupSessionId,
+      groupId,
+      userId: 0,
+      config: cfg,
+      aiService: this.aiService,
+      db: this.db,
+      botRole,
+      humanize: this.humanize,
+      targetMessage,
+      selfId,
+    });
 
-          const targetMessage: TargetMessage = {
-            userName: "system", userId: 0, userRole: "member",
-            content: "[No one in the group is talking? I'll answer!]", messageId: 0, timestamp: now,
-          };
-
-          const botRole = await getBotRole(groupId, this.ctx, selfId);
-          const toolCtx = this.buildToolContext({
-            ctx: this.ctx, event: null, groupSessionId, groupId, userId: 0,
-            config: cfg, aiService: this.aiService, db: this.db, botRole, humanize: this.humanize, targetMessage, selfId,
-          });
-
-          const result = await this.runWithRateLimitGuard(
-            () => this.runChat(this.aiInstance, toolCtx, history, targetMessage, {
-              config: cfg, botNickname, botRole: toolCtx.botRole, aiService: this.aiService, isGroup: true,
-              plannerThoughts: "You stumbled upon some message in this group and decided to reply.\nQuote messages from group friends appropriately (using [reply:message ID] format).\nDon't mention your intentions like \"I'm here to answer\".",
-              replyContext: { type: "idle" },
-            }, this.humanize, this.skillManager),
-            { groupId, label: "idle-check" },
-          );
-          if (!result) {
-            this.groupMessageCount.set(groupSessionId, 0);
-            this.groupMessageCountAfterBot.set(groupSessionId, 0);
-            this.groupLastIdleCheckTime.set(groupSessionId, now);
-            return;
-          }
+    const result = await this.runWithRateLimitGuard(
+      () =>
+        this.runChat(
+          this.aiInstance,
+          toolCtx,
+          history,
+          targetMessage,
+          {
+            config: cfg,
+            botNickname,
+            botRole: toolCtx.botRole,
+            aiService: this.aiService,
+            isGroup: true,
+            plannerThoughts:
+              'You stumbled upon some message in this group and decided to reply.\nQuote messages from group friends appropriately (using [reply:message ID] format).\nDon\'t mention your intentions like "I\'m here to answer".',
+            replyContext: { type: "idle" },
+          },
+          this.humanize,
+          this.skillManager,
+        ),
+      { groupId, label: "idle-check" },
+    );
+    if (!result) {
+      this.groupMessageCount.set(groupSessionId, 0);
+      this.groupMessageCountAfterBot.set(groupSessionId, 0);
+      this.groupLastIdleCheckTime.set(groupSessionId, scheduledAt);
+      return;
+    }
 
-          await this.sendAIResponse({ ctx: this.ctx, groupId, messages: result.messages, config: cfg, sentIndices: toolCtx.sentMessageIndices }, selfId);
-          this.saveBotMessages(groupId, groupSessionId, result.messages, now, cfg, this.db, this.ctx, selfId);
-          this.groupLastBotMessageTime.set(groupSessionId, now);
-          this.groupMessageCountAfterBot.set(groupSessionId, 0);
-          this.startCooldownTimer(groupSessionId, groupId, selfId);
-          this.ctx.logger.info(`[IdleCheck] group ${groupId} idle reply completed`);
-        } catch (err) {
-          this.ctx.logger.error(`[IdleCheck] group ${groupId} idle detection failed: ${err}`);
-        } finally {
-          this.idleCheckProcessing.delete(groupSessionId);
-        }
-      }
-    } catch (err) {}
+    await finalizeChatTurn(this.pluginCtx, {
+      event: null,
+      cfg,
+      result,
+      groupId,
+      groupSessionId,
+      userId: 0,
+      selfId,
+      toolCtx,
+      send: true,
+      isLive: true,
+    });
+    this.groupLastBotMessageTime.set(groupSessionId, Date.now());
+    this.groupMessageCountAfterBot.set(groupSessionId, 0);
+    this.ctx.logger.info(`[IdleCheck] group ${groupId} idle reply completed`);
   }
 }

package/manage/queue-processor.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, StructuredUserInput } from "./group-structured-history";
 import { buildStructuredUserInputFromEvent } from "./group-structured-history";
@@ -15,14 +15,13 @@ import type {
   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 { extractContent, getBotRole } from "../utils";
 
 interface DynamicDelayQueueData {
@@ -33,9 +32,11 @@ interface DynamicDelayQueueData {
 
 export class QueueProcessor {
   private dynamicDelayQueues = new Map<string, DynamicDelayQueueData>();
+  private pluginCtx: ChatPluginContext;
 
   private ctx: MiokiContext;
-  private cfg: ChatConfig;
+  private configProvider: ChatConfigProvider;
+  private defaultConfig: ChatConfig;
   private db: ChatDatabase;
   private humanize: HumanizeEngine;
   private aiInstance: AIInstance;
@@ -50,17 +51,16 @@ export class QueueProcessor {
   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;
-  private startCooldownTimer: (groupSessionId: string, groupId: number, selfId: number) => void;
+  private sessionTurnScheduler: SessionTurnScheduler;
 
   constructor(pluginCtx: ChatPluginContext) {
+    this.pluginCtx = pluginCtx;
     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;
@@ -75,13 +75,10 @@ export class QueueProcessor {
     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;
-    this.startCooldownTimer = pluginCtx.startCooldownTimer;
+    this.sessionTurnScheduler = pluginCtx.sessionTurnScheduler;
   }
 
   collectDynamicDelayMessage(groupSessionId: string, event: any, content: string): void {
@@ -105,9 +102,29 @@ export class QueueProcessor {
 
     this.ctx.logger.info(`[DynamicDelay] group ${groupId} start delay ${delayMs / 1000}s, interactions: ${this.rateLimiter.getInteractionCount(groupId)}`);
 
-    queueData.timer = setTimeout(async () => {
-      await this.processDynamicDelayQueue(groupSessionId, groupId, selfId);
+    const timer = setTimeout(() => {
+      const current = this.dynamicDelayQueues.get(groupSessionId);
+      if (!current || current !== queueData || current.timer !== timer) return;
+      this.dynamicDelayQueues.delete(groupSessionId);
+      current.timer = null;
+      const messages = current.messages;
+      if (messages.length === 0) return;
+      void this.sessionTurnScheduler
+        .run(groupSessionId, "dynamic-delay", () =>
+          this.processDynamicDelayMessages(
+            groupSessionId,
+            groupId,
+            selfId,
+            messages,
+          ),
+        )
+        .catch((err) =>
+          this.ctx.logger.error(
+            `[DynamicDelay] group ${groupId} processing failed: ${err}`,
+          ),
+        );
     }, delayMs);
+    queueData.timer = timer;
   }
 
   isInDynamicDelay(groupSessionId: string): boolean {
@@ -115,6 +132,21 @@ export class QueueProcessor {
     return queue != null && Date.now() < queue.delayUntil;
   }
 
+  scheduleQueuedMessages(groupSessionId: string, selfId: number): void {
+    void this.sessionTurnScheduler
+      .run(
+        groupSessionId,
+        "queued-message",
+        () => this.processQueuedMessages(groupSessionId, selfId),
+        { dedupeKey: `queued-message:${selfId}` },
+      )
+      .catch((err) =>
+        this.ctx.logger.error(
+          `[Queue] group ${groupSessionId} scheduling failed: ${err}`,
+        ),
+      );
+  }
+
   dispose(): void {
     for (const queue of this.dynamicDelayQueues.values()) {
       if (queue.timer) clearTimeout(queue.timer);
@@ -122,16 +154,12 @@ export class QueueProcessor {
     this.dynamicDelayQueues.clear();
   }
 
-  async processDynamicDelayQueue(groupSessionId: string, groupId: number, selfId: number): Promise<void> {
-    const queueData = this.dynamicDelayQueues.get(groupSessionId);
-    if (!queueData || queueData.messages.length === 0) {
-      this.dynamicDelayQueues.delete(groupSessionId);
-      return;
-    }
-
-    const messages = queueData.messages;
-    this.dynamicDelayQueues.delete(groupSessionId);
-
+  private async processDynamicDelayMessages(
+    groupSessionId: string,
+    groupId: number,
+    selfId: number,
+    messages: DynamicDelayQueueData["messages"],
+  ): Promise<void> {
     this.ctx.logger.info(`[DynamicDelay] group ${groupId} processes ${messages.length} delayed messages`);
     this.rateLimiter.clearGroupInteractions(groupId);
 
@@ -147,14 +175,15 @@ export class QueueProcessor {
       content: mergedContent, messageId: firstMsg.messageId, timestamp: Date.now(),
     };
 
+    const cfg = this.configProvider(groupId);
     const botRole = await getBotRole(groupId, this.ctx, selfId);
-    const botNickname = this.cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
+    const botNickname = cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
     const { groupName, memberCount } = await this.getGroupInfoData(this.ctx, groupId, selfId, String(groupId));
-    const { history } = await this.getGroupHistoryMessages(groupId, groupSessionId, this.ctx, this.cfg.historyCount, this.db, selfId, this.buildHistoryMediaOptions(this.aiInstance, this.cfg));
+    const { history } = await this.getGroupHistoryMessages(groupId, groupSessionId, this.ctx, cfg.historyCount, this.db, selfId, this.buildHistoryMediaOptions(this.aiInstance, cfg));
 
     const toolCtx = this.buildToolContext({
       ctx: this.ctx, event: firstMsg.event, groupSessionId, groupId, userId: firstMsg.userId,
-      config: this.cfg, aiService: this.aiService, db: this.db, botRole, humanize: this.humanize, targetMessage, selfId,
+      config: cfg, aiService: this.aiService, db: this.db, botRole, humanize: this.humanize, targetMessage, selfId,
     });
 
     this.sessionManager.getOrCreate(groupSessionId, "group", groupId);
@@ -162,19 +191,29 @@ export class QueueProcessor {
 
     const result = await this.runWithRateLimitGuard(
       () => this.runChat(this.aiInstance, toolCtx, history, targetMessage, {
-        config: this.cfg, groupName, memberCount, botNickname, botRole, aiService: this.aiService, isGroup: true,
+        config: cfg, groupName, memberCount, botNickname, botRole, aiService: this.aiService, isGroup: true,
         memoryContext: contexts.memoryContext, topicContext: contexts.topicContext, expressionContext: contexts.expressionContext,
         replyContext: { type: "review", targetUser: targetMessage.userName, targetMessage: targetMessage.content },
         reviewMessages: { contents: mergedContents, userNames, messageIds },
       }, this.humanize, this.skillManager, {
-        manager: this.groupStructuredHistory, ttlMs: this.cfg.groupStructuredHistoryTtlMs, currentUserInputs: structuredUserInputs,
+        manager: this.groupStructuredHistory, ttlMs: cfg.groupStructuredHistoryTtlMs, currentUserInputs: structuredUserInputs,
       }),
       { userId: targetMessage.userId, groupId, label: "dynamic-delay" },
     );
     if (!result) return;
 
-    await this.sendAIResponse({ ctx: this.ctx, groupId, messages: result.messages, config: this.cfg, sentIndices: toolCtx.sentMessageIndices }, selfId);
-    this.startCooldownTimer(groupSessionId, groupId, selfId);
+    await finalizeChatTurn(this.pluginCtx, {
+      event: firstMsg.event,
+      cfg,
+      result,
+      groupId,
+      groupSessionId,
+      userId: targetMessage.userId,
+      selfId,
+      toolCtx,
+      send: true,
+      isLive: true,
+    });
   }
 
   async processQueuedMessages(groupSessionId: string, selfId: number): Promise<void> {
@@ -191,8 +230,10 @@ export class QueueProcessor {
       const queuedContents: string[] = [];
       const structuredUserInputs: StructuredUserInput[] = [];
 
+      const cfg = this.configProvider(groupId);
+
       for (const item of queue) {
-        const { text: extractedText, multimodal } = extractContent(item.event, this.cfg, this.ctx);
+        const { text: extractedText, multimodal } = extractContent(item.event, cfg, this.ctx);
         const content = multimodal ? JSON.stringify(multimodal) : extractedText;
         if (content) {
           queuedContents.push(content);
@@ -219,33 +260,40 @@ export class QueueProcessor {
       };
 
       const botRole = await getBotRole(groupId, this.ctx, selfId);
-      const botNickname = this.cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
+      const botNickname = cfg.nicknames[0] || this.ctx.pickBot(selfId).nickname || "Bot";
       const toolCtx = this.buildToolContext({
         ctx: this.ctx, event: null, groupSessionId, groupId, userId: targetMessage.userId,
-        config: this.cfg, aiService: this.aiService, db: this.db, botRole, humanize: this.humanize, targetMessage, selfId,
+        config: cfg, aiService: this.aiService, db: this.db, botRole, humanize: this.humanize, targetMessage, selfId,
       });
 
-      const { history } = await this.getGroupHistoryMessages(groupId, groupSessionId, this.ctx, this.cfg.historyCount, this.db, selfId, this.buildHistoryMediaOptions(this.aiInstance, this.cfg));
+      const { history } = await this.getGroupHistoryMessages(groupId, groupSessionId, this.ctx, cfg.historyCount, this.db, selfId, this.buildHistoryMediaOptions(this.aiInstance, cfg));
       const contexts = await this.getHumanizeContexts(this.humanize, groupSessionId, targetMessage.userName, history, targetMessage.userId);
       const { groupName, memberCount } = await this.getGroupInfoData(this.ctx, groupId, selfId);
 
       const result = await this.runWithRateLimitGuard(
         () => this.runChat(this.aiInstance, toolCtx, history, targetMessage, {
-          config: this.cfg, groupName, memberCount, botNickname, botRole: toolCtx.botRole, aiService: this.aiService, isGroup: true,
+          config: cfg, groupName, memberCount, botNickname, botRole: toolCtx.botRole, aiService: this.aiService, isGroup: true,
           memoryContext: contexts.memoryContext, topicContext: contexts.topicContext, expressionContext: contexts.expressionContext,
           replyContext: { type: "comment", targetUser: targetMessage.userName, targetMessage: targetMessage.content },
         }, this.humanize, this.skillManager, {
-          manager: this.groupStructuredHistory, ttlMs: this.cfg.groupStructuredHistoryTtlMs, currentUserInputs: structuredUserInputs,
+          manager: this.groupStructuredHistory, ttlMs: cfg.groupStructuredHistoryTtlMs, currentUserInputs: structuredUserInputs,
         }),
         { userId: targetMessage.userId, groupId, label: "queue" },
       );
       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(groupId, groupSessionId, result.messages, now, this.cfg, this.db, this.ctx, selfId);
-      this.sessionManager.touch(groupSessionId);
+      await finalizeChatTurn(this.pluginCtx, {
+        event: firstItem.event,
+        cfg,
+        result,
+        groupId,
+        groupSessionId,
+        userId: targetMessage.userId,
+        selfId,
+        toolCtx,
+        send: true,
+        isLive: true,
+      });
       this.ctx.logger.info(`[Queue] group ${groupSessionId} done`);
     } catch (err) {
       this.ctx.logger.error(err);