mioku-plugin-chat 2.0.0

package/manage/idle-check.ts

@@ -0,0 +1,186 @@
+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 { SkillSessionManager } from "./skill-session";
+import type { GroupStructuredHistoryManager } from "./group-structured-history";
+import type { SessionManager } from "./session";
+import type {
+  RunRateLimitGuard,
+  HistoryMediaOptions,
+  GetGroupHistoryMessages,
+  GetGroupInfoData,
+  SendAIResponse,
+  SaveBotMessages,
+  RunChat,
+  BuildToolContext,
+} from "./types";
+import { getBotRole, isGroupAllowed } from "../utils";
+
+export class IdleCheckManager {
+  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;
+
+  constructor(
+    private ctx: MiokiContext,
+    private cfg: 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 runWithRateLimitGuard: RunRateLimitGuard,
+    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,
+  ) {}
+
+  recordActivity(groupSessionId: string): void {
+    this.groupLastActivityTime.set(groupSessionId, Date.now());
+    const count = this.groupMessageCount.get(groupSessionId) ?? 0;
+    this.groupMessageCount.set(groupSessionId, count + 1);
+  }
+
+  recordBotMessages(groupSessionId: string, count: number, selfId: number): void {
+    const current = this.groupMessageCountAfterBot.get(groupSessionId) ?? 0;
+    this.groupMessageCountAfterBot.set(groupSessionId, current + count);
+    let bots = this.groupBotsMapping.get(groupSessionId);
+    if (!bots) { bots = new Set<number>(); this.groupBotsMapping.set(groupSessionId, bots); }
+    bots.add(selfId);
+    this.groupLastBotMessageTime.set(groupSessionId, Date.now());
+  }
+
+  start(): void {
+    if (this.intervalHandle) return;
+    this.intervalHandle = setInterval(async () => { await this.tick(); }, 60_000);
+  }
+
+  stop(): void {
+    if (this.intervalHandle) { clearInterval(this.intervalHandle); this.intervalHandle = null; }
+  }
+
+  dispose(): void {
+    this.stop();
+    this.groupLastActivityTime.clear();
+    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 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);
+        if (!isGroupAllowed(groupId, cfg)) continue;
+
+        let lastBotTime = this.groupLastBotMessageTime.get(groupSessionId) ?? 0;
+        if (lastBotTime === 0) {
+          const botMsgs = this.db.getBotMessages(groupId, 1);
+          if (botMsgs.length > 0) {
+            lastBotTime = botMsgs[botMsgs.length - 1].timestamp;
+            this.groupLastBotMessageTime.set(groupSessionId, lastBotTime);
+          }
+        }
+
+        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);
+        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));
+        if (availableBots.length === 0) continue;
+
+        const selfId = availableBots[Math.floor(Math.random() * availableBots.length)];
+        this.idleCheckProcessing.add(groupSessionId);
+
+        try {
+          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);
+
+          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: 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;
+          }
+
+          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) {}
+  }
+}

package/manage/queue-processor.ts

@@ -0,0 +1,228 @@
+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 { SkillSessionManager } from "./skill-session";
+import type { GroupStructuredHistoryManager, StructuredUserInput } from "./group-structured-history";
+import type { SessionManager } from "./session";
+import type { RateLimiter } from "./rate-limiter";
+import type { MessageQueueManager } from "../utils/queue";
+import type {
+  RunRateLimitGuard,
+  HistoryMediaOptions,
+  GetGroupHistoryMessages,
+  GetGroupInfoData,
+  GetHumanizeContexts,
+  SendAIResponse,
+  SaveBotMessages,
+  SendEmoji,
+  RunChat,
+  BuildToolContext,
+  BuildStructuredUserInput,
+} from "./types";
+import { extractContent, getBotRole } from "../utils";
+
+interface DynamicDelayQueueData {
+  messages: Array<{ event: any; content: string; userName: string; userId: number; messageId: number; timestamp: number }>;
+  timer: NodeJS.Timeout | null;
+  delayUntil: number;
+}
+
+export class QueueProcessor {
+  private dynamicDelayQueues = new Map<string, DynamicDelayQueueData>();
+
+  constructor(
+    private ctx: MiokiContext,
+    private cfg: 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 queueManager: MessageQueueManager,
+    private runWithRateLimitGuard: RunRateLimitGuard,
+    private buildHistoryMediaOptions: (ai: AIInstance, cfg: ChatConfig) => HistoryMediaOptions,
+    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,
+  ) {}
+
+  collectDynamicDelayMessage(groupSessionId: string, event: any, content: string): void {
+    let queueData = this.dynamicDelayQueues.get(groupSessionId);
+    if (!queueData) {
+      queueData = { messages: [], timer: null, delayUntil: 0 };
+      this.dynamicDelayQueues.set(groupSessionId, queueData);
+    }
+    const userName = event.sender?.card || event.sender?.nickname || String(event.user_id);
+    queueData.messages.push({ event, content, userName, userId: event.user_id, messageId: event.message_id, timestamp: Date.now() });
+  }
+
+  startDynamicDelayTimer(groupSessionId: string, groupId: number, delayMs: number, selfId: number): void {
+    let queueData = this.dynamicDelayQueues.get(groupSessionId);
+    if (!queueData) {
+      queueData = { messages: [], timer: null, delayUntil: Date.now() + delayMs };
+      this.dynamicDelayQueues.set(groupSessionId, queueData);
+    }
+    if (queueData.timer) clearTimeout(queueData.timer);
+    queueData.delayUntil = Date.now() + delayMs;
+
+    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);
+    }, delayMs);
+  }
+
+  isInDynamicDelay(groupSessionId: string): boolean {
+    const queue = this.dynamicDelayQueues.get(groupSessionId);
+    return queue != null && Date.now() < queue.delayUntil;
+  }
+
+  dispose(): void {
+    for (const queue of this.dynamicDelayQueues.values()) {
+      if (queue.timer) clearTimeout(queue.timer);
+    }
+    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);
+
+    this.ctx.logger.info(`[DynamicDelay] group ${groupId} processes ${messages.length} delayed messages`);
+    this.rateLimiter.clearGroupInteractions(groupId);
+
+    const mergedContents = messages.map((m) => m.content);
+    const userNames = messages.map((m) => m.userName);
+    const messageIds = messages.map((m) => m.messageId);
+    const structuredUserInputs = messages.map((m) => this.buildStructuredUserInputFromEvent(m.event, m.content, m.timestamp));
+    const mergedContent = mergedContents.join("\n---\n");
+    const firstMsg = messages[0];
+
+    const targetMessage: TargetMessage = {
+      userName: userNames.join(", "), userId: firstMsg.userId, userRole: "member",
+      content: mergedContent, messageId: firstMsg.messageId, timestamp: Date.now(),
+    };
+
+    const botRole = await getBotRole(groupId, this.ctx, selfId);
+    const botNickname = this.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 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,
+    });
+
+    this.sessionManager.getOrCreate(groupSessionId, "group", groupId);
+    const contexts = await this.getHumanizeContexts(this.humanize, groupSessionId, targetMessage.userName, history, targetMessage.userId);
+
+    const result = await this.runWithRateLimitGuard(
+      () => this.runChat(this.aiInstance, toolCtx, history, targetMessage, {
+        config: this.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,
+      }),
+      { 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);
+  }
+
+  async processQueuedMessages(groupSessionId: string, selfId: number): Promise<void> {
+    try {
+      const queue = this.queueManager.getQueue(groupSessionId);
+      if (!queue || queue.length === 0) {
+        this.queueManager.clearActiveTarget(groupSessionId);
+        return;
+      }
+
+      const groupId = parseInt(groupSessionId.split(":")[1], 10);
+      this.ctx.logger.info(`[Queue] group ${groupSessionId} batch ${queue.length} messages`);
+
+      const queuedContents: string[] = [];
+      const structuredUserInputs: StructuredUserInput[] = [];
+
+      for (const item of queue) {
+        const { text: extractedText, multimodal } = extractContent(item.event, this.cfg, this.ctx);
+        const content = multimodal ? JSON.stringify(multimodal) : extractedText;
+        if (content) {
+          queuedContents.push(content);
+          structuredUserInputs.push(this.buildStructuredUserInputFromEvent(item.event, content, item.queuedAt));
+        }
+      }
+
+      this.queueManager.clearQueue(groupSessionId);
+      if (queuedContents.length === 0) {
+        this.queueManager.clearActiveTarget(groupSessionId);
+        return;
+      }
+
+      this.queueManager.clearActiveTarget(groupSessionId);
+
+      const firstItem = queue[0];
+      const userName = firstItem.event.sender?.card || firstItem.event.sender?.nickname || String(firstItem.event.user_id);
+      const mergedContent = queuedContents.join("\n");
+
+      const targetMessage: TargetMessage = {
+        userName, userId: firstItem.event.user_id || firstItem.event.sender?.user_id,
+        userRole: firstItem.event.sender?.role || "member", content: mergedContent,
+        messageId: firstItem.event.message_id, timestamp: Date.now(),
+      };
+
+      const botRole = await getBotRole(groupId, this.ctx, selfId);
+      const botNickname = this.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,
+      });
+
+      const { history } = await this.getGroupHistoryMessages(groupId, groupSessionId, this.ctx, this.cfg.historyCount, this.db, selfId, this.buildHistoryMediaOptions(this.aiInstance, this.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,
+          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,
+        }),
+        { 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);
+      this.ctx.logger.info(`[Queue] group ${groupSessionId} done`);
+    } catch (err) {
+      this.ctx.logger.error(err);
+    }
+  }
+}