mioku-plugin-chat 2.3.1 → 2.4.0

package/manage/cooldown.ts

@@ -5,6 +5,7 @@ import type { ChatDatabase } from "../db";
 import type { HumanizeEngine } from "../humanize";
 import type { SkillSessionManager } from "./skill-session";
 import type { GroupStructuredHistoryManager } from "./group-structured-history";
+import { buildStructuredUserInputFromEvent } from "./group-structured-history";
 import type { SessionManager } from "./session";
 import type { RateLimiter } from "./rate-limiter";
 import type { IdleCheckManager } from "./idle-check";
@@ -21,6 +22,7 @@ import type {
   BuildToolContext,
   BuildStructuredUserInput,
 } from "./types";
+import type { ChatPluginContext } from "../context";
 import { getBotRole } from "../utils";
 
 interface CooldownMessage {
@@ -38,33 +40,56 @@ export class CooldownManager {
   private groupCooldownMessages = new Map<string, CooldownMessage[]>();
   private cooldownTimeoutIds = new Map<string, NodeJS.Timeout>();
 
-  constructor(
-    private ctx: MiokiContext,
-    private cfg: ChatConfig,
-    private db: ChatDatabase,
-    private humanize: HumanizeEngine,
-    private aiInstance: AIInstance,
-    private aiService: import("mioku").AIService,
-    private skillManager: SkillSessionManager,
-    private groupStructuredHistory: GroupStructuredHistoryManager,
-    private sessionManager: SessionManager,
-    private rateLimiter: RateLimiter,
-    private idleCheckManager: IdleCheckManager,
-    private runWithRateLimitGuard: RunRateLimitGuard,
-    private buildHistoryMediaOptions: (
-      ai: AIInstance,
-      cfg: ChatConfig,
-    ) => HistoryMediaOptions,
-    private getGroupHistoryMessages: GetGroupHistoryMessages,
-    private getGroupInfoData: GetGroupInfoData,
-    private getHumanizeContexts: GetHumanizeContexts,
-    private sendAIResponse: SendAIResponse,
-    private saveBotMessages: SaveBotMessages,
-    private sendEmoji: SendEmoji,
-    private runChat: RunChat,
-    private buildToolContext: BuildToolContext,
-    private buildStructuredUserInputFromEvent: BuildStructuredUserInput,
-  ) {}
+  private ctx: MiokiContext;
+  private cfg: ChatConfig;
+  private db: ChatDatabase;
+  private humanize: HumanizeEngine;
+  private aiInstance: AIInstance;
+  private aiService: import("mioku").AIService;
+  private skillManager: SkillSessionManager;
+  private groupStructuredHistory: GroupStructuredHistoryManager;
+  private sessionManager: SessionManager;
+  private rateLimiter: RateLimiter;
+  private idleCheckManager: IdleCheckManager;
+  private runWithRateLimitGuard: RunRateLimitGuard;
+  private buildHistoryMediaOptions: (
+    ai: AIInstance,
+    cfg: ChatConfig,
+  ) => HistoryMediaOptions;
+  private getGroupHistoryMessages: GetGroupHistoryMessages;
+  private getGroupInfoData: GetGroupInfoData;
+  private getHumanizeContexts: GetHumanizeContexts;
+  private sendAIResponse: SendAIResponse;
+  private saveBotMessages: SaveBotMessages;
+  private sendEmoji: SendEmoji;
+  private runChat: RunChat;
+  private buildToolContext: BuildToolContext;
+  private buildStructuredUserInputFromEvent: BuildStructuredUserInput;
+
+  constructor(pluginCtx: ChatPluginContext) {
+    this.ctx = pluginCtx.ctx;
+    this.cfg = pluginCtx.config;
+    this.db = pluginCtx.db;
+    this.humanize = pluginCtx.humanize;
+    this.aiInstance = pluginCtx.aiInstance;
+    this.aiService = pluginCtx.aiService;
+    this.skillManager = pluginCtx.skillManager;
+    this.groupStructuredHistory = pluginCtx.groupStructuredHistory;
+    this.sessionManager = pluginCtx.sessionManager;
+    this.rateLimiter = pluginCtx.rateLimiter;
+    this.idleCheckManager = pluginCtx.idleCheckManager;
+    this.runWithRateLimitGuard = pluginCtx.runWithRateLimitGuard;
+    this.buildHistoryMediaOptions = pluginCtx.buildHistoryMediaOptions;
+    this.getGroupHistoryMessages = pluginCtx.getGroupHistoryMessages;
+    this.getGroupInfoData = pluginCtx.getGroupInfoData;
+    this.getHumanizeContexts = pluginCtx.getHumanizeContexts;
+    this.sendAIResponse = pluginCtx.sendAIResponse;
+    this.saveBotMessages = pluginCtx.saveBotMessages;
+    this.sendEmoji = pluginCtx.sendEmoji;
+    this.runChat = pluginCtx.runChat;
+    this.buildToolContext = pluginCtx.buildToolContext;
+    this.buildStructuredUserInputFromEvent = buildStructuredUserInputFromEvent;
+  }
 
   startCooldownTimer(
     groupSessionId: string,

package/manage/group-structured-history.ts

@@ -1,5 +1,6 @@
 import type { ChatCompletionMessageParam } from "openai/resources/chat/completions";
 import type { MultimodalContentItem } from "mioku";
+import type { TargetMessage } from "../types";
 
 export interface StructuredUserInput {
   userName: string;
@@ -94,6 +95,40 @@ export function buildStructuredUserMessages(
   }));
 }
 
+export function buildStructuredUserInputFromEvent(
+  event: any,
+  content: string,
+  fallbackTimestamp: number = Date.now(),
+): StructuredUserInput {
+  return {
+    userName:
+      event?.sender?.card ||
+      event?.sender?.nickname ||
+      String(event?.user_id || event?.sender?.user_id || 0),
+    userId: event?.user_id || event?.sender?.user_id || 0,
+    userRole: event?.sender?.role || "member",
+    userTitle: event?.sender?.title,
+    content,
+    messageId: event?.message_id,
+    timestamp:
+      typeof event?.time === "number" ? event.time * 1000 : fallbackTimestamp,
+  };
+}
+
+export function buildStructuredUserInputFromTarget(
+  targetMessage: TargetMessage,
+): StructuredUserInput {
+  return {
+    userName: targetMessage.userName,
+    userId: targetMessage.userId,
+    userRole: targetMessage.userRole,
+    userTitle: targetMessage.userTitle,
+    content: targetMessage.content,
+    messageId: targetMessage.messageId,
+    timestamp: targetMessage.timestamp,
+  };
+}
+
 export function attachImagesToCurrentUserMessages(
   messages: ChatCompletionMessageParam[],
   pendingImageUrls?: string[],

package/manage/idle-check.ts

@@ -16,6 +16,7 @@ import type {
   RunChat,
   BuildToolContext,
 } from "./types";
+import type { ChatPluginContext } from "../context";
 import { getBotRole, isGroupAllowed } from "../utils";
 
 export class IdleCheckManager {
@@ -28,26 +29,45 @@ export class IdleCheckManager {
   private groupBotsMapping = new Map<string, Set<number>>();
   private intervalHandle: NodeJS.Timeout | null = null;
 
-  constructor(
-    private ctx: MiokiContext,
-    private cfg: ChatConfig,
-    private db: ChatDatabase,
-    private humanize: HumanizeEngine,
-    private aiInstance: AIInstance,
-    private aiService: import("mioku").AIService,
-    private skillManager: SkillSessionManager,
-    private groupStructuredHistory: GroupStructuredHistoryManager,
-    private sessionManager: SessionManager,
-    private runWithRateLimitGuard: RunRateLimitGuard,
-    private buildHistoryMediaOptions: (ai: AIInstance, cfg: ChatConfig) => HistoryMediaOptions,
-    private getGroupHistoryMessages: GetGroupHistoryMessages,
-    private getGroupInfoData: GetGroupInfoData,
-    private sendAIResponse: SendAIResponse,
-    private saveBotMessages: SaveBotMessages,
-    private runChat: RunChat,
-    private buildToolContext: BuildToolContext,
-    private startCooldownTimer: (groupSessionId: string, groupId: number, selfId: number) => void,
-  ) {}
+  private ctx: MiokiContext;
+  private cfg: ChatConfig;
+  private db: ChatDatabase;
+  private humanize: HumanizeEngine;
+  private aiInstance: AIInstance;
+  private aiService: import("mioku").AIService;
+  private skillManager: SkillSessionManager;
+  private groupStructuredHistory: GroupStructuredHistoryManager;
+  private sessionManager: SessionManager;
+  private runWithRateLimitGuard: RunRateLimitGuard;
+  private buildHistoryMediaOptions: (ai: AIInstance, cfg: ChatConfig) => HistoryMediaOptions;
+  private getGroupHistoryMessages: GetGroupHistoryMessages;
+  private getGroupInfoData: GetGroupInfoData;
+  private sendAIResponse: SendAIResponse;
+  private saveBotMessages: SaveBotMessages;
+  private runChat: RunChat;
+  private buildToolContext: BuildToolContext;
+  private startCooldownTimer: (groupSessionId: string, groupId: number, selfId: number) => void;
+
+  constructor(pluginCtx: ChatPluginContext) {
+    this.ctx = pluginCtx.ctx;
+    this.cfg = pluginCtx.config;
+    this.db = pluginCtx.db;
+    this.humanize = pluginCtx.humanize;
+    this.aiInstance = pluginCtx.aiInstance;
+    this.aiService = pluginCtx.aiService;
+    this.skillManager = pluginCtx.skillManager;
+    this.groupStructuredHistory = pluginCtx.groupStructuredHistory;
+    this.sessionManager = pluginCtx.sessionManager;
+    this.runWithRateLimitGuard = pluginCtx.runWithRateLimitGuard;
+    this.buildHistoryMediaOptions = pluginCtx.buildHistoryMediaOptions;
+    this.getGroupHistoryMessages = pluginCtx.getGroupHistoryMessages;
+    this.getGroupInfoData = pluginCtx.getGroupInfoData;
+    this.sendAIResponse = pluginCtx.sendAIResponse;
+    this.saveBotMessages = pluginCtx.saveBotMessages;
+    this.runChat = pluginCtx.runChat;
+    this.buildToolContext = pluginCtx.buildToolContext;
+    this.startCooldownTimer = pluginCtx.startCooldownTimer;
+  }
 
   recordActivity(groupSessionId: string): void {
     this.groupLastActivityTime.set(groupSessionId, Date.now());

package/manage/queue-processor.ts

@@ -5,6 +5,7 @@ import type { ChatDatabase } from "../db";
 import type { HumanizeEngine } from "../humanize";
 import type { SkillSessionManager } from "./skill-session";
 import type { GroupStructuredHistoryManager, StructuredUserInput } from "./group-structured-history";
+import { buildStructuredUserInputFromEvent } from "./group-structured-history";
 import type { SessionManager } from "./session";
 import type { RateLimiter } from "./rate-limiter";
 import type { MessageQueueManager } from "../utils/queue";
@@ -21,6 +22,7 @@ import type {
   BuildToolContext,
   BuildStructuredUserInput,
 } from "./types";
+import type { ChatPluginContext } from "../context";
 import { extractContent, getBotRole } from "../utils";
 
 interface DynamicDelayQueueData {
@@ -32,31 +34,55 @@ interface DynamicDelayQueueData {
 export class QueueProcessor {
   private dynamicDelayQueues = new Map<string, DynamicDelayQueueData>();
 
-  constructor(
-    private ctx: MiokiContext,
-    private cfg: ChatConfig,
-    private db: ChatDatabase,
-    private humanize: HumanizeEngine,
-    private aiInstance: AIInstance,
-    private aiService: import("mioku").AIService,
-    private skillManager: SkillSessionManager,
-    private groupStructuredHistory: GroupStructuredHistoryManager,
-    private sessionManager: SessionManager,
-    private rateLimiter: RateLimiter,
-    private queueManager: MessageQueueManager,
-    private runWithRateLimitGuard: RunRateLimitGuard,
-    private buildHistoryMediaOptions: (ai: AIInstance, cfg: ChatConfig) => HistoryMediaOptions,
-    private getGroupHistoryMessages: GetGroupHistoryMessages,
-    private getGroupInfoData: GetGroupInfoData,
-    private getHumanizeContexts: GetHumanizeContexts,
-    private sendAIResponse: SendAIResponse,
-    private saveBotMessages: SaveBotMessages,
-    private sendEmoji: SendEmoji,
-    private runChat: RunChat,
-    private buildToolContext: BuildToolContext,
-    private buildStructuredUserInputFromEvent: BuildStructuredUserInput,
-    private startCooldownTimer: (groupSessionId: string, groupId: number, selfId: number) => void,
-  ) {}
+  private ctx: MiokiContext;
+  private cfg: ChatConfig;
+  private db: ChatDatabase;
+  private humanize: HumanizeEngine;
+  private aiInstance: AIInstance;
+  private aiService: import("mioku").AIService;
+  private skillManager: SkillSessionManager;
+  private groupStructuredHistory: GroupStructuredHistoryManager;
+  private sessionManager: SessionManager;
+  private rateLimiter: RateLimiter;
+  private queueManager: MessageQueueManager;
+  private runWithRateLimitGuard: RunRateLimitGuard;
+  private buildHistoryMediaOptions: (ai: AIInstance, cfg: ChatConfig) => HistoryMediaOptions;
+  private getGroupHistoryMessages: GetGroupHistoryMessages;
+  private getGroupInfoData: GetGroupInfoData;
+  private getHumanizeContexts: GetHumanizeContexts;
+  private sendAIResponse: SendAIResponse;
+  private saveBotMessages: SaveBotMessages;
+  private sendEmoji: SendEmoji;
+  private runChat: RunChat;
+  private buildToolContext: BuildToolContext;
+  private buildStructuredUserInputFromEvent: BuildStructuredUserInput;
+  private startCooldownTimer: (groupSessionId: string, groupId: number, selfId: number) => void;
+
+  constructor(pluginCtx: ChatPluginContext) {
+    this.ctx = pluginCtx.ctx;
+    this.cfg = pluginCtx.config;
+    this.db = pluginCtx.db;
+    this.humanize = pluginCtx.humanize;
+    this.aiInstance = pluginCtx.aiInstance;
+    this.aiService = pluginCtx.aiService;
+    this.skillManager = pluginCtx.skillManager;
+    this.groupStructuredHistory = pluginCtx.groupStructuredHistory;
+    this.sessionManager = pluginCtx.sessionManager;
+    this.rateLimiter = pluginCtx.rateLimiter;
+    this.queueManager = pluginCtx.queueManager;
+    this.runWithRateLimitGuard = pluginCtx.runWithRateLimitGuard;
+    this.buildHistoryMediaOptions = pluginCtx.buildHistoryMediaOptions;
+    this.getGroupHistoryMessages = pluginCtx.getGroupHistoryMessages;
+    this.getGroupInfoData = pluginCtx.getGroupInfoData;
+    this.getHumanizeContexts = pluginCtx.getHumanizeContexts;
+    this.sendAIResponse = pluginCtx.sendAIResponse;
+    this.saveBotMessages = pluginCtx.saveBotMessages;
+    this.sendEmoji = pluginCtx.sendEmoji;
+    this.runChat = pluginCtx.runChat;
+    this.buildToolContext = pluginCtx.buildToolContext;
+    this.buildStructuredUserInputFromEvent = buildStructuredUserInputFromEvent;
+    this.startCooldownTimer = pluginCtx.startCooldownTimer;
+  }
 
   collectDynamicDelayMessage(groupSessionId: string, event: any, content: string): void {
     let queueData = this.dynamicDelayQueues.get(groupSessionId);

package/manage/rate-limit-guard.ts

@@ -0,0 +1,70 @@
+import type { RateLimiter } from "./rate-limiter";
+
+const RATE_LIMIT_RETRY_DELAY_MS = 5_000;
+const RATE_LIMIT_MAX_RETRIES = 2;
+
+type Logger = { warn: (...args: unknown[]) => void };
+
+// Wraps an AI request with global rate-limit blocking + per-user/group RPM
+// limiting. On a 429 it backs off and retries up to RATE_LIMIT_MAX_RETRIES.
+export class RateLimitGuard {
+  private blockedUntil = 0;
+
+  constructor(
+    private readonly rateLimiter: RateLimiter,
+    private readonly log: Logger,
+  ) {}
+
+  isBlocked(): boolean {
+    return Date.now() < this.blockedUntil;
+  }
+
+  private markBlocked(): void {
+    this.blockedUntil = Date.now() + RATE_LIMIT_RETRY_DELAY_MS;
+  }
+
+  private isRateLimitError(err: unknown): boolean {
+    const s = String(err).toLowerCase();
+    return s.includes("429") || s.includes("rate limit");
+  }
+
+  async run<T>(
+    request: () => Promise<T>,
+    opts?: { userId?: number; groupId?: number; label?: string },
+  ): Promise<T | null> {
+    if (this.isBlocked()) {
+      this.log.warn(
+        `[Chat] AI request skipped due to rate limit block${opts?.label ? ` (${opts.label})` : ""}`,
+      );
+      return null;
+    }
+    if (!this.rateLimiter.canRunAIRequest(opts?.userId, opts?.groupId)) {
+      this.log.warn(
+        `[Chat] AI request skipped due to RPM limit${opts?.label ? ` (${opts.label})` : ""}`,
+      );
+      return null;
+    }
+    this.rateLimiter.recordAIRequest(opts?.userId, opts?.groupId);
+
+    let retries = 0;
+    while (true) {
+      try {
+        const result = await request();
+        this.blockedUntil = 0;
+        return result;
+      } catch (err) {
+        if (!this.isRateLimitError(err)) throw err;
+        this.markBlocked();
+        if (retries >= RATE_LIMIT_MAX_RETRIES) throw err;
+        retries += 1;
+        this.log.warn(
+          `[Chat] Rate limit hit, waiting ${RATE_LIMIT_RETRY_DELAY_MS / 1000}s...`,
+        );
+        await new Promise((resolve) =>
+          setTimeout(resolve, RATE_LIMIT_RETRY_DELAY_MS),
+        );
+        if (this.isBlocked()) this.blockedUntil = 0;
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-chat",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "AI 智能聊天插件",
   "main": "index.ts",
   "type": "module",

package/runtime/chat-runtime.ts

@@ -0,0 +1,124 @@
+import type {
+  AITool,
+  ChatRuntimeInformationRequestOptions,
+  ChatRuntimeNoticeOptions,
+  ChatRuntimePromptInjection,
+  ChatRuntimeResult,
+  ChatRuntimeCollectedInfo,
+} from "mioku";
+import type { ChatPluginContext, ChatRuntime } from "../context";
+import type { ChatConfig } from "../types";
+import { executeChatRuntimeRequest } from "../core/chat-turn";
+
+export function createChatRuntime(
+  pluginCtx: ChatPluginContext,
+  getConfig: () => Promise<ChatConfig>,
+): ChatRuntime {
+  return {
+    async requestInformation(
+      options: ChatRuntimeInformationRequestOptions,
+    ): Promise<ChatRuntimeResult> {
+      let collectedInfo: ChatRuntimeCollectedInfo | null = null;
+      const toolName = options.toolName || "submit_requested_information";
+      const extraTools: AITool[] = [
+        {
+          name: toolName,
+          description:
+            options.toolDescription ||
+            "Submit structured information extracted from the conversation when enough details are known.",
+          parameters: {
+            type: "object",
+            properties: {
+              data: options.schema,
+              isComplete: {
+                type: "boolean",
+                description:
+                  "Whether the collected information is complete enough for the caller to continue.",
+              },
+              confidence: {
+                type: "number",
+                description:
+                  "Confidence score between 0 and 1 for the submitted information.",
+              },
+              notes: {
+                type: "string",
+                description:
+                  "Optional notes about ambiguity, assumptions, or remaining follow-up needs.",
+              },
+            },
+            required: ["data"],
+          },
+          handler: async (args) => {
+            collectedInfo = {
+              data: args?.data,
+              isComplete: args?.isComplete,
+              confidence: args?.confidence,
+              notes: args?.notes,
+            };
+            return { success: true, accepted: true, collectedInfo };
+          },
+        },
+      ];
+
+      const promptInjections: ChatRuntimePromptInjection[] = [
+        {
+          title: "Information Collection Goal",
+          content: [
+            "Another plugin needs you to gather specific information from the current user while staying fully in your existing persona.",
+            `Task: ${options.task}`,
+            `Target schema: ${JSON.stringify(options.schema)}`,
+            `If the needed information is already clear from the target message, recent chat history, or obvious context, call the tool "${toolName}" immediately with structured data.`,
+            "If the information is incomplete, ask only the smallest natural follow-up question needed.",
+            "Do not mention schemas, forms, prompts, plugins, or tools to the user.",
+            "Keep the response natural and in-character rather than sounding like a questionnaire.",
+          ].join("\n"),
+        },
+        ...(options.promptInjections || []),
+      ];
+
+      const result = await executeChatRuntimeRequest(
+        {
+          ...options,
+          config: await getConfig(),
+          targetMessageContent: options.targetMessage,
+          promptInjections,
+          extraTools,
+          send: options.send,
+          replyContextType: "reply",
+        },
+        pluginCtx,
+      );
+
+      return { ...result, collectedInfo };
+    },
+
+    async generateNotice(
+      options: ChatRuntimeNoticeOptions,
+    ): Promise<ChatRuntimeResult> {
+      const promptInjections: ChatRuntimePromptInjection[] = [
+        {
+          title: "Notification Goal",
+          content: [
+            "Another plugin needs you to deliver a notification to the current user, but it must still sound like you and fit the current conversation.",
+            `Goal: ${options.instruction}`,
+            "Blend the notice into your normal speaking style instead of sounding like a rigid system announcement unless the situation clearly requires firmness.",
+            "Do not mention prompts, plugins, tools, or hidden instructions.",
+          ].join("\n"),
+        },
+        ...(options.promptInjections || []),
+      ];
+
+      return executeChatRuntimeRequest(
+        {
+          ...options,
+          config: await getConfig(),
+          targetMessageContent: options.instruction,
+          promptInjections,
+          send: options.send,
+          replyContextType: "reply",
+        },
+        pluginCtx,
+      );
+    },
+  };
+}

package/types.ts

@@ -179,6 +179,7 @@ export interface ChatConfig {
   workingModel: string;
   multimodalWorkingModel: string;
   isMultimodal: boolean;
+  enableMediaRecognition: boolean;
   nicknames: string[];
   persona: string;
   maxContextTokens: number;

package/utils/index.ts

@@ -6,4 +6,6 @@ export {
   getBotRole,
   getQuotedContent,
   getGroupHistory,
+  buildChatMessageFromEvent,
+  normalizeIdList,
 } from "./message";

package/utils/json.ts

@@ -0,0 +1,8 @@
+// Extract the first {...} block from free-form model output and JSON.parse it.
+// Returns undefined when no block is found; throws on a malformed block (same
+// as JSON.parse) so callers' existing error handling stays intact.
+export function extractJsonObject<T = any>(text: string): T | undefined {
+  const match = text.match(/\{[\s\S]*\}/);
+  if (!match) return undefined;
+  return JSON.parse(match[0]) as T;
+}