mioku-plugin-chat 2.0.0

package/manage/rate-limiter.ts

@@ -0,0 +1,312 @@
+import type { AIRequestLimitConfig, DynamicDelayConfig } from "../types";
+
+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();
+  private groupAiRequests: Map<number, number[]> = new Map();
+
+  private readonly maxTriggersPerWindow: number;
+  private readonly windowMs: number;
+  private readonly dedupWindowMs: number;
+  private readonly groupCooldownMs: number;
+  private readonly cleanupTimer: ReturnType<typeof setInterval>;
+  private readonly dynamicDelayConfig: DynamicDelayConfig;
+  private readonly aiRequestLimitConfig: AIRequestLimitConfig;
+  // 外部注入的队列长度获取函数
+  private getQueueLengthFn: ((groupId: number) => number) | null = null;
+
+  /**
+   * 设置队列长度获取函数
+   */
+  setQueueLengthGetter(fn: (groupId: number) => number): void {
+    this.getQueueLengthFn = fn;
+  }
+
+  constructor(options?: {
+    maxTriggersPerWindow?: number;
+    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.cleanupTimer = setInterval(() => this.cleanup(), 300_000);
+  }
+
+  canProcess(
+    userId: number,
+    groupId: number | undefined,
+    content: string,
+  ): boolean {
+    const now = Date.now();
+
+    // 群组冷却检查
+    if (groupId) {
+      const lastResponse = this.groupLastResponse.get(groupId);
+      if (lastResponse && now - lastResponse < this.groupCooldownMs) {
+        return false;
+      }
+    }
+
+    // 用户频率检查
+    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,
+    );
+    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 now = Date.now();
+    const windowMs = this.dynamicDelayConfig.interactionWindowMs;
+
+    let groupUsers = this.groupInteractions.get(groupId);
+    if (!groupUsers) {
+      groupUsers = new Map();
+      this.groupInteractions.set(groupId, groupUsers);
+    }
+
+    let timestamps = groupUsers.get(userId) ?? [];
+    timestamps = timestamps.filter((t) => now - t < windowMs);
+    timestamps.push(now);
+    groupUsers.set(userId, timestamps);
+  }
+
+  canRunAIRequest(userId?: number, groupId?: number): boolean {
+    const now = Date.now();
+    const { userRpm, groupRpm, windowMs } = this.aiRequestLimitConfig;
+
+    if (typeof userId === "number") {
+      const userRequests = (this.userAiRequests.get(userId) ?? []).filter(
+        (timestamp) => now - timestamp < windowMs,
+      );
+      if (userRequests.length >= userRpm) {
+        return false;
+      }
+    }
+
+    if (typeof groupId === "number") {
+      const groupRequests = (this.groupAiRequests.get(groupId) ?? []).filter(
+        (timestamp) => now - timestamp < windowMs,
+      );
+      if (groupRequests.length >= groupRpm) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  recordAIRequest(userId?: number, groupId?: number): void {
+    const now = Date.now();
+    const windowMs = this.aiRequestLimitConfig.windowMs;
+
+    if (typeof userId === "number") {
+      const userRequests = (this.userAiRequests.get(userId) ?? []).filter(
+        (timestamp) => now - timestamp < windowMs,
+      );
+      userRequests.push(now);
+      this.userAiRequests.set(userId, userRequests);
+    }
+
+    if (typeof groupId === "number") {
+      const groupRequests = (this.groupAiRequests.get(groupId) ?? []).filter(
+        (timestamp) => now - timestamp < windowMs,
+      );
+      groupRequests.push(now);
+      this.groupAiRequests.set(groupId, groupRequests);
+    }
+  }
+
+  getInteractionCount(groupId: number): number {
+    const now = Date.now();
+    const windowMs = this.dynamicDelayConfig.interactionWindowMs;
+
+    // 优先使用队列长度作为互动人数计算
+    if (this.getQueueLengthFn) {
+      const queueLength = this.getQueueLengthFn(groupId);
+      if (queueLength > 0) {
+        return queueLength;
+      }
+    }
+
+    // 回退到 groupInteractions 统计
+    const groupUsers = this.groupInteractions.get(groupId);
+    if (!groupUsers) return 0;
+
+    let count = 0;
+    for (const [, timestamps] of groupUsers) {
+      const recentTimestamps = timestamps.filter((t) => now - t < windowMs);
+      if (recentTimestamps.length > 0) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  calculateDelay(groupId: number): number {
+    if (!this.dynamicDelayConfig.enabled) return 0;
+
+    const interactionCount = this.getInteractionCount(groupId);
+    if (interactionCount <= 1) return 0;
+
+    const { baseDelayMs, maxDelayMs } = this.dynamicDelayConfig;
+    const delay = (interactionCount - 1) * baseDelayMs;
+    return Math.min(delay, maxDelayMs);
+  }
+
+  getDelayInfo(groupId: number): {
+    delayMs: number;
+    interactionCount: number;
+    shouldDelay: boolean;
+  } {
+    const interactionCount = this.getInteractionCount(groupId);
+    const delayMs = this.calculateDelay(groupId);
+    return {
+      delayMs,
+      interactionCount,
+      shouldDelay: delayMs > 0,
+    };
+  }
+
+  clearGroupInteractions(groupId: number): void {
+    this.groupInteractions.delete(groupId);
+  }
+
+  cleanup(): void {
+    const now = Date.now();
+
+    for (const [userId, triggers] of this.userTriggers) {
+      const valid = triggers.filter((t) => now - t < this.windowMs);
+      if (valid.length === 0) {
+        this.userTriggers.delete(userId);
+      } else {
+        this.userTriggers.set(userId, valid);
+      }
+    }
+
+    for (const [userId, messages] of this.userMessages) {
+      const valid = messages.filter(
+        (m) => now - m.timestamp < this.dedupWindowMs,
+      );
+      if (valid.length === 0) {
+        this.userMessages.delete(userId);
+      } else {
+        this.userMessages.set(userId, valid);
+      }
+    }
+
+    for (const [groupId, timestamp] of this.groupLastResponse) {
+      if (now - timestamp > this.groupCooldownMs * 10) {
+        this.groupLastResponse.delete(groupId);
+      }
+    }
+
+    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);
+        }
+      }
+    }
+  }
+
+  dispose(): void {
+    clearInterval(this.cleanupTimer);
+    this.userTriggers.clear();
+    this.userMessages.clear();
+    this.groupLastResponse.clear();
+    this.groupInteractions.clear();
+    this.userAiRequests.clear();
+    this.groupAiRequests.clear();
+  }
+}

package/manage/session.ts

@@ -0,0 +1,96 @@
+import type { SessionMeta, SessionType } from "../types";
+import type { ChatDatabase } from "../db";
+
+/**
+ * LRU 会话管理器
+ */
+export class SessionManager {
+  private cache: Map<string, SessionMeta> = new Map();
+  private readonly maxSize: number;
+  private db: ChatDatabase;
+
+  constructor(db: ChatDatabase, maxSize: number) {
+    this.db = db;
+    this.maxSize = maxSize;
+  }
+
+  /**
+   * 获取或创建会话
+   */
+  getOrCreate(id: string, type: SessionType, targetId: number): SessionMeta {
+    // 先查缓存
+    if (this.cache.has(id)) {
+      return this.touch(id);
+    }
+
+    // 查数据库
+    const existing = this.db.getSession(id);
+    if (existing) {
+      this.addToCache(id, existing);
+      return existing;
+    }
+
+    // 创建新会话
+    const now = Date.now();
+    const session: SessionMeta = {
+      id,
+      type,
+      targetId,
+      createdAt: now,
+      updatedAt: now,
+      compressedContext: null,
+    };
+    this.db.saveSession(session);
+    this.addToCache(id, session);
+    return session;
+  }
+
+  /**
+   * 获取会话（不创建）
+   */
+  get(id: string): SessionMeta | null {
+    if (this.cache.has(id)) {
+      return this.touch(id);
+    }
+    const existing = this.db.getSession(id);
+    if (existing) {
+      this.addToCache(id, existing);
+      return existing;
+    }
+    return null;
+  }
+
+  /**
+   * 更新访问时间并移至最近
+   */
+  touch(id: string): SessionMeta {
+    const session = this.cache.get(id);
+    if (!session) {
+      throw new Error(`Session ${id} not found in cache`);
+    }
+    // 删除再插入，移到 Map 末尾（最近使用）
+    this.cache.delete(id);
+    session.updatedAt = Date.now();
+    this.cache.set(id, session);
+    this.db.saveSession(session);
+    return session;
+  }
+
+  /**
+   * 重置 bot 消息
+   */
+  resetBotMessages(id: string): void {
+    this.db.deleteBotMessages(id);
+  }
+
+  private addToCache(id: string, session: SessionMeta): void {
+    // LRU 淘汰
+    if (this.cache.size >= this.maxSize) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest !== undefined) {
+        this.cache.delete(oldest);
+      }
+    }
+    this.cache.set(id, session);
+  }
+}

package/manage/skill-session.ts

@@ -0,0 +1,173 @@
+import type { AITool } from "mioku";
+import type { SkillSession } from "../types";
+import type { FeatureName } from "../core/feature-prompts";
+
+/**
+ * 技能会话管理器
+ * 管理每个 session 的技能加载和工具注册
+ */
+export class SkillSessionManager {
+  private sessions: Map<string, Map<string, SkillSession>> = new Map();
+  private features: Map<string, Map<string, FeatureSession>> = new Map();
+  private EXPIRY_MS = 60 * 60 * 1000; // 1 hour
+
+  getTools(sessionId: string): Map<string, AITool> {
+    const result = new Map<string, AITool>();
+    const sessionSkills = this.sessions.get(sessionId);
+    if (!sessionSkills) return result;
+
+    const now = Date.now();
+    for (const [skillName, session] of sessionSkills) {
+      if (now > session.expiresAt) {
+        sessionSkills.delete(skillName);
+        continue;
+      }
+      for (const [toolName, tool] of session.tools) {
+        result.set(toolName, tool);
+      }
+    }
+    return result;
+  }
+
+  loadSkill(
+    sessionId: string,
+    skillName: string,
+    tools: AITool[],
+  ): SkillSession {
+    let sessionSkills = this.sessions.get(sessionId);
+    if (!sessionSkills) {
+      sessionSkills = new Map();
+      this.sessions.set(sessionId, sessionSkills);
+    }
+
+    const now = Date.now();
+    const toolMap = new Map<string, AITool>();
+    for (const tool of tools) {
+      toolMap.set(`${skillName}.${tool.name}`, tool);
+    }
+
+    const session: SkillSession = {
+      skillName,
+      tools: toolMap,
+      loadedAt: now,
+      expiresAt: now + this.EXPIRY_MS,
+    };
+    sessionSkills.set(skillName, session);
+    return session;
+  }
+
+  unloadSkill(sessionId: string, skillName: string): boolean {
+    const sessionSkills = this.sessions.get(sessionId);
+    if (!sessionSkills) return false;
+    return sessionSkills.delete(skillName);
+  }
+
+  getActiveSkillsInfo(
+    sessionId: string,
+    isSkillVisible?: (skillName: string) => boolean,
+  ): string {
+    const sessionSkills = this.sessions.get(sessionId);
+    if (!sessionSkills || sessionSkills.size === 0) return "";
+
+    const now = Date.now();
+    const lines: string[] = [];
+
+    for (const [skillName, session] of sessionSkills) {
+      if (now > session.expiresAt) {
+        sessionSkills.delete(skillName);
+        continue;
+      }
+      if (isSkillVisible && !isSkillVisible(skillName)) {
+        continue;
+      }
+      const remainingMin = Math.ceil((session.expiresAt - now) / 60000);
+      const toolNames = [...session.tools.keys()].join(", ");
+      lines.push(
+        `- ${skillName} (expires in ${remainingMin}min): ${toolNames}`,
+      );
+    }
+
+    if (lines.length === 0) return "";
+    return `## Loaded External Skills\n${lines.join("\n")}`;
+  }
+
+  cleanup(): void {
+    const now = Date.now();
+    for (const [sessionId, sessionSkills] of this.sessions) {
+      for (const [skillName, session] of sessionSkills) {
+        if (now > session.expiresAt) {
+          sessionSkills.delete(skillName);
+        }
+      }
+      if (sessionSkills.size === 0) {
+        this.sessions.delete(sessionId);
+      }
+    }
+    for (const [sessionId, sessionFeatures] of this.features) {
+      for (const [featureName, feature] of sessionFeatures) {
+        if (now > feature.expiresAt) {
+          sessionFeatures.delete(featureName);
+        }
+      }
+      if (sessionFeatures.size === 0) {
+        this.features.delete(sessionId);
+      }
+    }
+  }
+
+  loadFeature(
+    sessionId: string,
+    featureName: FeatureName,
+    ttlMs: number,
+  ): void {
+    let sessionFeatures = this.features.get(sessionId);
+    if (!sessionFeatures) {
+      sessionFeatures = new Map();
+      this.features.set(sessionId, sessionFeatures);
+    }
+
+    const now = Date.now();
+    sessionFeatures.set(featureName, {
+      featureName,
+      loadedAt: now,
+      expiresAt: now + ttlMs,
+    });
+  }
+
+  getActiveFeatureNames(sessionId: string): FeatureName[] {
+    const sessionFeatures = this.features.get(sessionId);
+    if (!sessionFeatures) return [];
+
+    const now = Date.now();
+    const result: FeatureName[] = [];
+    for (const [featureName, feature] of sessionFeatures) {
+      if (now > feature.expiresAt) {
+        sessionFeatures.delete(featureName);
+        continue;
+      }
+      result.push(feature.featureName);
+    }
+    return result;
+  }
+
+  getActiveFeatureTools(sessionId: string): FeatureName[] {
+    // Only return features that have tools (web_search, web_read_page, recall_memory)
+    const all = this.getActiveFeatureNames(sessionId);
+    return all.filter((name) => {
+      switch (name) {
+        case "web_search":
+        case "web_read_page":
+        case "recall_memory":
+          return true;
+        default:
+          return false;
+      }
+    });
+  }
+}
+
+interface FeatureSession {
+  featureName: FeatureName;
+  loadedAt: number;
+  expiresAt: number;
+}

package/manage/types.ts

@@ -0,0 +1,138 @@
+import type { MiokiContext } from "mioki";
+import type { AIInstance, AIService } from "mioku";
+import type { SkillPermissionRole } from "mioku";
+import type { ChatRuntimePromptInjection } from "mioku";
+import type { ChatConfig, ChatMessage, TargetMessage, ToolContext, ChatResult } from "../types";
+import type { ChatDatabase } from "../db";
+import type { HumanizeEngine } from "../humanize";
+import type { EmojiAgent } from "../humanize";
+import type { SkillSessionManager } from "./skill-session";
+import type { GroupStructuredHistoryManager, StructuredUserInput } from "./group-structured-history";
+import type { SendAIResponseOptions } from "../core/base";
+import type { GroupInfoResult, HumanizeContextsResult } from "../core/base";
+
+export type { SendAIResponseOptions, GroupInfoResult, HumanizeContextsResult };
+
+export type HistoryMediaOptions = {
+  ai?: AIInstance;
+  workingModel?: string;
+  multimodalWorkingModel?: string;
+};
+
+export type RunRateLimitGuard = <T>(
+  request: () => Promise<T>,
+  opts?: { userId?: number; groupId?: number; label?: string },
+) => Promise<T | null>;
+
+export type GetGroupHistoryMessages = (
+  groupId: number,
+  groupSessionId: string,
+  ctx: MiokiContext,
+  historyCount: number,
+  db: ChatDatabase,
+  selfId: number,
+  mediaOptions?: HistoryMediaOptions,
+) => Promise<{ history: ChatMessage[] }>;
+
+export type GetGroupInfoData = (
+  ctx: MiokiContext,
+  groupId: number,
+  selfId: number,
+  fallbackGroupName?: string,
+) => Promise<GroupInfoResult>;
+
+export type GetHumanizeContexts = (
+  humanize: HumanizeEngine,
+  groupSessionId: string,
+  userName: string,
+  history: ChatMessage[],
+  triggerUserId?: number,
+) => Promise<HumanizeContextsResult>;
+
+export type SendAIResponse = (options: SendAIResponseOptions, selfId: number) => Promise<void>;
+
+export type SaveBotMessages = (
+  groupId: number,
+  groupSessionId: string,
+  messages: string[],
+  timestamp: number,
+  config: ChatConfig,
+  db: ChatDatabase,
+  ctx: MiokiContext,
+  selfId: number,
+) => void;
+
+export type SendEmoji = (ctx: MiokiContext, groupId: number, emojiPath: string | null | undefined, selfId: number) => Promise<void>;
+
+export type SendMessage = (
+  ctx: MiokiContext,
+  groupId: number | undefined,
+  userId: number,
+  text: string,
+  config: ChatConfig,
+  selfId: number,
+) => Promise<void>;
+
+export type BuildToolContext = (options: {
+  ctx: MiokiContext;
+  event: any;
+  selfId: number;
+  groupSessionId: string;
+  groupId?: number;
+  userId: number;
+  config: ChatConfig;
+  aiService: AIService;
+  db: ChatDatabase;
+  botRole: "owner" | "admin" | "member";
+  pendingImageUrls?: string[];
+  humanize: HumanizeEngine;
+  targetMessage: TargetMessage;
+}) => ToolContext;
+
+export type BuildStructuredUserInput = (event: any, content: string, fallbackTimestamp?: number) => StructuredUserInput;
+
+export type BuildStructuredUserInputFromTarget = (targetMessage: TargetMessage) => StructuredUserInput;
+
+export type PromptCtxForRunChat = {
+  config: ChatConfig;
+  groupName?: string;
+  memberCount?: number;
+  botNickname: string;
+  botRole: "owner" | "admin" | "member";
+  triggerSkillRole?: SkillPermissionRole;
+  aiService: AIService;
+  isGroup: boolean;
+  memoryContext?: string;
+  topicContext?: string;
+  expressionContext?: string;
+  activeSkillsInfo?: string;
+  plannerThoughts?: string;
+  replyContext?: {
+    type: "reply" | "comment" | "idle" | "review" | "poked";
+    targetUser?: string;
+    targetMessage?: string;
+  };
+  reviewMessages?: {
+    contents: string[];
+    userNames: string[];
+    messageIds: number[];
+  };
+  promptInjections?: ChatRuntimePromptInjection[];
+  emojiAgent?: EmojiAgent;
+};
+
+export type RunChat = (
+  ai: AIInstance,
+  toolCtx: ToolContext,
+  history: ChatMessage[],
+  targetMessage: TargetMessage,
+  promptCtx: PromptCtxForRunChat,
+  humanize: HumanizeEngine,
+  skillManager: SkillSessionManager,
+  structuredHistory?: {
+    manager: GroupStructuredHistoryManager;
+    ttlMs: number;
+    currentUserInputs: StructuredUserInput[];
+  },
+  runtimeOptions?: { extraTools?: any[] },
+) => Promise<ChatResult>;