mioku-plugin-chat 2.8.3 → 2.9.9

package/configs/settings.ts

@@ -18,9 +18,6 @@ export const SETTINGS_CONFIG = {
   },
   audio: {
     enabled: true,
-    baseUrl: "http://localhost:3939",
-    apiKey: "fufu",
-    timeoutMs: 40_000,
   },
   blacklistGroups: [],
   whitelistGroups: [],

package/context.ts

@@ -31,6 +31,7 @@ import type {
   ChatRuntimeResult,
   ChatRuntimeInformationRequestOptions,
 } from "mioku";
+import type { AudioServiceApi } from "mioku-service-audio";
 import type { ChatMessage } from "./types";
 
 export interface ChatPluginContext {
@@ -81,6 +82,7 @@ export interface ChatPluginContext {
     userMsg: ChatMessage,
     groupSessionId: string,
   ) => Promise<void>;
+  audioService?: AudioServiceApi;
 }
 
 export interface ChatRuntimeState {

package/core/base.ts

@@ -14,7 +14,8 @@ import type { HumanizeEngine } from "../humanize";
 import { parseLineMarkers, splitByReplyMarkers } from "../utils/queue";
 import { getGroupHistory } from "../utils";
 import { getService, Services } from "mioku";
-import { synthesizeAudioBase64 } from "./media/audio";
+import { synthesizeAudioSource } from "./media/audio";
+import type { AudioServiceApi } from "mioku-service-audio";
 import {
   extractStandaloneMarkdownBlock,
   splitOutgoingUnits,
@@ -29,6 +30,7 @@ export interface SendAIResponseOptions {
   config: ChatConfig;
   sentIndices?: Set<number>;
   onLineSent?: () => void | Promise<void>;
+  audioService?: AudioServiceApi;
 }
 
 const FAST_TYPING_BASE_MS = 150;
@@ -85,6 +87,7 @@ export async function sendAIResponse(
     config,
     sentIndices,
     onLineSent,
+    audioService,
   } = options;
   const typingDelayEnabled = config.enableTypingDelay ?? false;
   const enableMarkdownScreenshot = config.enableMarkdownScreenshot ?? true;
@@ -205,6 +208,7 @@ export async function sendAIResponse(
       const audioSource = await resolveAudioSource(ctx, {
         audioText,
         config,
+        audioService,
       });
       const fallbackText = !audioSource && audioText ? audioText : undefined;
       if (sendableText) {
@@ -243,6 +247,7 @@ export async function sendMessage(
   text: string,
   config: ChatConfig,
   selfId: number,
+  audioService?: AudioServiceApi,
 ): Promise<void> {
   const typingDelayEnabled = config.enableTypingDelay ?? false;
   const enableMarkdownScreenshot = config.enableMarkdownScreenshot ?? true;
@@ -353,6 +358,7 @@ export async function sendMessage(
       const audioSource = await resolveAudioSource(ctx, {
         audioText,
         config,
+        audioService,
       });
       const fallbackText = !audioSource && audioText ? audioText : undefined;
 
@@ -610,6 +616,7 @@ async function resolveAudioSource(
   options: {
     audioText?: string;
     config: ChatConfig;
+  audioService?: AudioServiceApi;
   },
 ): Promise<string | null> {
   const trimmed = String(options.audioText || "").trim();
@@ -617,12 +624,16 @@ async function resolveAudioSource(
     return null;
   }
 
-  if (!options.config.audio?.enabled || !options.config.audio.baseUrl?.trim()) {
+  if (!options.config.audio?.enabled) {
+    return null;
+  }
+
+  if (!options.audioService) {
     return null;
   }
 
   try {
-    return await synthesizeAudioBase64(options.config.audio, trimmed);
+    return await synthesizeAudioSource(options.audioService, trimmed);
   } catch (error) {
     ctx.logger.error(
       `[audio] Failed to synthesize voice for "${trimmed}": ${error}`,
@@ -746,6 +757,7 @@ export interface BuildToolContextOptions {
   pendingImageUrls?: string[];
   humanize: HumanizeEngine;
   targetMessage: TargetMessage;
+  audioService?: AudioServiceApi;
 }
 
 function resolveTriggerSkillRole(
@@ -794,6 +806,7 @@ export function buildToolContext(
     pendingImageUrls,
     humanize,
     targetMessage,
+    audioService,
   } = options;
 
   return {
@@ -818,6 +831,7 @@ export function buildToolContext(
         content,
         config,
         selfId,
+        audioService,
       );
     },
   };

package/core/chat-turn.ts

@@ -148,7 +148,7 @@ export async function finalizeChatTurn(
 
   if (groupId) {
     await pluginCtx.sendAIResponse(
-      { ctx, groupId, messages: result.messages, config: cfg, sentIndices: toolCtx.sentMessageIndices },
+      { ctx, groupId, messages: result.messages, config: cfg, sentIndices: toolCtx.sentMessageIndices, audioService: pluginCtx.audioService },
       selfId,
     );
     await pluginCtx.sendEmoji(ctx, groupId, result.emojiPath, selfId);
@@ -162,7 +162,7 @@ export async function finalizeChatTurn(
     const sentIndices = toolCtx.sentMessageIndices;
     for (let i = 0; i < result.messages.length; i++) {
       if (sentIndices?.has(i)) continue;
-      await pluginCtx.sendMessage(ctx, undefined, userId, result.messages[i], cfg, selfId);
+      await pluginCtx.sendMessage(ctx, undefined, userId, result.messages[i], cfg, selfId, pluginCtx.audioService);
     }
     if (result.emojiPath) {
       try {
@@ -312,6 +312,7 @@ export async function processChat(
       humanize: pluginCtx.humanize,
       targetMessage,
       selfId: e.self_id,
+      audioService: pluginCtx.audioService,
     });
 
     const result = await pluginCtx.runWithRateLimitGuard(
@@ -497,6 +498,7 @@ async function executeChatRuntimeRequestNow(
     humanize: pluginCtx.humanize,
     targetMessage,
     selfId,
+    audioService: pluginCtx.audioService,
   });
 
   if (options.send === false) {

package/core/media/audio.ts

@@ -1,73 +1,64 @@
-import type { AudioConfig } from "../../types";
+import { readFile } from "node:fs/promises";
+import type { MiokiContext } from "mioki";
+import type { AudioServiceApi, SupportedLang } from "mioku-service-audio";
 
-interface TTSResponse {
-  audio_base64?: string;
-  detail?: string;
-  error?: string;
-}
-
-function ensureTrailingSlash(value: string): string {
-  return value.endsWith("/") ? value : `${value}/`;
-}
-
-function detectAudioLanguage(text: string): string {
-  if (/[\u3040-\u30ff]/.test(text)) {
-    return "all_ja";
-  }
-  if (/[\u4e00-\u9fff]/.test(text)) {
-    return "all_zh";
-  }
+function detectAudioLanguage(text: string): SupportedLang {
+  if (/[\u3040-\u30ff]/.test(text)) return "ja";
+  if (/[\u4e00-\u9fff]/.test(text)) return "zh";
+  if (/[\uac00-\ud7af]/.test(text)) return "ko";
   return "en";
 }
 
-export async function synthesizeAudioBase64(
-  config: AudioConfig,
+export async function synthesizeAudioSource(
+  audioService: AudioServiceApi | undefined,
   text: string,
-): Promise<string> {
-  const trimmedText = String(text || "").trim();
-  if (!config.enabled) {
-    throw new Error("Audio output is disabled");
-  }
-  if (!trimmedText) {
-    throw new Error("Audio text cannot be empty");
-  }
-  if (!config.baseUrl?.trim()) {
-    throw new Error("Audio service baseUrl is not configured");
-  }
-
-  const endpoint = new URL("tts", ensureTrailingSlash(config.baseUrl.trim()));
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  };
+): Promise<string | null> {
+  const trimmed = String(text || "").trim();
+  if (!audioService) return null;
+  if (!trimmed) return null;
 
-  const apiKey = config.apiKey?.trim();
-  if (apiKey) {
-    headers["X-API-Key"] = apiKey;
-  }
+  const isReady = await audioService.ready().catch(() => false);
+  if (!isReady) return null;
 
-  const response = await fetch(endpoint, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      text: trimmedText,
-      text_lang: detectAudioLanguage(trimmedText),
-    }),
-    signal: AbortSignal.timeout(Math.max(1000, config.timeoutMs || 20_000)),
+  const result = await audioService.generateByText({
+    text: trimmed,
+    textLang: detectAudioLanguage(trimmed),
+    mediaType: "wav",
   });
 
-  const payload = (await response.json().catch(() => ({}))) as TTSResponse;
-  if (!response.ok) {
-    throw new Error(
-      payload?.detail ||
-        payload?.error ||
-        `TTS request failed with status ${response.status}`,
-    );
-  }
+  if (!result?.filePath) return null;
+  const filePath = result.filePath.replace(/^file:\/\//, "");
+  const buf = await readFile(filePath);
+  return `base64://${buf.toString("base64")}`;
+}
 
-  const audioBase64 = String(payload.audio_base64 || "").trim();
-  if (!audioBase64) {
-    throw new Error("TTS response missing audio_base64");
+export async function sendVoice(
+  ctx: MiokiContext,
+  e: any,
+  filePath: string,
+  logTag = "[audio]",
+): Promise<void> {
+  const fileUrl = filePath.startsWith("file://")
+    ? filePath
+    : `file://${filePath}`;
+  try {
+    await e.reply([ctx.segment.record(fileUrl)]);
+    return;
+  } catch (err: any) {
+    const msg = String(err?.message ?? err);
+    if (
+      !/File URL path must be absolute|ENOENT|cannot access|No such file/i.test(
+        msg,
+      )
+    ) {
+      throw err;
+    }
+    const localPath = filePath.replace(/^file:\/\//, "");
+    const buf = await readFile(localPath);
+    const b64 = `base64://${buf.toString("base64")}`;
+    ctx.logger.info(
+      `${logTag} file:// 发送失败 (${msg})，回退 base64 (${buf.length} bytes)`,
+    );
+    await e.reply([ctx.segment.record(b64)]);
   }
-
-  return `base64://${audioBase64}`;
 }

package/core/prompt.ts

@@ -279,7 +279,7 @@ function buildResponseFormatSection(
   - Use [reply:123456] at the START of a line to quote-reply that message (123456 is message_id)
   - **You can use MULTIPLE [reply:xxx] markers in different lines to quote multiple messages!**`);
 
-  if (ctx.config.audio?.enabled && ctx.config.audio.baseUrl?.trim()) {
+  if (ctx.config.audio?.enabled) {
     lines.push(`
 ### Optional Voice Message Format
 - You MAY optionally send one voice message by writing [audio:content]
@@ -525,7 +525,7 @@ function buildReviewGuidance(isMulti: boolean, length: Strength): string[] {
 function buildPokedGuidance(length: Strength): string[] {
   return [
     "Someone pokes you in a group, probably out of non-malicious play or to draw your attention to what happened in the group chat.",
-    "Don't make a fuss about replying, just observe whether the chat history in the group has noteworthy content, and if not, simply say hello or express concern to the user.",
+    "Don't make a fuss about replying, just observe whether the chat history in the group has noteworthy content, and if not, simply say hello or express concern to the user. Don't stress about being poked.",
     POKED_LENGTH[length],
   ].filter(Boolean);
 }

package/handlers/idle-debug.ts

@@ -81,6 +81,7 @@ export async function handleIdleCheckDebug(
           humanize: pluginCtx.humanize,
           targetMessage,
           selfId: e.self_id,
+          audioService: pluginCtx.audioService,
         });
 
         const result = await pluginCtx.runWithRateLimitGuard(

package/handlers/message.ts

@@ -25,6 +25,7 @@ import {
   summarizeHistoryVideo,
 } from "../core/media/history-media";
 import { handleIdleCheckDebug } from "./idle-debug";
+import { handleTtsCommand } from "./tts-command";
 import { processChat } from "../core/chat-turn";
 
 const POKE_COOLDOWN_MS = 10 * 60_000;
@@ -55,6 +56,12 @@ export function createMessageHandler(
       return;
     }
 
+    if (text.startsWith("/tts")) {
+      const payload = text.replace(/^\/tts\s*/, "");
+      await handleTtsCommand(pluginCtx, e, payload);
+      return;
+    }
+
     if (text === "/重置会话") {
       if (groupId) {
         pluginCtx.sessionManager.resetBotMessages(`group:${groupId}`);

package/handlers/poke.ts

@@ -86,6 +86,7 @@ export function createPokeHandler(
             humanize: pluginCtx.humanize,
             targetMessage,
             selfId: e.self_id,
+            audioService: pluginCtx.audioService,
           });
 
           const result = await pluginCtx.runWithRateLimitGuard(

package/handlers/tts-command.ts

@@ -0,0 +1,69 @@
+import type { SupportedLang } from "mioku-service-audio";
+import type { ChatPluginContext } from "../context";
+import { sendVoice } from "../core/media/audio";
+
+function detectLang(text: string): SupportedLang {
+  if (/[\u3040-\u30ff]/.test(text)) return "ja";
+  if (/[\u4e00-\u9fff]/.test(text)) return "zh";
+  if (/[\uac00-\ud7af]/.test(text)) return "ko";
+  return "en";
+}
+
+export async function handleTtsCommand(
+  pluginCtx: ChatPluginContext,
+  e: any,
+  payload: string,
+): Promise<void> {
+  const { ctx } = pluginCtx;
+  const isOwner = ctx.isOwner?.(e) ?? false;
+  // if (!isOwner) {
+  //   await e.reply("只有主人才能使用 /tts 指令~");
+  //   return;
+  // }
+
+  const text = String(payload || "").trim();
+  if (!text) {
+    await e.reply("用法: /tts <要合成的文本>");
+    return;
+  }
+
+  const audioService = pluginCtx.audioService;
+  if (!audioService) {
+    await e.reply("audio 服务未加载，请安装 mioku-service-audio 后重启");
+    return;
+  }
+
+  const isReady = await audioService.ready().catch(() => false);
+  if (!isReady) {
+    ctx.logger.warn(
+      `[tts-cmd] audio 未就绪 status=${JSON.stringify(audioService.getStatus?.())}`,
+    );
+    await e.reply("audio 服务正在启动/失败，请稍后再试");
+    return;
+  }
+
+  ctx.logger.info(
+    `[tts-cmd] 推理: "${text.slice(0, 40)}" lang=${detectLang(text)}`,
+  );
+
+  let result;
+  try {
+    result = await audioService.generateByText({
+      text,
+      textLang: detectLang(text),
+      mediaType: "wav",
+    });
+  } catch (err: any) {
+    ctx.logger.error(`[tts-cmd] 推理失败: ${err?.message ?? err}`);
+    await e.reply(`TTS 推理失败: ${err?.message ?? err}`);
+    return;
+  }
+
+  if (!result?.filePath) {
+    await e.reply("TTS 推理未返回音频文件");
+    return;
+  }
+
+  ctx.logger.info(`[tts-cmd] 发送 -> ${result.filePath}`);
+  await sendVoice(ctx, e, result.filePath, "[tts-cmd]");
+}

package/index.ts

@@ -1,11 +1,13 @@
 import { definePlugin, type MiokiContext } from "mioki";
 import type { AIInstance, AIModelRole, AIService } from "mioku";
-import {
-  getPluginRuntimeState,
-  getService,
-  Services,
-} from "mioku";
-import type { ChatConfig, ChatMessage, ChatGroupsFile, TargetMessage } from "./types";
+import type { AudioServiceApi } from "mioku-service-audio";
+import { getPluginRuntimeState, getService, Services } from "mioku";
+import type {
+  ChatConfig,
+  ChatMessage,
+  ChatGroupsFile,
+  TargetMessage,
+} from "./types";
 import { initDatabase } from "./db";
 import { SessionManager } from "./manage/session";
 import { RateLimiter } from "./manage/rate-limiter";
@@ -59,14 +61,10 @@ function resolveRoleInstances(aiService: AIService): {
   isMultimodal: boolean;
 } | null {
   const getByRole = (role: AIModelRole) =>
-    aiService.getInstanceByRole?.(role) ??
-    aiService.get?.(role) ??
-    undefined;
+    aiService.getInstanceByRole?.(role) ?? aiService.get?.(role) ?? undefined;
 
   const main =
-    getByRole("main") ??
-    aiService.getDefault?.() ??
-    aiService.get?.("main");
+    getByRole("main") ?? aiService.getDefault?.() ?? aiService.get?.("main");
   if (!main) return null;
 
   const work = getByRole("working") ?? aiService.get?.("work") ?? main;
@@ -81,9 +79,13 @@ function resolveRoleInstances(aiService: AIService): {
   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);
+    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);
+    const anyInfo = instances.find(
+      (item) => item.name === (fallbackInstance as any).name,
+    );
     return anyInfo?.modelId || "";
   };
 
@@ -121,13 +123,25 @@ export default definePlugin({
     const aiService = getService(ctx, Services.AI);
     const configService = getService(ctx, Services.Config);
     const screenshotService = getService(ctx, Services.Screenshot);
+    const audioService = ctx.services.audio as AudioServiceApi | undefined;
     let warnedMarkdownScreenshotUnavailable = false;
+    if (!audioService) {
+      ctx.logger.warn("聊天插件检测到 audio 服务未安装 语音消息将不会发出");
+    }
 
     if (configService) {
       await configService.registerConfig("chat", "base", BASE_CONFIG);
       await configService.registerConfig("chat", "settings", SETTINGS_CONFIG);
-      await configService.registerConfig("chat", "personalization", PERSONALIZATION_CONFIG);
-      await configService.registerConfig("chat", "groups", DEFAULT_GROUPS_CONFIG);
+      await configService.registerConfig(
+        "chat",
+        "personalization",
+        PERSONALIZATION_CONFIG,
+      );
+      await configService.registerConfig(
+        "chat",
+        "groups",
+        DEFAULT_GROUPS_CONFIG,
+      );
     }
 
     let cachedBaseConfig: ChatConfig | null = null;
@@ -150,7 +164,8 @@ export default definePlugin({
         );
       }
       const base = (await configService.getConfig("chat", "base")) ?? {};
-      const settings = (await configService.getConfig("chat", "settings")) ?? {};
+      const settings =
+        (await configService.getConfig("chat", "settings")) ?? {};
       const personalization =
         (await configService.getConfig("chat", "personalization")) ?? {};
       const mergedDefaults = mergeChatConfig(
@@ -175,20 +190,26 @@ export default definePlugin({
       if (!screenshotService && merged.enableMarkdownScreenshot) {
         merged.enableMarkdownScreenshot = false;
         if (!warnedMarkdownScreenshotUnavailable) {
-          ctx.logger.warn("聊天插件未加载 screenshot 服务，Markdown 截图渲染已自动关闭");
+          ctx.logger.warn(
+            "聊天插件未加载 screenshot 服务，Markdown 截图渲染已自动关闭",
+          );
           warnedMarkdownScreenshotUnavailable = true;
         }
       }
       merged.whitelistGroups = normalizeIdList(merged.whitelistGroups);
       merged.blacklistGroups = normalizeIdList(merged.blacklistGroups);
-      merged.mediaAnalysisBlacklistUsers =
-        normalizeMediaAnalysisBlacklist(merged as Record<string, any>);
+      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.workingModel =
+        roleModels.working || merged.workingModel || merged.model;
       merged.multimodalWorkingModel =
-        roleModels.vision || merged.multimodalWorkingModel || merged.workingModel;
+        roleModels.vision ||
+        merged.multimodalWorkingModel ||
+        merged.workingModel;
       merged.isMultimodal = roleIsMultimodal;
       if (!roleIsMultimodal) merged.enableMediaRecognition = false;
       if (!merged.apiKey) merged.apiKey = "__ai_service__";
@@ -203,7 +224,10 @@ export default definePlugin({
       }
       const raw = await configService.getConfig("chat", "groups");
       cachedGroupsConfig =
-        raw && typeof raw === "object" && raw.groups && typeof raw.groups === "object"
+        raw &&
+        typeof raw === "object" &&
+        raw.groups &&
+        typeof raw.groups === "object"
           ? (raw as ChatGroupsFile)
           : DEFAULT_GROUPS_CONFIG;
     };
@@ -279,7 +303,9 @@ export default definePlugin({
           apiUrl: legacyApiUrl,
           apiKey: legacyApiKey,
           modelType: "text",
-          model: String((earlyConfig as any).workingModel || legacyModel || "default"),
+          model: String(
+            (earlyConfig as any).workingModel || legacyModel || "default",
+          ),
         });
         await aiService.create({
           name: "vision",
@@ -287,7 +313,9 @@ export default definePlugin({
           apiKey: legacyApiKey,
           modelType: "multimodal",
           model: String(
-            (earlyConfig as any).multimodalWorkingModel || legacyModel || "default",
+            (earlyConfig as any).multimodalWorkingModel ||
+              legacyModel ||
+              "default",
           ),
         });
         aiService.setDefault("main");
@@ -367,7 +395,9 @@ export default definePlugin({
     const rateLimitGuard = new RateLimitGuard(rateLimiter, ctx.logger);
     const runWithRateLimitGuard = rateLimitGuard.run.bind(rateLimitGuard);
 
-    const getAIInstance = (role: AIModelRole = "main"): AIInstance | undefined => {
+    const getAIInstance = (
+      role: AIModelRole = "main",
+    ): AIInstance | undefined => {
       if (role === "working") {
         return aiService.getInstanceByRole?.("working") ?? workAIInstance;
       }
@@ -378,12 +408,21 @@ export default definePlugin({
     };
 
     const pluginCtx = {
-      ctx, defaultConfig: configProvider(), configProvider, getConfig,
+      ctx,
+      defaultConfig: configProvider(),
+      configProvider,
+      getConfig,
       db,
-      aiInstance: mainAIInstance, workAIInstance, visionAIInstance,
+      aiInstance: mainAIInstance,
+      workAIInstance,
+      visionAIInstance,
       getAIInstance,
-      aiService, humanize,
-      sessionManager, skillManager, rateLimiter, queueManager,
+      aiService,
+      humanize,
+      sessionManager,
+      skillManager,
+      rateLimiter,
+      queueManager,
       groupStructuredHistory,
       cooldownManager: undefined as unknown as CooldownManager,
       idleCheckManager: undefined as unknown as IdleCheckManager,
@@ -391,28 +430,41 @@ export default definePlugin({
       sessionTurnScheduler,
       runWithRateLimitGuard,
       buildHistoryMediaOptions,
-      getGroupHistoryMessages, getGroupInfoData, getHumanizeContexts,
-      sendAIResponse, sendMessage, saveBotMessages, sendEmoji,
+      getGroupHistoryMessages,
+      getGroupInfoData,
+      getHumanizeContexts,
+      sendAIResponse,
+      sendMessage,
+      saveBotMessages,
+      sendEmoji,
       buildToolContext,
       buildStructuredUserInputFromTarget,
       runChat,
+      audioService,
       startCooldownTimer: (
         groupSessionId: string,
         groupId: number,
         selfId: number,
       ) => cooldownManager.startCooldownTimer(groupSessionId, groupId, selfId),
-      async recordGroupMessageForLearning(userMsg: ChatMessage, groupSessionId: string) {
+      async recordGroupMessageForLearning(
+        userMsg: ChatMessage,
+        groupSessionId: string,
+      ) {
         db.saveMessage(userMsg);
         await Promise.all([
           humanize.expressionLearner.onMessage(userMsg),
           humanize.topicTracker.onMessage(groupSessionId),
         ]);
         if (userMsg.groupId) {
-          const ttlMs = configProvider(userMsg.groupId).groupStructuredHistoryTtlMs;
+          const ttlMs = configProvider(
+            userMsg.groupId,
+          ).groupStructuredHistoryTtlMs;
           groupStructuredHistory.append(
             groupSessionId,
             buildStructuredUserMessages([
-              buildStructuredUserInputFromTarget(userMsg as unknown as TargetMessage),
+              buildStructuredUserInputFromTarget(
+                userMsg as unknown as TargetMessage,
+              ),
             ]),
             ttlMs,
           );
@@ -427,8 +479,14 @@ export default definePlugin({
     const queueProcessor = new QueueProcessor(pluginCtx);
     pluginCtx.queueProcessor = queueProcessor;
 
-    const cleanupInterval = setInterval(() => skillManager.cleanup(), 10 * 60_000);
-    const dbCleanup = new ChatDatabaseCleanup(db, configProvider().retention ?? DEFAULT_CLEANUP_CONFIG);
+    const cleanupInterval = setInterval(
+      () => skillManager.cleanup(),
+      10 * 60_000,
+    );
+    const dbCleanup = new ChatDatabaseCleanup(
+      db,
+      configProvider().retention ?? DEFAULT_CLEANUP_CONFIG,
+    );
     dbCleanup.start();
     idleCheckManager.start();
 
@@ -440,7 +498,11 @@ export default definePlugin({
       },
       matchMessageCommands: (
         getPluginRuntimeState("boot") as
-          | { matchMessageCommands?: (text: string) => Array<{ plugin: string; command: string }> }
+          | {
+              matchMessageCommands?: (
+                text: string,
+              ) => Array<{ plugin: string; command: string }>;
+            }
           | undefined
       )?.matchMessageCommands,
       pokeCooldowns,

package/manage/cooldown.ts

@@ -227,6 +227,7 @@ export class CooldownManager {
       humanize: this.humanize,
       targetMessage,
       selfId,
+      audioService: this.pluginCtx.audioService,
     });
 
     const contexts = await this.getHumanizeContexts(
@@ -353,6 +354,7 @@ export class CooldownManager {
       humanize: this.humanize,
       targetMessage,
       selfId,
+      audioService: this.pluginCtx.audioService,
     });
     const { groupName, memberCount } = await this.getGroupInfoData(
       this.ctx,

package/manage/idle-check.ts

@@ -254,6 +254,7 @@ export class IdleCheckManager {
       humanize: this.humanize,
       targetMessage,
       selfId,
+      audioService: this.pluginCtx.audioService,
     });
 
     const result = await this.runWithRateLimitGuard(

package/manage/queue-processor.ts

@@ -184,6 +184,7 @@ export class QueueProcessor {
     const toolCtx = this.buildToolContext({
       ctx: this.ctx, event: firstMsg.event, groupSessionId, groupId, userId: firstMsg.userId,
       config: cfg, aiService: this.aiService, db: this.db, botRole, humanize: this.humanize, targetMessage, selfId,
+      audioService: this.pluginCtx.audioService,
     });
 
     this.sessionManager.getOrCreate(groupSessionId, "group", groupId);
@@ -264,6 +265,7 @@ export class QueueProcessor {
       const toolCtx = this.buildToolContext({
         ctx: this.ctx, event: null, groupSessionId, groupId, userId: targetMessage.userId,
         config: cfg, aiService: this.aiService, db: this.db, botRole, humanize: this.humanize, targetMessage, selfId,
+        audioService: this.pluginCtx.audioService,
       });
 
       const { history } = await this.getGroupHistoryMessages(groupId, groupSessionId, this.ctx, cfg.historyCount, this.db, selfId, this.buildHistoryMediaOptions(this.aiInstance, cfg));

package/manage/types.ts

@@ -71,6 +71,7 @@ export type SendMessage = (
   text: string,
   config: ChatConfig,
   selfId: number,
+  audioService?: import("mioku-service-audio").AudioServiceApi,
 ) => Promise<void>;
 
 export type BuildToolContext = (options: {
@@ -87,6 +88,7 @@ export type BuildToolContext = (options: {
   pendingImageUrls?: string[];
   humanize: HumanizeEngine;
   targetMessage: TargetMessage;
+  audioService?: import("mioku-service-audio").AudioServiceApi;
 }) => ToolContext;
 
 export type BuildStructuredUserInput = (event: any, content: string, fallbackTimestamp?: number) => StructuredUserInput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-chat",
-  "version": "2.8.3",
+  "version": "2.9.9",
   "description": "AI 智能聊天插件",
   "main": "index.ts",
   "type": "module",
@@ -38,6 +38,11 @@
           "cmd": "/重置群会话",
           "desc": "重置当前群的AI聊天记录",
           "role": "admin"
+        },
+        {
+          "cmd": "/tts <文本>",
+          "desc": "TTS 推理",
+          "role": "owner"
         }
       ]
     }
@@ -53,7 +58,8 @@
     "mioku": "workspace:*"
   },
   "peerDependencies": {
-    "mioku": "^0.8.0",
+    "mioku": "^0.9.0",
+    "mioku-service-audio": "workspace:*",
     "mioki": "^0.16.0"
   }
 }

package/types.ts

@@ -154,11 +154,6 @@ export interface WebReaderConfig {
  */
 export interface AudioConfig {
   enabled: boolean;
-  // 服务器URL
-  baseUrl: string;
-  // 密钥
-  apiKey: string;
-  timeoutMs: number;
 }
 
 export interface AIRequestLimitConfig {