mioku-plugin-chat 3.0.5 → 3.1.0

package/handlers/poke.ts

@@ -15,12 +15,13 @@ export function createPokeHandler(
   const { getConfig, runtimeState, pokeCooldowns } = state;
 
   return async (e: NoticeEvent) => {
-    const selfId = Number(e.self_id || 0);
-    const targetId = Number(
-      (e.raw as { target_id?: string } | undefined)?.target_id ?? 0,
-    );
-    if (targetId !== selfId) return;
-    const groupId = Number(e.group_id || 0);
+    const selfId = String(e.self_id ?? "").trim();
+    const raw = e.raw as { target_id?: unknown; user_id?: unknown } | undefined;
+    const targetId = String(
+      raw?.target_id ?? raw?.user_id ?? e.user_id ?? "",
+    ).trim();
+    if (!targetId || targetId !== selfId) return;
+    const groupId = String(e.group_id ?? "").trim();
     const cfg = groupId ? await getConfig(groupId) : await getConfig();
     if (!cfg.model && !cfg.apiKey) return;
     if (!groupId || !isGroupAllowed(groupId, cfg)) return;
@@ -42,10 +43,9 @@ export function createPokeHandler(
             "group",
             groupId,
           );
-          const userId = Number(e.user_id || 0);
+          const userId = String(e.user_id ?? "").trim();
           const botRole = await getBotRole(groupId, ctx, selfId);
-          const botNickname =
-            cfg.nicknames[0] || e.bot?.nickname || "Bot";
+          const botNickname = cfg.nicknames[0] || e.bot?.nickname || "Bot";
 
           let senderName = String(userId);
           try {
@@ -54,9 +54,7 @@ export function createPokeHandler(
               ? await bot.getMemberInfo(groupId, userId)
               : undefined;
             senderName =
-              memberInfo?.card ||
-              memberInfo?.nickname ||
-              String(userId);
+              memberInfo?.card || memberInfo?.nickname || String(userId);
           } catch {}
 
           const targetMessage: TargetMessage = {
@@ -76,8 +74,11 @@ export function createPokeHandler(
             selfId,
             pluginCtx.buildHistoryMediaOptions(pluginCtx.aiInstance, cfg),
           );
-          const { groupName, memberCount } =
-            await pluginCtx.getGroupInfoData(ctx, groupId, selfId);
+          const { groupName, memberCount } = await pluginCtx.getGroupInfoData(
+            ctx,
+            groupId,
+            selfId,
+          );
 
           const toolCtx = pluginCtx.buildToolContext({
             ctx,

package/humanize/emotion-agent.ts

@@ -38,7 +38,7 @@ export class EmotionAgent {
     return state;
   }
 
-  getAvailableEmotions(groupId?: number): string[] {
+  getAvailableEmotions(groupId?: string): string[] {
     const cfg = this.getConfig(groupId);
     const emotions = Object.keys(cfg.emotion?.emotions || {})
       .map((name) => name.trim().toLowerCase())
@@ -46,7 +46,7 @@ export class EmotionAgent {
     return Array.from(new Set(["default", ...emotions]));
   }
 
-  getReferenceExamples(emotion: string, groupId?: number): string[] {
+  getReferenceExamples(emotion: string, groupId?: string): string[] {
     const cfg = this.getConfig(groupId);
     const normalized = this.normalizeEmotionName(emotion);
     const emotions = cfg.emotion?.emotions || {};
@@ -55,7 +55,7 @@ export class EmotionAgent {
     return this.normalizeExamples(emotions[this.getDefaultEmotion(groupId)]?.examples);
   }
 
-  setEmotion(sessionId: string, emotion: string, groupId?: number): EmotionState {
+  setEmotion(sessionId: string, emotion: string, groupId?: string): EmotionState {
     const current = this.resolveEmotion(emotion, groupId);
     const state = { current, updatedAt: Date.now() };
     this.states.set(sessionId, state);
@@ -144,14 +144,14 @@ ${input.targetMessage.userName}: ${input.targetMessage.content}`;
     return this.resolveEmotion(parsed?.emotion, extractGroupIdFromSession(input.sessionId));
   }
 
-  private resolveEmotion(emotion: unknown, groupId?: number): string {
+  private resolveEmotion(emotion: unknown, groupId?: string): string {
     const normalized = this.normalizeEmotionName(emotion);
     const available = this.getAvailableEmotions(groupId);
     if (available.includes(normalized)) return normalized;
     return this.getDefaultEmotion(groupId);
   }
 
-  private getDefaultEmotion(groupId?: number): string {
+  private getDefaultEmotion(groupId?: string): string {
     const cfg = this.getConfig(groupId);
     const configured = this.normalizeEmotionName(cfg.emotion?.defaultEmotion);
     const available = this.getAvailableEmotions(groupId);

package/humanize/expression.ts

@@ -9,8 +9,8 @@ export class ExpressionLearner {
   private ai: AIInstance;
   private getConfig: ChatConfigProvider;
   private db: ChatDatabase;
-  private pendingMessagesByUser: Map<number, ChatMessage[]> = new Map();
-  private learningUsers: Set<number> = new Set();
+  private pendingMessagesByUser: Map<string, ChatMessage[]> = new Map();
+  private learningUsers: Set<string> = new Set();
 
   constructor(ai: AIInstance, configProvider: ChatConfigProvider, db: ChatDatabase) {
     this.ai = ai;
@@ -33,9 +33,9 @@ export class ExpressionLearner {
   }
 
   getExpressionContextForUser(
-    userId: number,
+    userId: string,
     userName: string,
-    groupId?: number,
+    groupId?: string,
   ): string {
     const cfg = this.getConfig(groupId);
     if (!cfg.expression?.enabled) return "";
@@ -62,7 +62,7 @@ export class ExpressionLearner {
     return context;
   }
 
-  private async tryLearn(userId: number, cfg = this.getConfig()): Promise<void> {
+  private async tryLearn(userId: string, cfg = this.getConfig()): Promise<void> {
     if (this.learningUsers.has(userId)) return;
 
     const threshold = Math.max(
@@ -95,7 +95,7 @@ export class ExpressionLearner {
   }
 
   private async learnForUser(
-    userId: number,
+    userId: string,
     messages: ChatMessage[],
     cfg = this.getConfig(),
   ): Promise<void> {

package/humanize/index.ts

@@ -16,7 +16,7 @@ import { TopicTracker } from "./topic";
 import { ActionPlanner } from "./planner";
 import { ExpressionLearner } from "./expression";
 
-export type ChatConfigProvider = (groupId?: number) => ChatConfig;
+export type ChatConfigProvider = (groupId?: string) => ChatConfig;
 
 export class HumanizeEngine {
   readonly memoryRetrieval: MemoryRetrieval;

package/humanize/memory.ts

@@ -6,7 +6,7 @@ import { extractGroupIdFromSession } from "../utils/group-config";
 import type { ChatConfigProvider } from "./index";
 
 export interface MemoryUserHistoryChunk {
-  userId: number;
+  userId: string;
   messages: ChatMessage[];
 }
 

package/index.ts

@@ -261,7 +261,7 @@ export default definePlugin({
       });
     }
 
-    const configProvider: ChatConfigProvider = (groupId?: number) => {
+    const configProvider: ChatConfigProvider = (groupId?: string) => {
       const base = cachedBaseConfig;
       if (!base) return PERSONALIZATION_CONFIG as unknown as ChatConfig;
       if (groupId === undefined) return base;
@@ -269,7 +269,7 @@ export default definePlugin({
       return mergeGroupOverrides(base, overrides);
     };
 
-    const getConfig = async (groupId?: number): Promise<ChatConfig> => {
+    const getConfig = async (groupId?: string): Promise<ChatConfig> => {
       if (!cachedBaseConfig) await refreshBaseCache();
       return configProvider(groupId);
     };
@@ -380,14 +380,14 @@ roleModels = resolved.models;
     rateLimiter.setConfigProvider(configProvider);
     const skillManager = new SkillSessionManager();
 
-    rateLimiter.setQueueLengthGetter((groupId: number) =>
+    rateLimiter.setQueueLengthGetter((groupId: string) =>
       queueManager.getQueueLength(`group:${groupId}`),
     );
 
     const humanize = new HumanizeEngine(workAIInstance, db, configProvider);
     await humanize.init();
 
-    const pokeCooldowns = new Map<number, number>();
+    const pokeCooldowns = new Map<string, number>();
     const processingSet = new Set<string>();
     const sessionTurnScheduler = new SessionTurnScheduler();
     const groupStructuredHistory = new GroupStructuredHistoryManager();
@@ -442,8 +442,8 @@ roleModels = resolved.models;
       audioService,
       startCooldownTimer: (
         groupSessionId: string,
-        groupId: number,
-        selfId: number,
+        groupId: string,
+        selfId: string,
       ) => cooldownManager.startCooldownTimer(groupSessionId, groupId, selfId),
       async recordGroupMessageForLearning(
         userMsg: ChatMessage,
@@ -511,20 +511,25 @@ roleModels = resolved.models;
     aiService.registerChatRuntime(runtime);
 
     ctx.command({
-      name: "/重置会话",
-      match: /^\/重置会话$/,
-      prefixes: false,
+      name: "重置会话",
+      prefixes: ["/", "."],
+      match: /^重置会话$/,
       description: "重置自己的AI聊天记录",
+      usage: ".重置会话",
       handler: async ({ event }) => {
-        if (event.user_id === event.self_id) return;
+        if (String(event.user_id ?? "") === String(event.self_id ?? "")) return;
         const groupId =
-          event.message_type === "group" ? Number(event.group_id) : undefined;
+          event.message_type === "group"
+            ? String(event.group_id ?? "").trim() || undefined
+            : undefined;
         if (groupId) {
           pluginCtx.sessionManager.resetBotMessages(`group:${groupId}`);
           pluginCtx.groupStructuredHistory.clear(`group:${groupId}`);
           await event.reply("已清除本群会话中 AI 发送的消息~");
         } else {
-          const userId = Number(event.user_id || event.sender?.user_id || 0);
+          const userId = String(
+            event.user_id ?? event.sender?.user_id ?? "",
+          ).trim();
           pluginCtx.sessionManager.resetBotMessages(`personal:${userId}`);
           pluginCtx.groupStructuredHistory.clear(`personal:${userId}`);
           await event.reply("已清除你的个人会话中 AI 发送的消息~");
@@ -532,15 +537,18 @@ roleModels = resolved.models;
       },
     });
     ctx.command({
-      name: "/重置群会话",
-      match: /^\/重置群会话$/,
-      prefixes: false,
+      name: "重置群会话",
+      prefixes: ["/", "."],
+      match: /^重置群会话$/,
       permission: "admin",
       description: "重置当前群的AI聊天记录",
+      usage: ".重置群会话",
       handler: async ({ event }) => {
-        if (event.user_id === event.self_id) return;
+        if (String(event.user_id ?? "") === String(event.self_id ?? "")) return;
         const groupId =
-          event.message_type === "group" ? Number(event.group_id) : undefined;
+          event.message_type === "group"
+            ? String(event.group_id ?? "").trim() || undefined
+            : undefined;
         if (!groupId) {
           await event.reply("在群里使用试试看吧~", true);
           return;
@@ -551,14 +559,14 @@ roleModels = resolved.models;
       },
     });
     ctx.command({
-      name: "/tts",
-      match: /^\/tts\s*(.*)$/,
-      prefixes: false,
+      name: "tts",
+      prefixes: ["/", "."],
+      match: /^tts\s*(.*)$/,
       permission: "owner",
       description: "TTS 推理",
-      usage: "/tts <文本>",
+      usage: ".tts <文本>",
       handler: async ({ event, match }) => {
-        if (event.user_id === event.self_id) return;
+        if (String(event.user_id ?? "") === String(event.self_id ?? "")) return;
         await handleTtsCommand(pluginCtx, event, String(match?.[1] ?? "").trim());
       },
     });

package/manage/cooldown.ts

@@ -26,7 +26,7 @@ interface CooldownMessage {
   event: any;
   content: string;
   userName: string;
-  userId: number;
+  userId: string;
   messageId: string;
   timestamp: number;
   isDirectAt: boolean;
@@ -86,8 +86,8 @@ export class CooldownManager {
 
   startCooldownTimer(
     groupSessionId: string,
-    groupId: number,
-    selfId: number,
+    groupId: string,
+    selfId: string,
   ): void {
     const existingTimer = this.cooldownTimeoutIds.get(groupSessionId);
     if (existingTimer) clearTimeout(existingTimer);
@@ -142,7 +142,7 @@ export class CooldownManager {
 
   collectMessage(
     groupSessionId: string,
-    groupId: number,
+    groupId: string,
     event: any,
     content: string,
     isDirectAt: boolean,
@@ -175,9 +175,9 @@ export class CooldownManager {
 
   private async processReviewMessages(
     groupSessionId: string,
-    groupId: number,
+    groupId: string,
     collected: CooldownMessage[],
-    selfId: number,
+    selfId: string,
   ): Promise<void> {
     const mergedContents = collected.map((m) => m.content);
     const userNames = collected.map((m) => m.userName);
@@ -297,9 +297,9 @@ export class CooldownManager {
 
   private async processCooldownWithPlanner(
     groupSessionId: string,
-    groupId: number,
+    groupId: string,
     collected: CooldownMessage[],
-    selfId: number,
+    selfId: string,
   ): Promise<void> {
     const mergedContent = collected.map((m) => m.content).join("\n");
     const firstMsg = collected[0];

package/manage/group-structured-history.ts

@@ -4,7 +4,7 @@ import type { TargetMessage } from "../types";
 
 export interface StructuredUserInput {
   userName: string;
-  userId: number;
+  userId: string;
   userRole?: string;
   userTitle?: string;
   content: string;
@@ -192,7 +192,7 @@ function formatStructuredUserContent(input: StructuredUserInput): string {
   const lines = [
     "[Group Member Message]",
     `Name: ${input.userName || "unknown"}`,
-    `QQ: ${input.userId || 0}`,
+    `user_id: ${input.userId || "unknown"}`,
     `Time: ${formatTimestamp(input.timestamp)}`,
   ];
 

package/manage/idle-check.ts

@@ -25,7 +25,7 @@ export class IdleCheckManager {
   private groupLastBotMessageTime = new Map<string, number>();
   private groupMessageCountAfterBot = new Map<string, number>();
   private groupLastIdleCheckTime = new Map<string, number>();
-  private groupBotsMapping = new Map<string, Set<number>>();
+  private groupBotsMapping = new Map<string, Set<string>>();
   private intervalHandle: NodeJS.Timeout | null = null;
 
   private ctx: MiokuContext;
@@ -71,11 +71,11 @@ export class IdleCheckManager {
     this.groupMessageCount.set(groupSessionId, count + 1);
   }
 
-  recordBotMessages(groupSessionId: string, count: number, selfId: number): void {
+  recordBotMessages(groupSessionId: string, count: number, selfId: string): 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); }
+    if (!bots) { bots = new Set<string>(); this.groupBotsMapping.set(groupSessionId, bots); }
     bots.add(selfId);
     this.groupLastBotMessageTime.set(groupSessionId, Date.now());
   }
@@ -106,14 +106,15 @@ export class IdleCheckManager {
 
       const now = Date.now();
       const checkInterval = 60_000;
-      const allBotIds = Array.from(this.ctx.bots).map((bot) => Number(bot.bot_id));
+      const allBotIds = Array.from(this.ctx.bots).map((bot) => String(bot.bot_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 groupId = String(groupSessionId.split(":")[1] ?? "").trim();
+        if (!groupId) continue;
         const cfg = this.configProvider(groupId);
         if (!cfg.planner?.enabled) continue;
         if (!isGroupAllowed(groupId, cfg)) continue;
@@ -130,7 +131,7 @@ export class IdleCheckManager {
           cfg.planner.idleCheckBotIds ??
           baseCfg.planner?.idleCheckBotIds ??
           allBotIds;
-        const enabledBotIds = idleCheckBotIds.filter((id: number) =>
+        const enabledBotIds = idleCheckBotIds.filter((id: string) =>
           allBotIds.includes(id),
         );
 
@@ -193,8 +194,8 @@ export class IdleCheckManager {
 
   private async processIdleCheckTurn(
     groupSessionId: string,
-    groupId: number,
-    selfId: number,
+    groupId: string,
+    selfId: string,
     cfg: ChatConfig,
     scheduledLastActivity: number,
     scheduledAt: number,
@@ -234,7 +235,7 @@ export class IdleCheckManager {
 
     const targetMessage: TargetMessage = {
       userName: "system",
-      userId: 0,
+      userId: "",
       userRole: "member",
       content: "[No one in the group is talking? I'll answer!]",
       messageId: "",
@@ -246,7 +247,7 @@ export class IdleCheckManager {
       event: null,
       groupSessionId,
       groupId,
-      userId: 0,
+      userId: "",
       config: cfg,
       aiService: this.aiService,
       db: this.db,
@@ -292,7 +293,7 @@ export class IdleCheckManager {
       result,
       groupId,
       groupSessionId,
-      userId: 0,
+      userId: "",
       selfId,
       toolCtx,
       send: true,

package/manage/queue-processor.ts

@@ -25,7 +25,7 @@ import { finalizeChatTurn } from "../core/chat-turn";
 import { extractContent, getBotRole } from "../utils";
 
 interface DynamicDelayQueueData {
-  messages: Array<{ event: any; content: string; userName: string; userId: number; messageId: string; timestamp: number }>;
+  messages: Array<{ event: any; content: string; userName: string; userId: string; messageId: string; timestamp: number }>;
   timer: NodeJS.Timeout | null;
   delayUntil: number;
 }
@@ -91,7 +91,7 @@ export class QueueProcessor {
     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 {
+  startDynamicDelayTimer(groupSessionId: string, groupId: string, delayMs: number, selfId: string): void {
     let queueData = this.dynamicDelayQueues.get(groupSessionId);
     if (!queueData) {
       queueData = { messages: [], timer: null, delayUntil: Date.now() + delayMs };
@@ -132,7 +132,7 @@ export class QueueProcessor {
     return queue != null && Date.now() < queue.delayUntil;
   }
 
-  scheduleQueuedMessages(groupSessionId: string, selfId: number): void {
+  scheduleQueuedMessages(groupSessionId: string, selfId: string): void {
     void this.sessionTurnScheduler
       .run(
         groupSessionId,
@@ -156,8 +156,8 @@ export class QueueProcessor {
 
   private async processDynamicDelayMessages(
     groupSessionId: string,
-    groupId: number,
-    selfId: number,
+    groupId: string,
+    selfId: string,
     messages: DynamicDelayQueueData["messages"],
   ): Promise<void> {
     this.ctx.logger.info(`[DynamicDelay] group ${groupId} processes ${messages.length} delayed messages`);
@@ -217,7 +217,7 @@ export class QueueProcessor {
     });
   }
 
-  async processQueuedMessages(groupSessionId: string, selfId: number): Promise<void> {
+  async processQueuedMessages(groupSessionId: string, selfId: string): Promise<void> {
     try {
       const queue = this.queueManager.getQueue(groupSessionId);
       if (!queue || queue.length === 0) {
@@ -225,7 +225,8 @@ export class QueueProcessor {
         return;
       }
 
-      const groupId = parseInt(groupSessionId.split(":")[1], 10);
+      const groupId = String(groupSessionId.split(":")[1] ?? "").trim();
+      if (!groupId) return;
       this.ctx.logger.info(`[Queue] group ${groupSessionId} batch ${queue.length} messages`);
 
       const queuedContents: string[] = [];
@@ -255,7 +256,7 @@ export class QueueProcessor {
       const mergedContent = queuedContents.join("\n");
 
       const targetMessage: TargetMessage = {
-        userName, userId: firstItem.event.user_id || firstItem.event.sender?.user_id,
+        userName, userId: String(firstItem.event.user_id ?? firstItem.event.sender?.user_id ?? "").trim(),
         userRole: firstItem.event.sender?.role || "member", content: mergedContent,
         messageId: firstItem.event.message_id, timestamp: Date.now(),
       };

package/manage/rate-limit-guard.ts

@@ -52,8 +52,8 @@ export class RateLimitGuard {
   async run<T>(
     request: () => Promise<T>,
     opts?: {
-      userId?: number;
-      groupId?: number;
+      userId?: string;
+      groupId?: string;
       label?: string;
       skipRetryOnRateLimit?: boolean;
     },

package/manage/rate-limiter.ts

@@ -13,16 +13,16 @@ const DEFAULT_AI_REQUEST_LIMITS: AIRequestLimitConfig = {
   windowMs: 60_000,
 };
 
-export type ChatConfigProvider = (groupId?: number) => ChatConfig;
+export type ChatConfigProvider = (groupId?: string) => ChatConfig;
 
 export class RateLimiter {
-  private userTriggers: Map<number, number[]> = new Map();
-  private userMessages: Map<number, { content: string; timestamp: number }[]> =
+  private userTriggers: Map<string, number[]> = new Map();
+  private userMessages: Map<string, { content: string; timestamp: number }[]> =
     new Map();
-  private groupLastResponse: Map<number, number> = new Map();
-  private groupInteractions: Map<number, Map<number, number[]>> = new Map();
-  private userAiRequests: Map<number, number[]> = new Map();
-  private groupAiRequests: Map<number, number[]> = new Map();
+  private groupLastResponse: Map<string, number> = new Map();
+  private groupInteractions: Map<string, Map<string, number[]>> = new Map();
+  private userAiRequests: Map<string, number[]> = new Map();
+  private groupAiRequests: Map<string, number[]> = new Map();
 
   private readonly maxTriggersPerWindow: number;
   private readonly windowMs: number;
@@ -30,13 +30,13 @@ export class RateLimiter {
   private readonly groupCooldownMs: number;
   private readonly cleanupTimer: ReturnType<typeof setInterval>;
   private getConfig: ChatConfigProvider;
-  private getQueueLengthFn: ((groupId: number) => number) | null = null;
+  private getQueueLengthFn: ((groupId: string) => number) | null = null;
 
   setConfigProvider(provider: ChatConfigProvider): void {
     this.getConfig = provider;
   }
 
-  setQueueLengthGetter(fn: (groupId: number) => number): void {
+  setQueueLengthGetter(fn: (groupId: string) => number): void {
     this.getQueueLengthFn = fn;
   }
 
@@ -58,17 +58,17 @@ export class RateLimiter {
     this.cleanupTimer = setInterval(() => this.cleanup(), 300_000);
   }
 
-  private getDynamicDelay(groupId?: number): DynamicDelayConfig {
+  private getDynamicDelay(groupId?: string): DynamicDelayConfig {
     return this.getConfig(groupId)?.dynamicDelay ?? DEFAULT_DYNAMIC_DELAY;
   }
 
-  private getAiRequestLimits(groupId?: number): AIRequestLimitConfig {
+  private getAiRequestLimits(groupId?: string): AIRequestLimitConfig {
     return this.getConfig(groupId)?.aiRequestLimits ?? DEFAULT_AI_REQUEST_LIMITS;
   }
 
   canProcess(
-    userId: number,
-    groupId: number | undefined,
+    userId: string,
+    groupId: string | undefined,
     content: string,
   ): boolean {
     const now = Date.now();
@@ -93,7 +93,7 @@ export class RateLimiter {
     return !recentSame;
   }
 
-  record(userId: number, groupId: number | undefined, content: string): void {
+  record(userId: string, groupId: string | undefined, content: string): void {
     const now = Date.now();
 
     const triggers = this.userTriggers.get(userId) ?? [];
@@ -110,7 +110,7 @@ export class RateLimiter {
     }
   }
 
-  recordInteraction(groupId: number, userId: number): void {
+  recordInteraction(groupId: string, userId: string): void {
     const dynamicDelay = this.getDynamicDelay(groupId);
     if (!dynamicDelay.enabled) return;
 
@@ -129,7 +129,7 @@ export class RateLimiter {
     groupUsers.set(userId, timestamps);
   }
 
-  canRunAIRequest(userId?: number, groupId?: number): boolean {
+  canRunAIRequest(userId?: string, groupId?: string): boolean {
     const now = Date.now();
     const { userRpm, groupRpm, windowMs } = this.getAiRequestLimits(groupId);
 
@@ -154,7 +154,7 @@ export class RateLimiter {
     return true;
   }
 
-  recordAIRequest(userId?: number, groupId?: number): void {
+  recordAIRequest(userId?: string, groupId?: string): void {
     const now = Date.now();
     const { windowMs } = this.getAiRequestLimits(groupId);
 
@@ -175,7 +175,7 @@ export class RateLimiter {
     }
   }
 
-  getInteractionCount(groupId: number): number {
+  getInteractionCount(groupId: string): number {
     const now = Date.now();
     const { interactionWindowMs: windowMs } = this.getDynamicDelay(groupId);
 
@@ -199,7 +199,7 @@ export class RateLimiter {
     return count;
   }
 
-  calculateDelay(groupId: number): number {
+  calculateDelay(groupId: string): number {
     const dynamicDelay = this.getDynamicDelay(groupId);
     if (!dynamicDelay.enabled) return 0;
 
@@ -211,7 +211,7 @@ export class RateLimiter {
     return Math.min(delay, maxDelayMs);
   }
 
-  getDelayInfo(groupId: number): {
+  getDelayInfo(groupId: string): {
     delayMs: number;
     interactionCount: number;
     shouldDelay: boolean;
@@ -225,7 +225,7 @@ export class RateLimiter {
     };
   }
 
-  clearGroupInteractions(groupId: number): void {
+  clearGroupInteractions(groupId: string): void {
     this.groupInteractions.delete(groupId);
   }
 

package/manage/session.ts

@@ -17,7 +17,7 @@ export class SessionManager {
   /**
    * 获取或创建会话
    */
-  getOrCreate(id: string, type: SessionType, targetId: number): SessionMeta {
+  getOrCreate(id: string, type: SessionType, targetId: string): SessionMeta {
     // 先查缓存
     if (this.cache.has(id)) {
       return this.touch(id);