mioku-plugin-chat 2.5.2 → 2.7.0

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;
@@ -25,17 +27,16 @@ export class HumanizeEngine {
   readonly expressionLearner: ExpressionLearner;
 
   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);
+    this.expressionLearner = new ExpressionLearner(workAI, configProvider, db);
   }
 
   async init(): Promise<void> {

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) {

package/humanize/topic.ts

@@ -2,25 +2,28 @@ import type { AIInstance } from "mioku";
 import { logger } from "mioki";
 import { extractJsonObject } from "../utils/json";
 import type { ChatDatabase } from "../db";
-import type { ChatConfig } from "../types";
+import type { ChatMessage } from "../types";
+import { extractGroupIdFromSession } from "../utils/group-config";
+import type { ChatConfigProvider } from "./index";
 
 export class TopicTracker {
   private ai: AIInstance;
-  private config: ChatConfig;
+  private getConfig: ChatConfigProvider;
   private db: ChatDatabase;
   private lastAnalyzedWindowEnd: Map<string, number> = new Map();
 
-  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(sessionId: string): Promise<void> {
-    if (!this.config.topic?.enabled) return;
+    const cfg = this.getConfig(extractGroupIdFromSession(sessionId));
+    if (!cfg.topic?.enabled) return;
     if (!sessionId.startsWith("group:")) return;
 
-    const windowMs = this.getWindowMs();
+    const windowMs = this.getWindowMs(cfg);
     const completedWindowEnd = Math.floor(Date.now() / windowMs) * windowMs;
     if (completedWindowEnd <= 0) return;
 
@@ -32,18 +35,19 @@ export class TopicTracker {
     this.lastAnalyzedWindowEnd.set(sessionId, completedWindowEnd);
     const windowStartAt = completedWindowEnd - windowMs;
 
-    this.analyzeWindow(sessionId, windowStartAt, completedWindowEnd).catch(
+    this.analyzeWindow(sessionId, windowStartAt, completedWindowEnd, cfg).catch(
       (err) => logger.warn(`[TopicTracker] Analysis failed: ${err}`),
     );
   }
 
   getTopicContext(sessionId: string, historyStartAt?: number): string {
-    if (!this.config.topic?.enabled) return "";
+    const cfg = this.getConfig(extractGroupIdFromSession(sessionId));
+    if (!cfg.topic?.enabled) return "";
     if (!sessionId.startsWith("group:")) return "";
     if (!historyStartAt) return "";
 
-    const windowMs = this.getWindowMs();
-    const windowCount = this.getHistoryWindowCount();
+    const windowMs = this.getWindowMs(cfg);
+    const windowCount = this.getHistoryWindowCount(cfg);
     const firstWindowEnd = Math.floor(historyStartAt / windowMs) * windowMs;
     if (firstWindowEnd <= 0) return "";
 
@@ -79,6 +83,7 @@ export class TopicTracker {
     sessionId: string,
     windowStartAt: number,
     windowEndAt: number,
+    cfg = this.getConfig(extractGroupIdFromSession(sessionId)),
   ): Promise<void> {
     if (windowEndAt <= windowStartAt) return;
 
@@ -119,7 +124,7 @@ Output strictly in JSON format:
   "summary": "one concise abstract summary sentence"
 }`,
         messages: [],
-        model: this.config.workingModel || this.config.model,
+        model: cfg.workingModel || cfg.model,
         temperature: 0.2,
         max_tokens: 300,
       });
@@ -163,14 +168,14 @@ Output strictly in JSON format:
     }
   }
 
-  private getWindowMs(): number {
-    const hours = Number(this.config.topic?.windowHours);
+  private getWindowMs(cfg = this.getConfig()): number {
+    const hours = Number(cfg.topic?.windowHours);
     const safeHours = Number.isFinite(hours) && hours > 0 ? hours : 5;
     return Math.max(1, Math.floor(safeHours)) * 3600_000;
   }
 
-  private getHistoryWindowCount(): number {
-    const count = Number(this.config.topic?.historyWindowCount);
+  private getHistoryWindowCount(cfg = this.getConfig()): number {
+    const count = Number(cfg.topic?.historyWindowCount);
     if (!Number.isFinite(count) || count <= 0) return 3;
     return Math.max(1, Math.floor(count));
   }
@@ -202,3 +207,5 @@ Output strictly in JSON format:
     return `${year}-${month}-${day} ${hour}:${minute}`;
   }
 }
+
+export type { ChatMessage };