mioku-plugin-chat 2.5.0 → 2.6.0

package/configs/groups.ts

@@ -0,0 +1,5 @@
+import type { ChatGroupsFile } from "../types";
+
+export const DEFAULT_GROUPS_CONFIG: ChatGroupsFile = {
+  groups: {},
+};

package/context.ts

@@ -2,7 +2,7 @@ import type { MiokiContext } from "mioki";
 import type { AIInstance, AIService } from "mioku";
 import type { ChatConfig } from "./types";
 import type { ChatDatabase } from "./db";
-import type { HumanizeEngine } from "./humanize";
+import type { HumanizeEngine, ChatConfigProvider } from "./humanize";
 import type { SessionManager } from "./manage/session";
 import type { SkillSessionManager } from "./manage/skill-session";
 import type { RateLimiter } from "./manage/rate-limiter";
@@ -39,7 +39,9 @@ import type { ChatMessage } from "./types";
 export interface ChatPluginContext {
   // Core context
   ctx: MiokiContext;
-  config: ChatConfig;
+  defaultConfig: ChatConfig;
+  configProvider: ChatConfigProvider;
+  getConfig: (groupId?: number) => Promise<ChatConfig>;
   db: ChatDatabase;
   aiInstance: AIInstance;
   workAIInstance: AIInstance;
@@ -98,7 +100,7 @@ export interface ChatRuntimeState {
  * Closure state shared with the extracted message/poke handlers.
  */
 export interface ChatHandlerState {
-  getConfig: () => Promise<ChatConfig>;
+  getConfig: (groupId?: number) => Promise<ChatConfig>;
   matchMessageCommands?: (
     text: string,
   ) => Array<{ plugin: string; command: string }>;

package/core/chat-turn.ts

@@ -190,11 +190,12 @@ export async function processChat(
   pluginCtx: ChatPluginContext,
   runtimeState: ChatRuntimeState,
 ): Promise<void> {
-  const { ctx, config: cfg } = pluginCtx;
+  const { ctx } = pluginCtx;
   const isGroup = e.message_type === "group";
   const groupId: number | undefined = isGroup ? e.group_id : undefined;
   const userId: number = e.user_id || e.sender?.user_id;
   const selfId = e.self_id;
+  const cfg = await pluginCtx.getConfig(groupId);
 
   const personalSessionId = `personal:${userId}`;
   const groupSessionId = groupId ? `group:${groupId}` : personalSessionId;

package/core/media/image-analyzer.ts

@@ -27,6 +27,13 @@ export interface ImageAnalysisResult {
 
 export interface ImageAnalysisOptions {
   runAIRequest?<T>(request: () => Promise<T>): Promise<T | null>;
+  /**
+   * When non-empty, only memes whose detected character is in this list
+   * get downloaded into `data/chat/meme/<character>/<emotion>/`. Other
+   * characters still get a DB record but no local file.
+   * Empty (default) = no restriction; save for every detected character.
+   */
+  allowedCharacters?: string[];
 }
 
 function formatImageRecognitionLog(record: {
@@ -382,8 +389,29 @@ export async function processImage(
           ? analysis.characters
           : [analysis.character || "unknown"];
 
-      // 为每个角色创建文件夹并保存图片
-      const savePromises = characters.map(async (character) => {
+      // 应用 allowedCharacters 过滤：配置非空时只对列表内角色本地保存
+      const allowed = options?.allowedCharacters;
+      const hasRestriction = Array.isArray(allowed) && allowed.length > 0;
+      const normalizeName = (s: string) => String(s || "").trim().toLowerCase();
+      const allowedSet = hasRestriction
+        ? new Set((allowed as string[]).map(normalizeName))
+        : null;
+
+      const saveableCharacters = allowedSet
+        ? characters.filter((c) => allowedSet.has(normalizeName(c)))
+        : characters;
+
+      const skipped = characters.filter(
+        (c) => !saveableCharacters.includes(c),
+      );
+      if (skipped.length > 0) {
+        logger.info(
+          `[image-analyzer] Skipping local file save for characters outside allowedCharacters: ${skipped.join(", ")}`,
+        );
+      }
+
+      // 为每个允许保存的角色创建文件夹并保存图片
+      const savePromises = saveableCharacters.map(async (character) => {
         const memeDir = path.join(
           process.cwd(),
           "data",
@@ -429,7 +457,7 @@ export async function processImage(
     // 保存到数据库
     const record: ImageRecord = {
       hash,
-      url: imageUrl,
+      url: normalizeImageUrl(imageUrl) || imageUrl,
       type: analysis.type,
       description: analysis.description || "未知",
       emotion: analysis.emotion,
@@ -452,12 +480,64 @@ export async function processImage(
  * 命中数据库记录时返回 [meme:描述] 或 [image:描述]，否则返回 [image]。
  * 收集聊天历史时用它，之前没识别到的图片不会再次触发请求。
  */
-export function getImageTag(imageUrl: string, db: ChatDatabase): string {
-  const record = db.getImageByUrl(imageUrl);
+export async function getImageTag(imageUrl: string, db: ChatDatabase): Promise<string> {
+  const exact = db.getImageByUrl(imageUrl);
+  if (exact) {
+    return `[${exact.type}:${exact.description}]`;
+  }
 
-  if (record) {
-    return `[${record.type}:${record.description}]`;
+  const normalized = normalizeImageUrl(imageUrl);
+  if (normalized && normalized !== imageUrl) {
+    const normalizedHit = db.getImageByUrl(normalized);
+    if (normalizedHit) {
+      return `[${normalizedHit.type}:${normalizedHit.description}]`;
+    }
+  }
+
+  const hash = await calculateImageHash(imageUrl);
+  if (hash) {
+    const byHash = db.getImageByHash(hash);
+    if (byHash) {
+      try {
+        db.saveImage({
+          hash: byHash.hash,
+          url: normalized || imageUrl,
+          type: byHash.type,
+          description: byHash.description,
+          emotion: byHash.emotion,
+          character: byHash.character,
+          filePath: byHash.filePath,
+          createdAt: byHash.createdAt,
+        });
+      } catch {
+        // ignore — best-effort URL caching for next time
+      }
+      return `[${byHash.type}:${byHash.description}]`;
+    }
   }
 
   return "[image]";
 }
+
+/**
+ * Strip query string and hash so URLs from different NapCat code paths
+ * (live vs. get_group_msg_history) still match. QQ gchat.qpic.cn URLs
+ * include varying `?term=2`, `?spec=0`, signed tokens, etc.
+ */
+export function normalizeImageUrl(url: string): string {
+  if (!url || typeof url !== "string") return "";
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  try {
+    const u = new URL(trimmed);
+    return `${u.protocol}//${u.host}${u.pathname}`;
+  } catch {
+    const qIdx = trimmed.indexOf("?");
+    const hashIdx = trimmed.indexOf("#");
+    let cutAt = -1;
+    if (qIdx >= 0 && hashIdx >= 0) cutAt = Math.min(qIdx, hashIdx);
+    else if (qIdx >= 0) cutAt = qIdx;
+    else if (hashIdx >= 0) cutAt = hashIdx;
+    return cutAt >= 0 ? trimmed.slice(0, cutAt) : trimmed;
+  }
+}

package/core/tools/web.ts

@@ -287,7 +287,7 @@ export function createRecallMemoryTool(toolCtx: ToolContext): AITool {
         messages: toolCtx.db.getMessagesByUser(userId, toolCtx.sessionId, userHistoryLimit),
       }));
 
-      const retriever = new MemoryRetrieval(ai, toolCtx.config, toolCtx.db);
+      const retriever = new MemoryRetrieval(ai, () => toolCtx.config, toolCtx.db);
       const answer = await retriever.retrieveByQuestion({
         sessionId: toolCtx.sessionId,
         question,

package/db.ts

@@ -377,8 +377,11 @@ export async function initDatabase(): Promise<ChatDatabase> {
     `),
     // 图片记录
     insertImage: db.prepare(`
-      INSERT OR IGNORE INTO images (hash, url, type, description, emotion, character, file_path, created_at)
+      INSERT INTO images (hash, url, type, description, emotion, character, file_path, created_at)
       VALUES ($hash, $url, $type, $description, $emotion, $character, $filePath, $createdAt)
+      ON CONFLICT(hash) DO UPDATE SET
+        url = excluded.url,
+        created_at = excluded.created_at
     `),
     getImageByHash: db.prepare(`SELECT * FROM images WHERE hash = $hash`),
     getImageByUrl: db.prepare(`SELECT * FROM images WHERE url = $url`),

package/handlers/message.ts

@@ -33,13 +33,13 @@ export function createMessageHandler(
   const { getConfig, matchMessageCommands, runtimeState } = state;
 
   return async (e: any) => {
-    const cfg = await getConfig();
+    const isGroup = e.message_type === "group";
+    const groupId: number | undefined = isGroup ? e.group_id : undefined;
+    const cfg = await getConfig(groupId);
     if (!cfg.apiKey) return;
     if (!e?.message || !Array.isArray(e.message)) return;
 
     const text = ctx.text(e) || "";
-    const isGroup = e.message_type === "group";
-    const groupId: number | undefined = isGroup ? e.group_id : undefined;
     const userId: number = e.user_id || e.sender?.user_id;
 
     if (userId === e.self_id) return;
@@ -104,6 +104,10 @@ export function createMessageHandler(
                     groupId,
                     label: "image-analysis",
                   }),
+                allowedCharacters:
+                  cfg.emoji?.characters && cfg.emoji.characters.length > 0
+                    ? cfg.emoji.characters
+                    : undefined,
               }).catch((err) =>
                 ctx.logger.error(`[image-analyzer] Failed: ${err}`),
               );

package/handlers/poke.ts

@@ -13,9 +13,9 @@ export function createPokeHandler(
 
   return async (e: any) => {
     if (e.target_id !== e.self_id) return;
-    const cfg = await getConfig();
-    if (!cfg.apiKey) return;
     const groupId = e.group_id;
+    const cfg = groupId ? await getConfig(groupId) : await getConfig();
+    if (!cfg.apiKey) return;
     if (!groupId || !isGroupAllowed(groupId, cfg)) return;
 
     const lastPoke = pokeCooldowns.get(groupId) ?? 0;

package/humanize/emoji-agent.ts

@@ -5,6 +5,8 @@ import { logger } from "mioki";
 import * as fs from "fs/promises";
 import { existsSync, readdirSync } from "fs";
 import * as path from "path";
+import { extractGroupIdFromSession } from "../utils/group-config";
+import type { ChatConfigProvider } from "./index";
 
 export interface EmojiPickResult {
   success: boolean;
@@ -33,13 +35,13 @@ const AVAILABLE_EMOTIONS = [
 
 export class EmojiAgent {
   private ai: AIInstance;
-  private config: ChatConfig;
+  private getConfig: ChatConfigProvider;
   private db: ChatDatabase;
   private readonly memeBaseDir: string;
 
-  constructor(ai: AIInstance, config: ChatConfig, db: ChatDatabase) {
+  constructor(ai: AIInstance, configProvider: ChatConfigProvider, db: ChatDatabase) {
     this.ai = ai;
-    this.config = config;
+    this.getConfig = configProvider;
     this.db = db;
     this.memeBaseDir = path.join(process.cwd(), "data", "chat", "meme");
   }
@@ -77,6 +79,14 @@ export class EmojiAgent {
     aiResponseText: string,
     sessionId: string,
   ): Promise<EmojiPickResult> {
+    const cfg = this.getConfig(extractGroupIdFromSession(sessionId));
+    if (!cfg.emoji?.enabled) {
+      return {
+        success: false,
+        error: "emoji disabled",
+      };
+    }
+
     const intents = this.parseAllMemeIntents(aiResponseText);
     if (intents.length === 0) {
       return {
@@ -88,7 +98,7 @@ export class EmojiAgent {
     const chatHistory = this.db.getMessages(sessionId, 20);
 
     // 获取配置中的角色列表
-    const configChars = this.config.emoji?.characters || [];
+    const configChars = cfg.emoji?.characters || [];
 
     // 决定使用哪些角色
     let targetCharacters: string[];
@@ -112,6 +122,7 @@ export class EmojiAgent {
       targetCharacters,
       intent.emotion,
       chatHistory,
+      cfg,
     );
 
     if (!emojiResult.success || !emojiResult.emojiPath) {
@@ -135,6 +146,7 @@ export class EmojiAgent {
     characters: string[],
     emotion: string,
     chatHistory: ChatMessage[],
+    cfg: ChatConfig = this.getConfig(),
   ): Promise<{
     success: boolean;
     emojiPath?: string;
@@ -228,7 +240,7 @@ export class EmojiAgent {
       }
 
       // 检查是否使用 AI 选择
-      const useAI = this.config.emoji?.useAISelection;
+      const useAI = cfg.emoji?.useAISelection;
       if (!useAI) {
         // 不使用 AI，直接随机选择
         logger.info(`[emoji-agent] useAISelection=false, random pick`);
@@ -236,7 +248,7 @@ export class EmojiAgent {
       }
 
       // 使用 AI 选择最合适的表情包
-      return this.selectByAI(allEmojis, normalizedEmotion, chatHistory);
+      return this.selectByAI(allEmojis, normalizedEmotion, chatHistory, cfg);
     } catch (err) {
       logger.error(`[emoji-agent] Failed to pick emoji: ${err}`);
       return {
@@ -274,13 +286,14 @@ export class EmojiAgent {
     emojis: { path: string; character: string; file: string }[],
     emotion: string,
     chatHistory: ChatMessage[],
+    cfg: ChatConfig = this.getConfig(),
   ): Promise<{
     success: boolean;
     emojiPath?: string;
     description?: string;
     error?: string;
   }> {
-    const model = this.config.workingModel || this.config.model;
+    const model = cfg.workingModel || cfg.model;
 
     const systemPrompt = `You are an emoji/sticker selection assistant. Your task is to select the most appropriate emoji/sticker from a given list based on the chat context.
 

package/humanize/emotion-agent.ts

@@ -2,6 +2,8 @@ import type { AIInstance } from "mioku";
 import { logger } from "mioki";
 import { extractJsonObject } from "../utils/json";
 import type { ChatConfig, ChatMessage, TargetMessage } from "../types";
+import { extractGroupIdFromSession } from "../utils/group-config";
+import type { ChatConfigProvider } from "./index";
 
 export interface EmotionState {
   current: string;
@@ -18,41 +20,43 @@ export interface EmotionAnalysisInput {
 
 export class EmotionAgent {
   private readonly ai: AIInstance;
-  private readonly config: ChatConfig;
+  private readonly getConfig: ChatConfigProvider;
   private readonly states = new Map<string, EmotionState>();
 
-  constructor(ai: AIInstance, config: ChatConfig) {
+  constructor(ai: AIInstance, configProvider: ChatConfigProvider) {
     this.ai = ai;
-    this.config = config;
+    this.getConfig = configProvider;
   }
 
   getCurrent(sessionId: string): EmotionState {
     const existing = this.states.get(sessionId);
     if (existing) return existing;
 
-    const current = this.getDefaultEmotion();
+    const current = this.getDefaultEmotion(extractGroupIdFromSession(sessionId));
     const state = { current, updatedAt: 0 };
     this.states.set(sessionId, state);
     return state;
   }
 
-  getAvailableEmotions(): string[] {
-    const emotions = Object.keys(this.config.emotion?.emotions || {})
+  getAvailableEmotions(groupId?: number): string[] {
+    const cfg = this.getConfig(groupId);
+    const emotions = Object.keys(cfg.emotion?.emotions || {})
       .map((name) => name.trim().toLowerCase())
       .filter(Boolean);
     return Array.from(new Set(["default", ...emotions]));
   }
 
-  getReferenceExamples(emotion: string): string[] {
+  getReferenceExamples(emotion: string, groupId?: number): string[] {
+    const cfg = this.getConfig(groupId);
     const normalized = this.normalizeEmotionName(emotion);
-    const emotions = this.config.emotion?.emotions || {};
+    const emotions = cfg.emotion?.emotions || {};
     const examples = this.normalizeExamples(emotions[normalized]?.examples);
     if (examples.length > 0) return examples;
-    return this.normalizeExamples(emotions[this.getDefaultEmotion()]?.examples);
+    return this.normalizeExamples(emotions[this.getDefaultEmotion(groupId)]?.examples);
   }
 
-  setEmotion(sessionId: string, emotion: string): EmotionState {
-    const current = this.resolveEmotion(emotion);
+  setEmotion(sessionId: string, emotion: string, groupId?: number): EmotionState {
+    const current = this.resolveEmotion(emotion, groupId);
     const state = { current, updatedAt: Date.now() };
     this.states.set(sessionId, state);
     return state;
@@ -69,28 +73,30 @@ export class EmotionAgent {
   }
 
   async refreshIfNeeded(input: EmotionAnalysisInput): Promise<EmotionState> {
+    const groupId = extractGroupIdFromSession(input.sessionId);
+    const cfg = this.getConfig(groupId);
     const current = this.getCurrent(input.sessionId);
-    const intervalMs = Number(this.config.emotion?.updateIntervalMs ?? 60 * 60_000);
+    const intervalMs = Number(cfg.emotion?.updateIntervalMs ?? 60 * 60_000);
     const shouldRefresh =
       Boolean(input.force) || current.updatedAt <= 0 || Date.now() - current.updatedAt >= intervalMs;
 
     if (!shouldRefresh) return current;
 
     try {
-      const nextEmotion = await this.analyzeEmotion(input);
-      return this.setEmotion(input.sessionId, nextEmotion);
+      const nextEmotion = await this.analyzeEmotion(input, cfg);
+      return this.setEmotion(input.sessionId, nextEmotion, groupId);
     } catch (err) {
       logger.warn(`[emotion-agent] emotion analysis failed: ${err}`);
       if (current.updatedAt <= 0) {
-        return this.setEmotion(input.sessionId, this.getDefaultEmotion());
+        return this.setEmotion(input.sessionId, this.getDefaultEmotion(groupId), groupId);
       }
       return current;
     }
   }
 
-  private async analyzeEmotion(input: EmotionAnalysisInput): Promise<string> {
-    const availableEmotions = this.getAvailableEmotions();
-    const model = this.config.workingModel || this.config.model;
+  private async analyzeEmotion(input: EmotionAnalysisInput, cfg: ChatConfig = this.getConfig(extractGroupIdFromSession(input.sessionId))): Promise<string> {
+    const availableEmotions = this.getAvailableEmotions(extractGroupIdFromSession(input.sessionId));
+    const model = cfg.workingModel || cfg.model;
     const systemPrompt = `You are an emotion state selector for a chat bot.
 
 Task:
@@ -134,20 +140,21 @@ ${input.targetMessage.userName}: ${input.targetMessage.content}`;
 
     const content = response.content || "";
     const parsed = extractJsonObject(content);
-    if (parsed === undefined) return this.getDefaultEmotion();
-    return this.resolveEmotion(parsed?.emotion);
+    if (parsed === undefined) return this.getDefaultEmotion(extractGroupIdFromSession(input.sessionId));
+    return this.resolveEmotion(parsed?.emotion, extractGroupIdFromSession(input.sessionId));
   }
 
-  private resolveEmotion(emotion: unknown): string {
+  private resolveEmotion(emotion: unknown, groupId?: number): string {
     const normalized = this.normalizeEmotionName(emotion);
-    const available = this.getAvailableEmotions();
+    const available = this.getAvailableEmotions(groupId);
     if (available.includes(normalized)) return normalized;
-    return this.getDefaultEmotion();
+    return this.getDefaultEmotion(groupId);
   }
 
-  private getDefaultEmotion(): string {
-    const configured = this.normalizeEmotionName(this.config.emotion?.defaultEmotion);
-    const available = this.getAvailableEmotions();
+  private getDefaultEmotion(groupId?: number): string {
+    const cfg = this.getConfig(groupId);
+    const configured = this.normalizeEmotionName(cfg.emotion?.defaultEmotion);
+    const available = this.getAvailableEmotions(groupId);
     return available.includes(configured) ? configured : "default";
   }
 

package/humanize/expression.ts

@@ -2,23 +2,25 @@ import type { AIInstance } from "mioku";
 import { logger } from "mioki";
 import { extractJsonObject } from "../utils/json";
 import type { ChatDatabase } from "../db";
-import type { ChatConfig, ChatMessage } from "../types";
+import type { ChatMessage } from "../types";
+import type { ChatConfigProvider } from "./index";
 
 export class ExpressionLearner {
   private ai: AIInstance;
-  private config: ChatConfig;
+  private getConfig: ChatConfigProvider;
   private db: ChatDatabase;
   private pendingMessagesByUser: Map<number, ChatMessage[]> = new Map();
   private learningUsers: Set<number> = new Set();
 
-  constructor(ai: AIInstance, config: ChatConfig, db: ChatDatabase) {
+  constructor(ai: AIInstance, configProvider: ChatConfigProvider, db: ChatDatabase) {
     this.ai = ai;
-    this.config = config;
+    this.getConfig = configProvider;
     this.db = db;
   }
 
   async onMessage(message: ChatMessage): Promise<void> {
-    if (!this.config.expression?.enabled) return;
+    const cfg = this.getConfig(message.groupId);
+    if (!cfg.expression?.enabled) return;
     if (message.role !== "user") return;
     if (!message.content || message.content.length < 4) return;
     if (!message.userId) return;
@@ -27,13 +29,18 @@ export class ExpressionLearner {
     pending.push(message);
     this.pendingMessagesByUser.set(message.userId, pending);
 
-    await this.tryLearn(message.userId);
+    await this.tryLearn(message.userId, cfg);
   }
 
-  getExpressionContextForUser(userId: number, userName: string): string {
-    if (!this.config.expression?.enabled) return "";
+  getExpressionContextForUser(
+    userId: number,
+    userName: string,
+    groupId?: number,
+  ): string {
+    const cfg = this.getConfig(groupId);
+    if (!cfg.expression?.enabled) return "";
 
-    const sampleSize = this.config.expression?.sampleSize ?? 8;
+    const sampleSize = cfg.expression?.sampleSize ?? 8;
     const expressions = this.db.getExpressionsByUser(userId, sampleSize);
     if (expressions.length === 0) {
       logger.info(
@@ -55,12 +62,12 @@ export class ExpressionLearner {
     return context;
   }
 
-  private async tryLearn(userId: number): Promise<void> {
+  private async tryLearn(userId: number, cfg = this.getConfig()): Promise<void> {
     if (this.learningUsers.has(userId)) return;
 
     const threshold = Math.max(
       1,
-      this.config.expression?.learnAfterMessages ?? 100,
+      cfg.expression?.learnAfterMessages ?? 100,
     );
     const pending = this.pendingMessagesByUser.get(userId) ?? [];
     logger.debug(
@@ -76,7 +83,7 @@ export class ExpressionLearner {
 
         const batch = current.slice(0, threshold);
         this.pendingMessagesByUser.set(userId, current.slice(threshold));
-        await this.learnForUser(userId, batch);
+        await this.learnForUser(userId, batch, cfg);
       }
     } catch (err) {
       logger.warn(
@@ -90,10 +97,11 @@ export class ExpressionLearner {
   private async learnForUser(
     userId: number,
     messages: ChatMessage[],
+    cfg = this.getConfig(),
   ): Promise<void> {
     if (messages.length === 0) return;
 
-    const maxHabits = Math.max(1, this.config.expression?.sampleSize ?? 8);
+    const maxHabits = Math.max(1, cfg.expression?.sampleSize ?? 8);
     const userName = messages[messages.length - 1].userName || `User${userId}`;
     const msgTexts = messages.map((m) => m.content).join("\n");
 
@@ -128,7 +136,7 @@ Output strictly in JSON:
 
 If nothing reliable can be extracted, keep stable previous habits when possible. If still nothing, output {"expressions":[]}.`,
       messages: [],
-      model: this.config.workingModel || this.config.model,
+      model: cfg.workingModel || cfg.model,
       temperature: 0.2,
       max_tokens: 600,
     });
@@ -154,7 +162,7 @@ If nothing reliable can be extracted, keep stable previous habits when possible.
 
     const keepCount = Math.max(
       1,
-      this.config.retention?.expressionKeepPerUser ?? maxHabits,
+      cfg.retention?.expressionKeepPerUser ?? maxHabits,
     );
     const pruned = this.db.pruneExpressionsBySession(
       `user:${userId}`,
@@ -170,4 +178,4 @@ If nothing reliable can be extracted, keep stable previous habits when possible.
       `[ExpressionLearner] Updated ${normalized.length} habits for ${userName} (${userId}): ${JSON.stringify(normalized)}`,
     );
   }
-}
+}

package/humanize/index.ts

@@ -16,6 +16,8 @@ import { TopicTracker } from "./topic";
 import { ActionPlanner } from "./planner";
 import { ExpressionLearner } from "./expression";
 
+export type ChatConfigProvider = (groupId?: number) => ChatConfig;
+
 export class HumanizeEngine {
   readonly memoryRetrieval: MemoryRetrieval;
   readonly topicTracker: TopicTracker;
@@ -27,18 +29,18 @@ export class HumanizeEngine {
   constructor(
     mainAI: AIInstance,
     workAI: AIInstance,
-    config: ChatConfig,
     db: ChatDatabase,
+    configProvider: ChatConfigProvider,
   ) {
-    this.memoryRetrieval = new MemoryRetrieval(workAI, config, db);
-    this.topicTracker = new TopicTracker(workAI, config, db);
-    this.actionPlanner = new ActionPlanner(workAI, config);
-    this.emotionAgent = new EmotionAgent(workAI, config);
-    this.emojiAgent = new EmojiAgent(workAI, config, db);
-    this.expressionLearner = new ExpressionLearner(workAI, config, db);
+    this.memoryRetrieval = new MemoryRetrieval(workAI, configProvider, db);
+    this.topicTracker = new TopicTracker(workAI, configProvider, db);
+    this.actionPlanner = new ActionPlanner(workAI, configProvider);
+    this.emotionAgent = new EmotionAgent(workAI, configProvider);
+    this.emojiAgent = new EmojiAgent(workAI, configProvider, db);
+    this.expressionLearner = new ExpressionLearner(workAI, configProvider, db);
   }
 
   async init(): Promise<void> {
     // emojiAgent 不需要初始化，它直接从文件系统读取
   }
-}
+}

package/humanize/memory.ts

@@ -1,7 +1,9 @@
 import type { AIInstance } from "mioku";
 import { logger } from "mioki";
 import type { ChatDatabase } from "../db";
-import type { ChatConfig, ChatMessage } from "../types";
+import type { ChatMessage } from "../types";
+import { extractGroupIdFromSession } from "../utils/group-config";
+import type { ChatConfigProvider } from "./index";
 
 export interface MemoryUserHistoryChunk {
   userId: number;
@@ -18,17 +20,18 @@ export interface MemoryRecallInput {
 
 export class MemoryRetrieval {
   private ai: AIInstance;
-  private config: ChatConfig;
+  private getConfig: ChatConfigProvider;
   private db: ChatDatabase;
 
-  constructor(ai: AIInstance, config: ChatConfig, db: ChatDatabase) {
+  constructor(ai: AIInstance, configProvider: ChatConfigProvider, db: ChatDatabase) {
     this.ai = ai;
-    this.config = config;
+    this.getConfig = configProvider;
     this.db = db;
   }
 
   async retrieveByQuestion(input: MemoryRecallInput): Promise<string | null> {
-    if (!this.config.memory?.enabled) return null;
+    const cfg = this.getConfig(extractGroupIdFromSession(input.sessionId));
+    if (!cfg.memory?.enabled) return null;
 
     const question = String(input.question || "").trim();
     if (!question) return null;
@@ -68,7 +71,7 @@ Output requirements:
 - If useful evidence exists, summarize key facts with timestamps.
 - If no useful memory exists, output exactly: NO_USEFUL_MEMORY_FOUND`,
         messages: [],
-        model: this.config.workingModel || this.config.model,
+        model: cfg.workingModel || cfg.model,
         temperature: 0.2,
         max_tokens: 700,
       });
@@ -128,4 +131,4 @@ Output requirements:
   private formatTimestamp(timestamp: number): string {
     return new Date(timestamp).toLocaleString("zh-CN", { hour12: false });
   }
-}
+}