mioku-plugin-chat 2.5.2 → 2.7.0

package/manage/rate-limiter.ts

@@ -1,12 +1,24 @@
-import type { AIRequestLimitConfig, DynamicDelayConfig } from "../types";
+import type { AIRequestLimitConfig, ChatConfig, DynamicDelayConfig } from "../types";
+
+const DEFAULT_DYNAMIC_DELAY: DynamicDelayConfig = {
+  enabled: true,
+  interactionWindowMs: 60_000,
+  baseDelayMs: 30_000,
+  maxDelayMs: 300_000,
+};
+
+const DEFAULT_AI_REQUEST_LIMITS: AIRequestLimitConfig = {
+  userRpm: 3,
+  groupRpm: 6,
+  windowMs: 60_000,
+};
+
+export type ChatConfigProvider = (groupId?: number) => ChatConfig;
 
 export class RateLimiter {
-  // 用户触发记录：userId -> timestamp[]
   private userTriggers: Map<number, number[]> = new Map();
-  // 用户最近消息：userId -> {content, timestamp}[]
   private userMessages: Map<number, { content: string; timestamp: number }[]> =
     new Map();
-  // 群组最后响应时间：groupId -> timestamp
   private groupLastResponse: Map<number, number> = new Map();
   private groupInteractions: Map<number, Map<number, number[]>> = new Map();
   private userAiRequests: Map<number, number[]> = new Map();
@@ -17,14 +29,13 @@ export class RateLimiter {
   private readonly dedupWindowMs: number;
   private readonly groupCooldownMs: number;
   private readonly cleanupTimer: ReturnType<typeof setInterval>;
-  private readonly dynamicDelayConfig: DynamicDelayConfig;
-  private readonly aiRequestLimitConfig: AIRequestLimitConfig;
-  // 外部注入的队列长度获取函数
+  private getConfig: ChatConfigProvider;
   private getQueueLengthFn: ((groupId: number) => number) | null = null;
 
-  /**
-   * 设置队列长度获取函数
-   */
+  setConfigProvider(provider: ChatConfigProvider): void {
+    this.getConfig = provider;
+  }
+
   setQueueLengthGetter(fn: (groupId: number) => number): void {
     this.getQueueLengthFn = fn;
   }
@@ -34,28 +45,27 @@ export class RateLimiter {
     windowMs?: number;
     dedupWindowMs?: number;
     groupCooldownMs?: number;
-    dynamicDelay?: DynamicDelayConfig;
-    aiRequestLimits?: AIRequestLimitConfig;
   }) {
     this.maxTriggersPerWindow = options?.maxTriggersPerWindow ?? 5;
     this.windowMs = options?.windowMs ?? 60_000;
     this.dedupWindowMs = options?.dedupWindowMs ?? 30_000;
     this.groupCooldownMs = options?.groupCooldownMs ?? 1_000;
-    this.dynamicDelayConfig = options?.dynamicDelay ?? {
-      enabled: true,
-      interactionWindowMs: 60_000,
-      baseDelayMs: 30_000,
-      maxDelayMs: 300_000,
-    };
-    this.aiRequestLimitConfig = options?.aiRequestLimits ?? {
-      userRpm: 3,
-      groupRpm: 6,
-      windowMs: 60_000,
-    };
+    this.getConfig = () => ({
+      dynamicDelay: DEFAULT_DYNAMIC_DELAY,
+      aiRequestLimits: DEFAULT_AI_REQUEST_LIMITS,
+    }) as unknown as ChatConfig;
 
     this.cleanupTimer = setInterval(() => this.cleanup(), 300_000);
   }
 
+  private getDynamicDelay(groupId?: number): DynamicDelayConfig {
+    return this.getConfig(groupId)?.dynamicDelay ?? DEFAULT_DYNAMIC_DELAY;
+  }
+
+  private getAiRequestLimits(groupId?: number): AIRequestLimitConfig {
+    return this.getConfig(groupId)?.aiRequestLimits ?? DEFAULT_AI_REQUEST_LIMITS;
+  }
+
   canProcess(
     userId: number,
     groupId: number | undefined,
@@ -63,7 +73,6 @@ export class RateLimiter {
   ): boolean {
     const now = Date.now();
 
-    // 群组冷却检查
     if (groupId) {
       const lastResponse = this.groupLastResponse.get(groupId);
       if (lastResponse && now - lastResponse < this.groupCooldownMs) {
@@ -71,14 +80,12 @@ export class RateLimiter {
       }
     }
 
-    // 用户频率检查
     const triggers = this.userTriggers.get(userId) ?? [];
     const recentTriggers = triggers.filter((t) => now - t < this.windowMs);
     if (recentTriggers.length >= this.maxTriggersPerWindow) {
       return false;
     }
 
-    // 重复消息检查
     const messages = this.userMessages.get(userId) ?? [];
     const recentSame = messages.find(
       (m) => m.content === content && now - m.timestamp < this.dedupWindowMs,
@@ -86,34 +93,29 @@ export class RateLimiter {
     return !recentSame;
   }
 
-  /**
-   * 记录已处理的消息
-   */
   record(userId: number, groupId: number | undefined, content: string): void {
     const now = Date.now();
 
-    // 记录触发
     const triggers = this.userTriggers.get(userId) ?? [];
     triggers.push(now);
     this.userTriggers.set(userId, triggers);
 
-    // 记录消息（只保留最近 3 条）
     const messages = this.userMessages.get(userId) ?? [];
     messages.push({ content, timestamp: now });
     if (messages.length > 3) messages.shift();
     this.userMessages.set(userId, messages);
 
-    // 记录群组响应
     if (groupId) {
       this.groupLastResponse.set(groupId, now);
     }
   }
 
   recordInteraction(groupId: number, userId: number): void {
-    if (!this.dynamicDelayConfig.enabled) return;
+    const dynamicDelay = this.getDynamicDelay(groupId);
+    if (!dynamicDelay.enabled) return;
 
     const now = Date.now();
-    const windowMs = this.dynamicDelayConfig.interactionWindowMs;
+    const windowMs = dynamicDelay.interactionWindowMs;
 
     let groupUsers = this.groupInteractions.get(groupId);
     if (!groupUsers) {
@@ -129,7 +131,7 @@ export class RateLimiter {
 
   canRunAIRequest(userId?: number, groupId?: number): boolean {
     const now = Date.now();
-    const { userRpm, groupRpm, windowMs } = this.aiRequestLimitConfig;
+    const { userRpm, groupRpm, windowMs } = this.getAiRequestLimits(groupId);
 
     if (typeof userId === "number") {
       const userRequests = (this.userAiRequests.get(userId) ?? []).filter(
@@ -154,7 +156,7 @@ export class RateLimiter {
 
   recordAIRequest(userId?: number, groupId?: number): void {
     const now = Date.now();
-    const windowMs = this.aiRequestLimitConfig.windowMs;
+    const { windowMs } = this.getAiRequestLimits(groupId);
 
     if (typeof userId === "number") {
       const userRequests = (this.userAiRequests.get(userId) ?? []).filter(
@@ -175,9 +177,8 @@ export class RateLimiter {
 
   getInteractionCount(groupId: number): number {
     const now = Date.now();
-    const windowMs = this.dynamicDelayConfig.interactionWindowMs;
+    const { interactionWindowMs: windowMs } = this.getDynamicDelay(groupId);
 
-    // 优先使用队列长度作为互动人数计算
     if (this.getQueueLengthFn) {
       const queueLength = this.getQueueLengthFn(groupId);
       if (queueLength > 0) {
@@ -185,7 +186,6 @@ export class RateLimiter {
       }
     }
 
-    // 回退到 groupInteractions 统计
     const groupUsers = this.groupInteractions.get(groupId);
     if (!groupUsers) return 0;
 
@@ -200,12 +200,13 @@ export class RateLimiter {
   }
 
   calculateDelay(groupId: number): number {
-    if (!this.dynamicDelayConfig.enabled) return 0;
+    const dynamicDelay = this.getDynamicDelay(groupId);
+    if (!dynamicDelay.enabled) return 0;
 
     const interactionCount = this.getInteractionCount(groupId);
     if (interactionCount <= 1) return 0;
 
-    const { baseDelayMs, maxDelayMs } = this.dynamicDelayConfig;
+    const { baseDelayMs, maxDelayMs } = dynamicDelay;
     const delay = (interactionCount - 1) * baseDelayMs;
     return Math.min(delay, maxDelayMs);
   }
@@ -257,46 +258,21 @@ export class RateLimiter {
       }
     }
 
-    const aiWindowMs = this.aiRequestLimitConfig.windowMs;
-    for (const [userId, requests] of this.userAiRequests) {
-      const valid = requests.filter(
-        (timestamp) => now - timestamp < aiWindowMs,
-      );
-      if (valid.length === 0) {
-        this.userAiRequests.delete(userId);
-      } else {
-        this.userAiRequests.set(userId, valid);
-      }
-    }
-
-    for (const [groupId, requests] of this.groupAiRequests) {
-      const valid = requests.filter(
-        (timestamp) => now - timestamp < aiWindowMs,
-      );
-      if (valid.length === 0) {
-        this.groupAiRequests.delete(groupId);
-      } else {
-        this.groupAiRequests.set(groupId, valid);
-      }
-    }
-
-    if (this.dynamicDelayConfig.enabled) {
-      const windowMs = this.dynamicDelayConfig.interactionWindowMs;
-      for (const [groupId, groupUsers] of this.groupInteractions) {
-        let hasActiveUser = false;
-        for (const [userId, timestamps] of groupUsers) {
-          const valid = timestamps.filter((t) => now - t < windowMs);
-          if (valid.length === 0) {
-            groupUsers.delete(userId);
-          } else {
-            groupUsers.set(userId, valid);
-            hasActiveUser = true;
-          }
-        }
-        if (!hasActiveUser) {
-          this.groupInteractions.delete(groupId);
+    for (const [groupId, groupUsers] of this.groupInteractions) {
+      const windowMs = this.getDynamicDelay(groupId).interactionWindowMs;
+      let hasActiveUser = false;
+      for (const [userId, timestamps] of groupUsers) {
+        const valid = timestamps.filter((t) => now - t < windowMs);
+        if (valid.length === 0) {
+          groupUsers.delete(userId);
+        } else {
+          groupUsers.set(userId, valid);
+          hasActiveUser = true;
         }
       }
+      if (!hasActiveUser) {
+        this.groupInteractions.delete(groupId);
+      }
     }
   }
 
@@ -309,4 +285,4 @@ export class RateLimiter {
     this.userAiRequests.clear();
     this.groupAiRequests.clear();
   }
-}
+}

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.5.2",
+  "version": "2.7.0",
   "description": "AI 智能聊天插件",
   "main": "index.ts",
   "type": "module",

package/runtime/chat-runtime.ts

@@ -10,9 +10,21 @@ 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: () => Promise<ChatConfig>,
+  getConfig: (groupId?: number) => Promise<ChatConfig>,
 ): ChatRuntime {
   return {
     async requestInformation(
@@ -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,

package/types.ts

@@ -65,10 +65,8 @@ export interface PlannerConfig {
  */
 export interface EmojiConfig {
   enabled: boolean;
-  // 允许的表情包角色
   characters: string[];
-  // 使用AI选择表情包发送
-  useAISelection: boolean;
+  stickers: string[];
 }
 
 /**
@@ -219,6 +217,29 @@ export interface ChatConfig {
   retention: RetentionConfig;
 }
 
+/**
+ * 每群单独的开关覆盖
+ * 不填写的开关回退到全局默认；私聊会话不使用此覆盖
+ */
+export interface ChatGroupOverrides {
+  emoji?: { enabled?: boolean };
+  expression?: { enabled?: boolean };
+  retention?: { enabled?: boolean };
+  memory?: { enabled?: boolean };
+  topic?: { enabled?: boolean };
+  planner?: { enabled?: boolean };
+  audio?: { enabled?: boolean };
+  searxng?: { enabled?: boolean };
+  webReader?: { enabled?: boolean };
+  dynamicDelay?: { enabled?: boolean };
+  enableMarkdownScreenshot?: boolean;
+  enableMediaRecognition?: boolean;
+}
+
+export type ChatGroupsFile = {
+  groups: Record<string, ChatGroupOverrides>;
+};
+
 /**
  * 会话类型
  */
@@ -353,18 +374,6 @@ export interface ExpressionRecord {
   createdAt: number;
 }
 
-/**
- * 表情包注册记录
- */
-export interface EmojiRecord {
-  id?: number;
-  fileName: string;
-  description: string; // AI 生成的描述
-  emotion: string; // 情感标签
-  usageCount: number;
-  createdAt: number;
-}
-
 /**
  * 图片记录
  */
@@ -372,11 +381,8 @@ export interface ImageRecord {
   id?: number;
   hash: string; // 图片哈希
   url: string; // 原始 URL
-  type: "meme" | "image"; // 图片类型
+  type: "image";
   description: string; // AI 生成的简要描述
-  emotion?: string; // 情感标签（仅表情包）
-  character?: string; // 角色名称（仅表情包）
-  filePath?: string; // 本地文件路径（仅表情包）
   createdAt: number;
 }
 

package/utils/config.ts

@@ -0,0 +1,57 @@
+function isConfigObject(value: unknown): value is Record<string, any> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function mergeChatConfig<T extends Record<string, any>>(
+  defaults: T,
+  overrides: Record<string, any>,
+): T {
+  const result: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(defaults)) {
+    if (isConfigObject(value)) {
+      result[key] = mergeChatConfig(value, {});
+    } else if (Array.isArray(value)) {
+      result[key] = [...value];
+    } else {
+      result[key] = value;
+    }
+  }
+
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === undefined || value === null) continue;
+    if (isConfigObject(value)) {
+      const baseValue = isConfigObject(result[key]) ? result[key] : {};
+      result[key] = mergeChatConfig(baseValue, value);
+    } else if (Array.isArray(value)) {
+      result[key] = [...value];
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result as T;
+}
+
+export function normalizeIdList(input: unknown): number[] {
+  if (!Array.isArray(input)) return [];
+  return Array.from(
+    new Set(
+      input
+        .map((item) => Math.floor(Number(item)))
+        .filter((id) => Number.isFinite(id) && id > 0),
+    ),
+  );
+}
+
+export function normalizeMediaAnalysisBlacklist(
+  config: Record<string, any>,
+): number[] {
+  const current = config.mediaAnalysisBlacklistUsers;
+  const legacy = config.imageAnalysisBlacklistUsers;
+  const source =
+    legacy !== undefined && Array.isArray(current) && current.length === 0
+      ? legacy
+      : (current ?? legacy);
+  return normalizeIdList(source);
+}

package/utils/group-config.ts

@@ -0,0 +1,70 @@
+import type { ChatConfig, ChatGroupOverrides } from "../types";
+
+const OVERRIDABLE_SUB_OBJECTS = [
+  "emoji",
+  "expression",
+  "retention",
+  "memory",
+  "topic",
+  "planner",
+  "audio",
+  "searxng",
+  "webReader",
+  "dynamicDelay",
+] as const;
+
+const OVERRIDABLE_BOOLEAN_FIELDS = [
+  "enableMarkdownScreenshot",
+  "enableMediaRecognition",
+] as const;
+
+/**
+ * 把每个群的覆盖配置浅合并到全局配置上
+ * - 子对象（如 emoji）只覆盖其中存在的字段，未填字段继承全局
+ * - 顶层布尔字段（enableMarkdownScreenshot 等）若覆盖中存在则整体替换
+ * - 缺失字段、格式异常的覆盖会被静默忽略
+ */
+export function mergeGroupOverrides(
+  base: ChatConfig,
+  overrides: ChatGroupOverrides | undefined | null,
+): ChatConfig {
+  if (!overrides || typeof overrides !== "object") return base;
+  if (typeof base !== "object" || base === null) return base;
+
+  const result: ChatConfig = { ...base };
+  const resultMap = result as unknown as Record<string, unknown>;
+  const overridesMap = overrides as Record<string, unknown>;
+
+  for (const key of OVERRIDABLE_SUB_OBJECTS) {
+    const overrideSub = overridesMap[key];
+    if (overrideSub && typeof overrideSub === "object") {
+      const baseSub = (base as unknown as Record<string, unknown>)[key];
+      if (baseSub && typeof baseSub === "object") {
+        resultMap[key] = {
+          ...(baseSub as Record<string, unknown>),
+          ...(overrideSub as Record<string, unknown>),
+        };
+      }
+    }
+  }
+
+  for (const key of OVERRIDABLE_BOOLEAN_FIELDS) {
+    const value = overridesMap[key];
+    if (typeof value === "boolean") {
+      resultMap[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 从 sessionId（如 "group:123"）提取群号，个人会话返回 undefined
+ */
+export function extractGroupIdFromSession(sessionId: string): number | undefined {
+  if (!sessionId || typeof sessionId !== "string") return undefined;
+  if (!sessionId.startsWith("group:")) return undefined;
+  const raw = sessionId.slice("group:".length);
+  const parsed = parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}

package/utils/message.ts

@@ -308,12 +308,12 @@ async function getImageTagWithHashCache(
   ctx: HistoryFormatContext,
 ): Promise<string> {
   const exact = db.getImageByUrl?.(imageUrl);
-  if (exact) return `[${exact.type}:${exact.description}]`;
+  if (exact) return `[image:${exact.description}]`;
 
   const normalized = normalizeImageUrl(imageUrl);
   if (normalized && normalized !== imageUrl) {
     const hit = db.getImageByUrl?.(normalized);
-    if (hit) return `[${hit.type}:${hit.description}]`;
+    if (hit) return `[image:${hit.description}]`;
   }
 
   let hash = ctx.hashLookupCache.get(`hash:${imageUrl}`);
@@ -329,17 +329,14 @@ async function getImageTagWithHashCache(
       db.saveImage?.({
         hash: byHash.hash,
         url: normalized || imageUrl,
-        type: byHash.type,
+        type: "image",
         description: byHash.description,
-        emotion: byHash.emotion,
-        character: byHash.character,
-        filePath: byHash.filePath,
         createdAt: byHash.createdAt,
       });
     } catch {
       // best-effort URL caching for next call
     }
-    return `[${byHash.type}:${byHash.description}]`;
+    return `[image:${byHash.description}]`;
   }
 
   return "[image]";

package/utils/queue.ts

@@ -88,6 +88,11 @@ export class MessageQueueManager {
     const queue = this.pendingMessages.get(groupSessionId);
     return !!queue && queue.length > 0;
   }
+
+  dispose(): void {
+    this.pendingMessages.clear();
+    this.activeTargetMessages.clear();
+  }
 }
 
 /**