mioku-plugin-chat 2.7.0 → 2.8.0

package/configs/base.ts

@@ -1,13 +1,7 @@
 export const BASE_CONFIG = {
-  apiUrl: "https://api.openai.com/v1",
-  apiKey: "",
-  model: "gemini-3.0-flash-preview",
-  workingModel: "deepseek/deepseek-v3.2-exp", // 工作模型，用于 planner 等轻量任务
-  multimodalWorkingModel: "doubao-seed-2.0-mini", // 多模态工作模型，用于图片描述等任务
-  isMultimodal: true,
-  enableMediaRecognition: true, // 是否用多模态工作模型自动识别聊天记录中的图片/视频等媒体
   maxContextTokens: 128,
   temperature: 0.8,
-  historyCount: 100, // 群聊历史消息数量
-  maxIterations: 20, // AI 迭代次数限制，-1 表示不限制
+  historyCount: 100,
+  maxIterations: 20,
+  enableMediaRecognition: true,
 };

package/context.ts

@@ -1,5 +1,5 @@
 import type { MiokiContext } from "mioki";
-import type { AIInstance, AIService } from "mioku";
+import type { AIInstance, AIModelRole, AIService } from "mioku";
 import type { ChatConfig } from "./types";
 import type { ChatDatabase } from "./db";
 import type { HumanizeEngine, ChatConfigProvider } from "./humanize";
@@ -33,12 +33,7 @@ import type {
 } from "mioku";
 import type { ChatMessage } from "./types";
 
-/**
- * Core plugin context - bundles all managers and core services.
- * This is created once during plugin setup and used throughout the plugin lifetime.
- */
 export interface ChatPluginContext {
-  // Core context
   ctx: MiokiContext;
   defaultConfig: ChatConfig;
   configProvider: ChatConfigProvider;
@@ -47,10 +42,10 @@ export interface ChatPluginContext {
   aiInstance: AIInstance;
   workAIInstance: AIInstance;
   visionAIInstance: AIInstance;
+  getAIInstance: (role?: AIModelRole) => AIInstance | undefined;
   aiService: AIService;
   humanize: HumanizeEngine;
 
-  // Managers
   sessionManager: SessionManager;
   skillManager: SkillSessionManager;
   rateLimiter: RateLimiter;
@@ -61,10 +56,8 @@ export interface ChatPluginContext {
   queueProcessor: QueueProcessor;
   sessionTurnScheduler: SessionTurnScheduler;
 
-  // Utility
   runWithRateLimitGuard: RunRateLimitGuard;
 
-  // Services (utility functions)
   buildHistoryMediaOptions: (
     ai: AIInstance,
     config: ChatConfig,
@@ -90,17 +83,11 @@ export interface ChatPluginContext {
   ) => Promise<void>;
 }
 
-/**
- * Runtime state for rate limiting - passed separately as it's mutable state.
- */
 export interface ChatRuntimeState {
   isRateLimitBlocked: () => boolean;
   processingSet: Set<string>;
 }
 
-/**
- * Closure state shared with the extracted message/poke handlers.
- */
 export interface ChatHandlerState {
   getConfig: (groupId?: number) => Promise<ChatConfig>;
   matchMessageCommands?: (
@@ -110,10 +97,6 @@ export interface ChatHandlerState {
   pokeCooldowns: Map<number, number>;
 }
 
-/**
- * Chat runtime implementation for external callers (like boot plugin).
- * Provides notice generation and information request capabilities.
- */
 export interface ChatRuntime {
   generateNotice(
     options: ChatRuntimeNoticeOptions,

package/core/tools/info.ts

@@ -95,8 +95,17 @@ export function createInfoTools(toolCtx: ToolContext): AITool[] {
     tools.push({
       name: "get_group_member_list",
       description: "Get the list of group members (returns name and role only)",
-      parameters: { type: "object", properties: {} },
-      handler: async () => {
+      parameters: {
+        type: "object",
+        properties: {
+          limit: {
+            type: "number",
+            description: "Optional max members to return (server still caps at 50)",
+          },
+        },
+        required: [],
+      },
+      handler: async (args) => {
         try {
           const list = await toolCtx.ctx
             .pickBot(toolCtx.event.self_id)
@@ -106,7 +115,12 @@ export function createInfoTools(toolCtx: ToolContext): AITool[] {
             nickname: m.card || m.nickname,
             role: m.role,
           }));
-          return { members: members.slice(0, 50), total: members.length };
+          const limitRaw = Math.floor(Number(args?.limit));
+          const limit =
+            Number.isFinite(limitRaw) && limitRaw > 0
+              ? Math.min(limitRaw, 50)
+              : 50;
+          return { members: members.slice(0, limit), total: members.length };
         } catch (err) {
           return { error: `Failed to get member list: ${err}` };
         }

package/handlers/message.ts

@@ -36,7 +36,7 @@ export function createMessageHandler(
     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 (!cfg.model && !cfg.apiKey) return;
     if (!e?.message || !Array.isArray(e.message)) return;
 
     const text = ctx.text(e) || "";

package/handlers/poke.ts

@@ -16,7 +16,7 @@ export function createPokeHandler(
     if (e.target_id !== e.self_id) return;
     const groupId = e.group_id;
     const cfg = groupId ? await getConfig(groupId) : await getConfig();
-    if (!cfg.apiKey) return;
+    if (!cfg.model && !cfg.apiKey) return;
     if (!groupId || !isGroupAllowed(groupId, cfg)) return;
 
     const lastPoke = pokeCooldowns.get(groupId) ?? 0;

package/index.ts

@@ -1,6 +1,6 @@
 import { definePlugin } from "mioki";
 import type { MiokiContext } from "mioki";
-import type { AIInstance, AIService, ConfigService, ScreenshotService } from "mioku";
+import type { AIInstance, AIModelRole, AIService, ConfigService, ScreenshotService } from "mioku";
 import { getPluginRuntimeState } from "mioku";
 import type { ChatConfig, ChatMessage, ChatGroupsFile, TargetMessage } from "./types";
 import { initDatabase } from "./db";
@@ -48,9 +48,69 @@ import {
   normalizeMediaAnalysisBlacklist,
 } from "./utils/config";
 
+function resolveRoleInstances(aiService: AIService): {
+  main: AIInstance;
+  work: AIInstance;
+  vision: AIInstance;
+  models: { main: string; working: string; vision: string };
+  isMultimodal: boolean;
+} | null {
+  const getByRole = (role: AIModelRole) =>
+    aiService.getInstanceByRole?.(role) ??
+    aiService.get?.(role) ??
+    undefined;
+
+  const main =
+    getByRole("main") ??
+    aiService.getDefault?.() ??
+    aiService.get?.("main");
+  if (!main) return null;
+
+  const work = getByRole("working") ?? aiService.get?.("work") ?? main;
+  const vision = getByRole("vision") ?? aiService.get?.("vision") ?? work;
+
+  const bindings = aiService.getRoleBindings?.() ?? {
+    main: undefined,
+    working: undefined,
+    vision: undefined,
+  };
+  const instances = aiService.listInstances?.() ?? [];
+  const findModel = (role: AIModelRole, fallbackInstance: AIInstance) => {
+    const full = bindings[role];
+    if (full && full.includes("/")) return full.split("/").slice(1).join("/");
+    const info = instances.find((item) => item.role === role || item.name === role);
+    if (info?.modelId) return info.modelId;
+    const anyInfo = instances.find((item) => item.name === (fallbackInstance as any).name);
+    return anyInfo?.modelId || "";
+  };
+
+  const mainModel = findModel("main", main);
+  const workingModel = findModel("working", work) || mainModel;
+  const visionModel = findModel("vision", vision) || workingModel;
+
+  const models = aiService.listModels?.() ?? [];
+  const visionDesc =
+    models.find((item) => item.id === bindings.vision) ||
+    models.find((item) => item.modelId === visionModel);
+  const isMultimodal =
+    visionDesc?.capabilities?.includes("vision") ?? Boolean(visionModel);
+
+  return {
+    main,
+    work,
+    vision,
+    models: {
+      main: mainModel,
+      working: workingModel,
+      vision: visionModel,
+    },
+    isMultimodal,
+  };
+}
+
 export default definePlugin({
   name: "chat",
-  version: "1.0.0",
+  version: "1.1.0",
   description: "AI 智能聊天插件",
   async setup(ctx: MiokiContext) {
     ctx.logger.info("聊天插件正在初始化...");
@@ -69,6 +129,12 @@ export default definePlugin({
 
     let cachedBaseConfig: ChatConfig | null = null;
     let cachedGroupsConfig: ChatGroupsFile | null = null;
+    let roleModels = {
+      main: "",
+      working: "",
+      vision: "",
+    };
+    let roleIsMultimodal = true;
 
     const buildGlobalConfig = async (): Promise<ChatConfig> => {
       if (!configService) {
@@ -115,6 +181,15 @@ export default definePlugin({
       merged.mediaAnalysisBlacklistUsers =
         normalizeMediaAnalysisBlacklist(merged as Record<string, any>);
       delete (merged as any).imageAnalysisBlacklistUsers;
+
+      merged.model = roleModels.main || merged.model || "";
+      merged.workingModel = roleModels.working || merged.workingModel || merged.model;
+      merged.multimodalWorkingModel =
+        roleModels.vision || merged.multimodalWorkingModel || merged.workingModel;
+      merged.isMultimodal = roleIsMultimodal;
+      if (!roleIsMultimodal) merged.enableMediaRecognition = false;
+      if (!merged.apiKey) merged.apiKey = "__ai_service__";
+
       return merged;
     };
 
@@ -173,63 +248,85 @@ export default definePlugin({
       return configProvider(groupId);
     };
 
-    const defaultConfig = configProvider();
-    const config = defaultConfig;
-
-    if (!config.apiKey) {
-      ctx.logger.warn("聊天插件未配置 API Key，请在 config/chat/base.json 中配置");
+    if (!aiService) {
+      ctx.logger.error("聊天插件需要 AI 服务，但 AI 服务不可用");
       return;
     }
 
-    const db = await initDatabase();
-    const sessionManager = new SessionManager(db, config.maxSessions);
-    const queueManager = new MessageQueueManager();
-    const rateLimiter = new RateLimiter({
-      maxTriggersPerWindow: 5,
-      windowMs: 60_000,
-      dedupWindowMs: 30_000,
-      groupCooldownMs: 1_000,
-    });
-    rateLimiter.setConfigProvider(configProvider);
-    const skillManager = new SkillSessionManager();
+    let resolved = resolveRoleInstances(aiService);
 
-    rateLimiter.setQueueLengthGetter((groupId: number) =>
-      queueManager.getQueueLength(`group:${groupId}`),
-    );
+    if (!resolved) {
+      const earlyConfig = configProvider();
+      const legacyApiUrl = String((earlyConfig as any).apiUrl || "").trim();
+      const legacyApiKey = String((earlyConfig as any).apiKey || "").trim();
+      const legacyModel = String((earlyConfig as any).model || "").trim();
+      if (legacyApiUrl && legacyApiKey && legacyApiKey !== "__ai_service__") {
+        ctx.logger.warn(
+          "未检测到 AI 角色绑定，回退到 chat/base 遗留 apiUrl/apiKey 创建实例",
+        );
+        await aiService.create({
+          name: "main",
+          apiUrl: legacyApiUrl,
+          apiKey: legacyApiKey,
+          modelType: "multimodal",
+          model: legacyModel || "default",
+        });
+        await aiService.create({
+          name: "work",
+          apiUrl: legacyApiUrl,
+          apiKey: legacyApiKey,
+          modelType: "text",
+          model: String((earlyConfig as any).workingModel || legacyModel || "default"),
+        });
+        await aiService.create({
+          name: "vision",
+          apiUrl: legacyApiUrl,
+          apiKey: legacyApiKey,
+          modelType: "multimodal",
+          model: String(
+            (earlyConfig as any).multimodalWorkingModel || legacyModel || "default",
+          ),
+        });
+        aiService.setDefault("main");
+        aiService.setRoleBinding?.(
+          "main",
+          `runtime-main/${legacyModel || "default"}`,
+        );
+        aiService.setRoleBinding?.(
+          "working",
+          `runtime-work/${String((earlyConfig as any).workingModel || legacyModel || "default")}`,
+        );
+        aiService.setRoleBinding?.(
+          "vision",
+          `runtime-vision/${String((earlyConfig as any).multimodalWorkingModel || legacyModel || "default")}`,
+        );
+        resolved = resolveRoleInstances(aiService);
+      }
+    }
 
-    if (!aiService) {
-      ctx.logger.error("聊天插件需要 AI 服务，但 AI 服务不可用");
+    if (!resolved) {
+      ctx.logger.error(
+        "未配置 AI 提供商/主模型，请在 WebUI AI 设置中配置提供商并绑定主模型",
+      );
       return;
     }
 
-    const mainAIInstance = await aiService.create({
-      name: "main",
-      apiUrl: config.apiUrl,
-      apiKey: config.apiKey,
-      modelType: config.isMultimodal ? "multimodal" : "text",
-      model: config.model,
-    });
-    const workAIInstance = await aiService.create({
-      name: "work",
-      apiUrl: config.apiUrl,
-      apiKey: config.apiKey,
-      modelType: "text",
-      model: config.workingModel,
-    });
-    const visionAIInstance = await aiService.create({
-      name: "vision",
-      apiUrl: config.apiUrl,
-      apiKey: config.apiKey,
-      modelType: "multimodal",
-      model: config.multimodalWorkingModel,
-    });
-    aiService.setDefault("main");
+    roleModels = resolved.models;
+    roleIsMultimodal = resolved.isMultimodal;
+    await refreshBaseCache();
+
+    const mainAIInstance = resolved.main;
+    const workAIInstance = resolved.work;
+    const visionAIInstance = resolved.vision;
+    if (!aiService.getDefault()) {
+      aiService.setDefault("main");
+    }
 
     const registerPersona = (persona: string) => {
       mainAIInstance.registerPrompt("persona", persona);
       workAIInstance.registerPrompt("persona", persona);
     };
-    registerPersona(String(config.persona ?? ""));
+    registerPersona(String(configProvider().persona ?? ""));
     if (configService) {
       configService.onConfigChange("chat", "personalization", async () => {
         try {
@@ -241,6 +338,22 @@ export default definePlugin({
       });
     }
 
+    const db = await initDatabase();
+    const sessionManager = new SessionManager(db, configProvider().maxSessions);
+    const queueManager = new MessageQueueManager();
+    const rateLimiter = new RateLimiter({
+      maxTriggersPerWindow: 5,
+      windowMs: 60_000,
+      dedupWindowMs: 30_000,
+      groupCooldownMs: 1_000,
+    });
+    rateLimiter.setConfigProvider(configProvider);
+    const skillManager = new SkillSessionManager();
+
+    rateLimiter.setQueueLengthGetter((groupId: number) =>
+      queueManager.getQueueLength(`group:${groupId}`),
+    );
+
     const humanize = new HumanizeEngine(workAIInstance, db, configProvider);
     await humanize.init();
 
@@ -251,10 +364,21 @@ export default definePlugin({
     const rateLimitGuard = new RateLimitGuard(rateLimiter, ctx.logger);
     const runWithRateLimitGuard = rateLimitGuard.run.bind(rateLimitGuard);
 
+    const getAIInstance = (role: AIModelRole = "main"): AIInstance | undefined => {
+      if (role === "working") {
+        return aiService.getInstanceByRole?.("working") ?? workAIInstance;
+      }
+      if (role === "vision") {
+        return aiService.getInstanceByRole?.("vision") ?? visionAIInstance;
+      }
+      return aiService.getInstanceByRole?.("main") ?? mainAIInstance;
+    };
+
     const pluginCtx = {
-      ctx, defaultConfig, configProvider, getConfig,
+      ctx, defaultConfig: configProvider(), configProvider, getConfig,
       db,
       aiInstance: mainAIInstance, workAIInstance, visionAIInstance,
+      getAIInstance,
       aiService, humanize,
       sessionManager, skillManager, rateLimiter, queueManager,
       groupStructuredHistory,
@@ -301,7 +425,7 @@ export default definePlugin({
     pluginCtx.queueProcessor = queueProcessor;
 
     const cleanupInterval = setInterval(() => skillManager.cleanup(), 10 * 60_000);
-    const dbCleanup = new ChatDatabaseCleanup(db, config.retention ?? DEFAULT_CLEANUP_CONFIG);
+    const dbCleanup = new ChatDatabaseCleanup(db, configProvider().retention ?? DEFAULT_CLEANUP_CONFIG);
     dbCleanup.start();
     idleCheckManager.start();
 
@@ -325,7 +449,9 @@ export default definePlugin({
     ctx.handle("message", createMessageHandler(pluginCtx, handlerState));
     ctx.handle("notice.group.poke" as any, createPokeHandler(pluginCtx, handlerState));
 
-    ctx.logger.info("聊天插件加载成功");
+    ctx.logger.info(
+      `聊天插件加载成功 (main=${roleModels.main || "?"}, work=${roleModels.working || "?"}, vision=${roleModels.vision || "?"})`,
+    );
 
     return () => {
       idleCheckManager.dispose();

package/manage/idle-check.ts

@@ -102,7 +102,7 @@ export class IdleCheckManager {
   private async tick(): Promise<void> {
     try {
       const baseCfg = this.defaultConfig;
-      if (!baseCfg.apiKey) return;
+      if (!baseCfg.model && !baseCfg.apiKey) return;
 
       const now = Date.now();
       const checkInterval = 60_000;

package/package.json

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

package/types.ts

@@ -171,8 +171,10 @@ export interface AIRequestLimitConfig {
  * 聊天插件配置
  */
 export interface ChatConfig {
-  apiUrl: string;
-  apiKey: string;
+  /** @deprecated AI 连接已迁移到 ai-service providers */
+  apiUrl?: string;
+  /** @deprecated AI 连接已迁移到 ai-service providers；非空仅作兼容哨兵 */
+  apiKey?: string;
   model: string;
   workingModel: string;
   multimodalWorkingModel: string;
@@ -234,6 +236,7 @@ export interface ChatGroupOverrides {
   dynamicDelay?: { enabled?: boolean };
   enableMarkdownScreenshot?: boolean;
   enableMediaRecognition?: boolean;
+  allowedExternalSkills?: string[];
 }
 
 export type ChatGroupsFile = {

package/utils/group-config.ts

@@ -18,6 +18,8 @@ const OVERRIDABLE_BOOLEAN_FIELDS = [
   "enableMediaRecognition",
 ] as const;
 
+const OVERRIDABLE_ARRAY_FIELDS = ["allowedExternalSkills"] as const;
+
 /**
  * 把每个群的覆盖配置浅合并到全局配置上
  * - 子对象（如 emoji）只覆盖其中存在的字段，未填字段继承全局
@@ -55,6 +57,13 @@ export function mergeGroupOverrides(
     }
   }
 
+  for (const key of OVERRIDABLE_ARRAY_FIELDS) {
+    const value = overridesMap[key];
+    if (Array.isArray(value)) {
+      resultMap[key] = value.filter((v) => typeof v === "string");
+    }
+  }
+
   return result;
 }