mioku-plugin-chat 2.5.2 → 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/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/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;

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 });
   }
-}
+}

package/humanize/planner.ts

@@ -1,24 +1,25 @@
 import type { AIInstance } from "mioku";
 import { logger } from "mioki";
 import type {
-  ChatConfig,
   ChatMessage,
   PlannerAction,
   PlannerResult,
 } from "../types";
+import { extractGroupIdFromSession } from "../utils/group-config";
+import type { ChatConfigProvider } from "./index";
 
 export class ActionPlanner {
   private ai: AIInstance;
-  private config: ChatConfig;
+  private getConfig: ChatConfigProvider;
   private actionHistory: Map<
     string,
     { action: PlannerAction; time: number }[]
   > = new Map();
   private pendingPlans: Map<string, Promise<PlannerResult>> = new Map();
 
-  constructor(ai: AIInstance, config: ChatConfig) {
+  constructor(ai: AIInstance, configProvider: ChatConfigProvider) {
     this.ai = ai;
-    this.config = config;
+    this.getConfig = configProvider;
   }
 
   async plan(
@@ -28,18 +29,18 @@ export class ActionPlanner {
     lastTriggerMessage: string,
     isIdleCheck: boolean = false,
   ): Promise<PlannerResult> {
-    if (!this.config.planner?.enabled) {
+    const cfg = this.getConfig(extractGroupIdFromSession(sessionId));
+    if (!cfg.planner?.enabled) {
       return { action: "reply", reason: "planner disabled" };
     }
 
-    // Guard: if a plan call is already in-flight for this session, wait for it
     const existing = this.pendingPlans.get(sessionId);
     if (existing) {
       logger.info(`[ActionPlanner] Session ${sessionId} has a plan already in-flight, waiting...`);
       return existing;
     }
 
-    const planPromise = this.doPlan(sessionId, botName, recentHistory, lastTriggerMessage, isIdleCheck);
+    const planPromise = this.doPlan(sessionId, botName, recentHistory, lastTriggerMessage, isIdleCheck, cfg);
     this.pendingPlans.set(sessionId, planPromise);
 
     try {
@@ -55,8 +56,9 @@ export class ActionPlanner {
     recentHistory: ChatMessage[],
     lastTriggerMessage: string,
     isIdleCheck: boolean,
+    cfg = this.getConfig(extractGroupIdFromSession(sessionId)),
   ): Promise<PlannerResult> {
-    if (!this.config.planner?.enabled) {
+    if (!cfg.planner?.enabled) {
       return { action: "reply", reason: "planner disabled" };
     }
 
@@ -81,7 +83,6 @@ export class ActionPlanner {
     let prompt: string;
 
     if (isIdleCheck) {
-      // 空闲检测模式：没有明确触发消息，观察群友聊天并决定是否要融入对话
       prompt = `It is ${timeStr}. Your name is ${botName}.
 
 Here is the recent chat content (from oldest to most recent):
@@ -120,7 +121,6 @@ OR for complete:
 
 DO NOT include any explanation, markdown formatting, or additional text. Only output the JSON.`;
     } else {
-      // 正常模式：由触发消息驱动的 planner
       prompt = `It is ${timeStr}. Your name is ${botName}.
 
 Here is the chat content:
@@ -169,12 +169,11 @@ DO NOT include any explanation, markdown formatting, or additional text. Only ou
       const content = await this.ai.generateText({
         prompt,
         messages: [],
-        model: this.config.workingModel || this.config.model,
+        model: cfg.workingModel || cfg.model,
         temperature: isIdleCheck ? 0.3 : 0.2,
         max_tokens: isIdleCheck ? 300 : 500,
       });
 
-      // 如果返回内容为空，使用默认值
       if (!content || !content.trim()) {
         logger.warn(
           `[ActionPlanner] Empty response from AI, using default reply`,
@@ -182,7 +181,6 @@ DO NOT include any explanation, markdown formatting, or additional text. Only ou
         return { action: "reply", reason: "empty response" };
       }
 
-      // 尝试提取 JSON 块
       let jsonStr = "";
       const jsonMatch = content.match(/\{[\s\S]*\}/);
       if (jsonMatch) {
@@ -196,14 +194,11 @@ DO NOT include any explanation, markdown formatting, or additional text. Only ou
         return { action: "reply", reason: "parse failed" };
       }
 
-      // 尝试解析 JSON
       let parsed: any;
       try {
         parsed = JSON.parse(jsonStr);
       } catch {
-        // 尝试修复常见的 JSON 错误
         try {
-          // 移除可能存在的尾随逗号
           jsonStr = jsonStr.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]");
           parsed = JSON.parse(jsonStr);
         } catch (e) {