mioku-plugin-chat 2.6.0 → 2.7.1

package/manage/idle-check.ts

@@ -11,20 +11,19 @@ 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;
@@ -43,13 +42,11 @@ 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.configProvider = pluginCtx.configProvider;
     this.defaultConfig = pluginCtx.defaultConfig;
@@ -64,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 {
@@ -101,7 +95,6 @@ export class IdleCheckManager {
     this.groupMessageCount.clear();
     this.groupLastBotMessageTime.clear();
     this.groupMessageCountAfterBot.clear();
-    this.idleCheckProcessing.clear();
     this.groupLastIdleCheckTime.clear();
     this.groupBotsMapping.clear();
   }
@@ -116,7 +109,8 @@ export class IdleCheckManager {
       const allBotIds = Array.from(this.ctx.bots).map((bot) => bot.uin);
 
       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);
@@ -124,12 +118,24 @@ export class IdleCheckManager {
         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));
+        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;
+        let lastBotTime =
+          this.groupLastBotMessageTime.get(groupSessionId) ?? 0;
         if (lastBotTime === 0) {
           const botMsgs = this.db.getBotMessages(groupId, 1);
           if (botMsgs.length > 0) {
@@ -141,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

@@ -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,6 +32,7 @@ interface DynamicDelayQueueData {
 
 export class QueueProcessor {
   private dynamicDelayQueues = new Map<string, DynamicDelayQueueData>();
+  private pluginCtx: ChatPluginContext;
 
   private ctx: MiokiContext;
   private configProvider: ChatConfigProvider;
@@ -51,15 +51,13 @@ 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.configProvider = pluginCtx.configProvider;
     this.defaultConfig = pluginCtx.defaultConfig;
@@ -77,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 {
@@ -107,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 {
@@ -117,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);
@@ -124,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);
 
@@ -176,8 +202,18 @@ export class QueueProcessor {
     );
     if (!result) return;
 
-    await this.sendAIResponse({ ctx: this.ctx, groupId, messages: result.messages, config: 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> {
@@ -246,11 +282,18 @@ export class QueueProcessor {
       );
       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, 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);

package/manage/session-turn-scheduler.ts

@@ -0,0 +1,130 @@
+export type SessionTurnSource =
+  | "message"
+  | "queued-message"
+  | "cooldown"
+  | "cooldown-planner"
+  | "dynamic-delay"
+  | "idle-check"
+  | "idle-debug"
+  | "poke"
+  | "chat-runtime";
+
+interface SessionTurnEntry<T> {
+  source: SessionTurnSource;
+  dedupeKey?: string;
+  run: () => Promise<T>;
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason: unknown) => void;
+}
+
+interface SessionTurnState {
+  running: boolean;
+  pending: SessionTurnEntry<unknown>[];
+}
+
+export class SessionTurnSchedulerDisposedError extends Error {
+  constructor() {
+    super("Session turn scheduler has been disposed");
+    this.name = "SessionTurnSchedulerDisposedError";
+  }
+}
+
+export class SessionTurnScheduler {
+  private readonly sessions = new Map<string, SessionTurnState>();
+  private disposed = false;
+
+  run<T>(
+    sessionId: string,
+    source: SessionTurnSource,
+    task: () => Promise<T>,
+    options: { dedupeKey?: string } = {},
+  ): Promise<T> {
+    if (this.disposed) {
+      return Promise.reject(new SessionTurnSchedulerDisposedError());
+    }
+
+    const state = this.getOrCreateState(sessionId);
+    if (options.dedupeKey) {
+      const existing = state.pending.find(
+        (entry) => entry.dedupeKey === options.dedupeKey,
+      );
+      if (existing) return existing.promise as Promise<T>;
+    }
+
+    let resolve!: (value: T) => void;
+    let reject!: (reason: unknown) => void;
+    const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+      resolve = resolvePromise;
+      reject = rejectPromise;
+    });
+    const entry: SessionTurnEntry<T> = {
+      source,
+      dedupeKey: options.dedupeKey,
+      run: task,
+      promise,
+      resolve,
+      reject,
+    };
+
+    state.pending.push(entry as SessionTurnEntry<unknown>);
+    if (!state.running) void this.drain(sessionId, state);
+    return promise;
+  }
+
+  isBusy(sessionId: string): boolean {
+    const state = this.sessions.get(sessionId);
+    return Boolean(state?.running || state?.pending.length);
+  }
+
+  pendingCount(sessionId: string): number {
+    return this.sessions.get(sessionId)?.pending.length ?? 0;
+  }
+
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    const error = new SessionTurnSchedulerDisposedError();
+
+    for (const [sessionId, state] of this.sessions) {
+      for (const entry of state.pending.splice(0)) entry.reject(error);
+      if (!state.running) this.sessions.delete(sessionId);
+    }
+  }
+
+  private getOrCreateState(sessionId: string): SessionTurnState {
+    let state = this.sessions.get(sessionId);
+    if (!state) {
+      state = { running: false, pending: [] };
+      this.sessions.set(sessionId, state);
+    }
+    return state;
+  }
+
+  private async drain(
+    sessionId: string,
+    state: SessionTurnState,
+  ): Promise<void> {
+    if (state.running || this.disposed) return;
+    state.running = true;
+
+    try {
+      while (!this.disposed) {
+        const entry = state.pending.shift();
+        if (!entry) break;
+        try {
+          entry.resolve(await entry.run());
+        } catch (err) {
+          entry.reject(err);
+        }
+      }
+    } finally {
+      state.running = false;
+      if (state.pending.length === 0) {
+        this.sessions.delete(sessionId);
+      } else if (!this.disposed) {
+        void this.drain(sessionId, state);
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-chat",
-  "version": "2.6.0",
+  "version": "2.7.1",
   "description": "AI 智能聊天插件",
   "main": "index.ts",
   "type": "module",

package/runtime/chat-runtime.ts

@@ -10,6 +10,18 @@ import type { ChatPluginContext, ChatRuntime } from "../context";
 import type { ChatConfig } from "../types";
 import { executeChatRuntimeRequest } from "../core/chat-turn";
 
+function resolveRuntimeGroupId(
+  options: ChatRuntimeNoticeOptions | ChatRuntimeInformationRequestOptions,
+): number | undefined {
+  if ("event" in options) {
+    const event = options.event;
+    return event?.message_type === "group" && typeof event.group_id === "number"
+      ? event.group_id
+      : undefined;
+  }
+  return "groupId" in options ? options.groupId : undefined;
+}
+
 export function createChatRuntime(
   pluginCtx: ChatPluginContext,
   getConfig: (groupId?: number) => Promise<ChatConfig>,
@@ -79,7 +91,7 @@ export function createChatRuntime(
       const result = await executeChatRuntimeRequest(
         {
           ...options,
-          config: await getConfig(),
+          config: await getConfig(resolveRuntimeGroupId(options)),
           targetMessageContent: options.targetMessage,
           promptInjections,
           extraTools,
@@ -111,7 +123,7 @@ export function createChatRuntime(
       return executeChatRuntimeRequest(
         {
           ...options,
-          config: await getConfig(),
+          config: await getConfig(resolveRuntimeGroupId(options)),
           targetMessageContent: options.instruction,
           promptInjections,
           send: options.send,