@downcity/plugins 1.0.174 → 1.0.193

package/scripts/chat-channel-config.test.mjs

@@ -1,82 +1,33 @@
 /**
- * Chat channel 配置持久化公开行为测试。
+ * Chat channel 构造配置公开行为测试。
  */
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ChatPlugin } from "../bin/index.js";
 
 function create_channel(name) {
-  let enabled = false;
-  let channel_account_id = "";
   return {
     name,
-    isEnabled: () => enabled,
-    getChannelAccountId: () => channel_account_id,
+    isEnabled: () => false,
+    getChannelAccountId: () => "",
     getAccount: () => null,
-    applyRuntimePatch: (patch) => {
-      if (typeof patch.enabled === "boolean") enabled = patch.enabled;
-      if (Object.prototype.hasOwnProperty.call(patch, "channelAccountId")) {
-        channel_account_id = String(patch.channelAccountId || "").trim();
-      }
-    },
   };
 }
 
-function create_context(plugin) {
-  const writes = [];
-  const context = {
-    config: {
-      id: "agent_test",
-      version: "1.0.0",
-      plugins: { memory: { enabled: true } },
-    },
-    pluginInstances: new Map([["chat", plugin]]),
-    pluginConfig: {
-      persistProjectPlugins: async (plugins) => {
-        writes.push(structuredClone(plugins));
-        return "/tmp/agent_test";
-      },
-    },
-  };
-  return { context, writes };
-}
-
-async function execute(plugin, action_name, context, input) {
-  return await plugin.actions[action_name].execute({
-    context,
-    input,
-    pluginName: "chat",
-    actionName: action_name,
-  });
-}
-
-test("chat.open/close/configure 持久化完整 plugins 配置", async () => {
+test("ChatPlugin 配置只来自 constructor", () => {
   const telegram = create_channel("telegram");
-  const plugin = new ChatPlugin({ channels: [telegram] });
-  const { context, writes } = create_context(plugin);
-
-  await execute(plugin, "open", context, { channel: "telegram" });
-  assert.equal(writes.length, 1);
-  assert.equal(writes[0].memory.enabled, true);
-  assert.equal(writes[0].chat.channels.telegram.enabled, true);
-  assert.equal(plugin.isChannelEnabled(context, "telegram"), true);
-
-  await execute(plugin, "configure", context, {
-    channel: "telegram",
-    config: { enabled: false },
-    restart: false,
-  });
-  assert.equal(writes.length, 2);
-  assert.equal(writes[1].chat.channels.telegram.enabled, false);
-  assert.equal(plugin.isChannelEnabled(context, "telegram"), false);
+  const queue = { maxConcurrency: 7, mergeDebounceMs: 123 };
+  const plugin = new ChatPlugin({ queue, channels: [telegram] });
 
-  await execute(plugin, "close", context, { channel: "telegram" });
-  assert.equal(writes.length, 3);
-  assert.equal(context.config.plugins.chat.channels.telegram.enabled, false);
+  assert.equal(plugin.channels[0], telegram);
+  assert.deepEqual(plugin.getQueueWorkerConfig({}), queue);
 });
 
-test("ChatPlugin queue 只读取 constructor 配置", () => {
-  const queue = { maxConcurrency: 7, mergeDebounceMs: 123 };
-  const plugin = new ChatPlugin({ queue, channels: [] });
-  assert.deepEqual(plugin.getQueueWorkerConfig({}), queue);
+test("ChatPlugin 不提供配置修改 action", () => {
+  const plugin = new ChatPlugin({ channels: [] });
+
+  assert.equal("open" in plugin.actions, false);
+  assert.equal("close" in plugin.actions, false);
+  assert.equal("configuration" in plugin.actions, false);
+  assert.equal("configure" in plugin.actions, false);
 });

package/scripts/chat-storage.test.mjs

@@ -0,0 +1,92 @@
+/**
+ * Chat Plugin 存储所有权测试。
+ */
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { ChatPlugin, clean_chat_storage } from "../bin/index.js";
+
+function create_project_root() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "downcity-chat-storage-"));
+}
+
+test("clean_chat_storage 只清理 Chat Plugin 自有数据", async () => {
+  const root_path = create_project_root();
+  try {
+    const session_id = "session_chat";
+    const meta_path = path.join(root_path, ".downcity", "channel", "meta.json");
+    const chat_dir = path.join(root_path, ".downcity", "chat", session_id);
+    const agent_session_dir = path.join(
+      root_path,
+      ".downcity",
+      "agents",
+      "agent_test",
+      "sessions",
+      session_id,
+    );
+    fs.mkdirSync(path.dirname(meta_path), { recursive: true });
+    fs.mkdirSync(chat_dir, { recursive: true });
+    fs.mkdirSync(agent_session_dir, { recursive: true });
+    fs.writeFileSync(path.join(chat_dir, "history.jsonl"), "{}\n");
+    fs.writeFileSync(meta_path, JSON.stringify({
+      v: 1,
+      updatedAt: Date.now(),
+      sessionIdByTargetKey: { "telegram|chat_1||": session_id },
+      routesBySessionId: {
+        [session_id]: {
+          v: 1,
+          sessionId: session_id,
+          channel: "telegram",
+          chatId: "chat_1",
+          updatedAt: Date.now(),
+        },
+      },
+    }));
+
+    const result = await clean_chat_storage({
+      root_path,
+      channel: "telegram",
+      chat_id: "chat_1",
+    });
+    assert.equal(result.session_id, session_id);
+    assert.equal(result.removed_chat_dir, true);
+    assert.equal(result.removed_route, true);
+    assert.equal(fs.existsSync(chat_dir), false);
+    assert.equal(fs.existsSync(agent_session_dir), true);
+    const meta = JSON.parse(fs.readFileSync(meta_path, "utf8"));
+    assert.equal(meta.routesBySessionId[session_id], undefined);
+  } finally {
+    fs.rmSync(root_path, { recursive: true, force: true });
+  }
+});
+
+test("chat.history_clear action 只清空事件历史", async () => {
+  const root_path = create_project_root();
+  try {
+    const session_id = "session_history";
+    const history_path = path.join(
+      root_path,
+      ".downcity",
+      "chat",
+      session_id,
+      "history.jsonl",
+    );
+    fs.mkdirSync(path.dirname(history_path), { recursive: true });
+    fs.writeFileSync(history_path, "{}\n");
+    const plugin = new ChatPlugin({ channels: [] });
+    const result = await plugin.actions.history_clear.execute({
+      context: { rootPath: root_path },
+      input: { sessionId: session_id },
+      pluginName: "chat",
+      actionName: "history_clear",
+    });
+    assert.equal(result.success, true);
+    assert.equal(result.data.cleared, true);
+    assert.equal(fs.existsSync(history_path), false);
+  } finally {
+    fs.rmSync(root_path, { recursive: true, force: true });
+  }
+});

package/scripts/skill-plugin.test.mjs

@@ -0,0 +1,93 @@
+/**
+ * SkillPlugin action 目录与动态 system prompt 回归测试。
+ *
+ * 关键点（中文）
+ * - find/install action 只返回 shell 指引，不能执行命令或写入文件。
+ * - system prompt 必须根据构造参数输出项目、用户和自定义扫描根。
+ * - install action 的提示词应引导 Agent 调用 list 检查 Skill 是否进入可发现范围。
+ */
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { SkillPlugin } from "../bin/index.js";
+
+test("SkillPlugin 暴露四个职责清晰的 actions", () => {
+  const plugin = new SkillPlugin();
+
+  assert.deepEqual(Object.keys(plugin.actions).sort(), [
+    "find",
+    "install",
+    "list",
+    "lookup",
+  ]);
+});
+
+test("SkillPlugin 根据扫描参数生成 action 工作流提示", async () => {
+  const project_root = path.resolve("fixtures/skill-prompt-project");
+  const plugin = new SkillPlugin({
+    use: ["project", "home"],
+    paths: [".agents/shared-skills"],
+    ignore: ["hidden-skill"],
+  });
+
+  const prompt = await plugin.system({ rootPath: project_root });
+
+  assert.match(prompt, /\[project\] \.agents\/skills ->/);
+  assert.match(prompt, /\[custom\] \.agents\/shared-skills ->/);
+  assert.match(prompt, /\[home\] ~\/\.agents\/skills ->/);
+  assert.match(prompt, /Call `skill\.find`/);
+  assert.match(prompt, /call `skill\.install`/);
+  assert.match(prompt, /return prompts only/);
+  assert.match(prompt, /Configured ignore rules are active/);
+});
+
+test("find 和 install actions 只返回提示词且不创建扫描目录", async () => {
+  const project_root = path.resolve("fixtures/skill-instruction-actions");
+  const plugin = new SkillPlugin({
+    use: ["project", "home"],
+    paths: [".agents/shared-skills"],
+  });
+
+  assert.equal(fs.existsSync(project_root), false);
+
+  const find_result = await plugin.actions.find.execute({
+    context: { rootPath: project_root },
+    input: { query: "web access" },
+  });
+  const install_result = await plugin.actions.install.execute({
+    context: { rootPath: project_root },
+    input: { spec: "owner/repository@web-access" },
+  });
+
+  assert.equal(find_result.success, true);
+  assert.match(find_result.data.prompt, /https:\/\/www\.skills\.sh\//);
+  assert.match(
+    find_result.data.prompt,
+    /https:\/\/app\.lobehub\.com\/community\/skill/,
+  );
+  assert.match(find_result.data.prompt, /npx -y skills find 'web access'/);
+  assert.match(find_result.data.prompt, /has not searched for or installed anything/);
+  assert.equal(install_result.success, true);
+  assert.match(
+    install_result.data.prompt,
+    /npx -y skills add 'owner\/repository@web-access' -y/,
+  );
+  assert.match(install_result.data.prompt, /action: "list"/);
+  assert.match(install_result.data.prompt, /has not installed or changed any files/);
+  assert.equal(fs.existsSync(project_root), false);
+});
+
+test("install action 在没有扫描根时返回配置提示", async () => {
+  const project_root = path.resolve("fixtures/no-skill-root");
+  const plugin = new SkillPlugin({ use: [] });
+  const result = await plugin.actions.install.execute({
+    context: { rootPath: project_root },
+    input: { spec: "owner/repository@skill" },
+  });
+
+  assert.equal(result.success, true);
+  assert.match(result.data.prompt, /No scan roots are configured/);
+  assert.equal(fs.existsSync(project_root), false);
+});

package/scripts/sound-plugin.test.mjs

@@ -0,0 +1,250 @@
+/**
+ * @file SoundPlugin 的 FED 模型发现、ASR/TTS 调用和自动转写测试。
+ *
+ * 关键点（中文）
+ * - 测试编译后的公开入口，确保 package 导出与用户实际使用方式一致。
+ * - ASR 测试验证本地音频只会转成 data URL，不会把本地路径传给 FED。
+ * - TTS 测试验证输出严格使用 AI SDK UIMessage。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { SoundPlugin } from "../bin/index.js";
+
+function create_context(root_path) {
+  return {
+    rootPath: root_path,
+  };
+}
+
+async function run_action(plugin, action_name, context, input) {
+  return await plugin.actions[action_name].execute({
+    context,
+    input,
+    pluginName: plugin.name,
+    actionName: action_name,
+  });
+}
+
+function create_tts_message(url = "data:audio/mpeg;base64,dGVzdA==") {
+  return {
+    id: "sound:test",
+    role: "assistant",
+    parts: [
+      {
+        type: "file",
+        mediaType: "audio/mpeg",
+        filename: "speech.mp3",
+        url,
+      },
+    ],
+  };
+}
+
+test("sound.models 只返回 FED 中支持 ASR 或 TTS 的模型", async () => {
+  const plugin = new SoundPlugin({
+    list_models: () => [
+      { id: "asr", name: "ASR", modalities: ["asr"] },
+      { id: "tts", name: "TTS", modalities: ["tts"] },
+      { id: "both", name: "Both", modalities: ["asr", "tts"] },
+      { id: "text", name: "Text", modalities: ["text"] },
+    ],
+    asr: async () => ({ text: "ok" }),
+    tts: async () => create_tts_message(),
+  });
+  const context = create_context(process.cwd());
+
+  const all_result = await run_action(plugin, "models", context, {});
+  assert.equal(all_result.success, true);
+  assert.deepEqual(all_result.data.items.map((model) => model.id), ["asr", "tts", "both"]);
+
+  const asr_result = await run_action(plugin, "models", context, { capability: "asr" });
+  assert.equal(asr_result.success, true);
+  assert.deepEqual(asr_result.data.items.map((model) => model.id), ["asr", "both"]);
+
+  const tts_result = await run_action(plugin, "models", context, { capability: "tts" });
+  assert.equal(tts_result.success, true);
+  assert.deepEqual(tts_result.data.items.map((model) => model.id), ["tts", "both"]);
+});
+
+test("sound.asr 把本地音频转为 data URL 后直接调用 FED", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-sound-"));
+  const audio_path = path.join(root_path, "voice.wav");
+  await fs.writeFile(audio_path, Buffer.from("audio-test"));
+  let received_input;
+  const plugin = new SoundPlugin({
+    default_asr_model: "fed-asr",
+    asr: async (input) => {
+      received_input = input;
+      return {
+        text: " transcript ",
+        segments: [{ text: " first ", startSecond: 0, endSecond: 1.25 }],
+        language: "en",
+        durationInSeconds: 1.25,
+      };
+    },
+    tts: async () => create_tts_message(),
+  });
+
+  try {
+    const result = await run_action(
+      plugin,
+      "asr",
+      create_context(root_path),
+      { audio_path: "./voice.wav" },
+    );
+    assert.equal(result.success, true);
+    assert.equal(received_input.model, "fed-asr");
+    assert.equal(received_input.audio_path, undefined);
+    assert.equal(received_input.media_type, "audio/wav");
+    assert.equal(received_input.filename, "voice.wav");
+    assert.match(received_input.data_url, /^data:audio\/wav;base64,/);
+    assert.deepEqual(result.data, {
+      text: "transcript",
+      segments: [{ text: "first", startSecond: 0, endSecond: 1.25 }],
+      language: "en",
+      durationInSeconds: 1.25,
+    });
+  } finally {
+    await fs.rm(root_path, { recursive: true, force: true });
+  }
+});
+
+test("sound.tts 使用默认参数并返回 AI SDK UIMessage", async () => {
+  let received_input;
+  const message = create_tts_message();
+  const plugin = new SoundPlugin({
+    default_tts_model: "fed-tts",
+    language: "zh",
+    voice: "alloy",
+    format: "mp3",
+    asr: async () => ({ text: "ok" }),
+    tts: async (input) => {
+      received_input = input;
+      return message;
+    },
+  });
+
+  const result = await run_action(
+    plugin,
+    "tts",
+    create_context(process.cwd()),
+    { text: " 你好 " },
+  );
+  assert.equal(result.success, true);
+  assert.deepEqual(received_input, {
+    model: "fed-tts",
+    text: "你好",
+    language: "zh",
+    voice: "alloy",
+    format: "mp3",
+  });
+  assert.deepEqual(result.data, message);
+});
+
+test("sound action 不会隐式选择模型或接受非 UIMessage TTS 结果", async () => {
+  const plugin = new SoundPlugin({
+    asr: async () => ({ text: "ok" }),
+    tts: async () => ({ url: "https://example.com/speech.mp3" }),
+  });
+  const context = create_context(process.cwd());
+
+  const asr_result = await run_action(plugin, "asr", context, {
+    url: "https://example.com/input.mp3",
+  });
+  assert.equal(asr_result.success, false);
+  assert.match(asr_result.error, /requires a model id/);
+
+  const tts_result = await run_action(plugin, "tts", context, {
+    model: "fed-tts",
+    text: "hello",
+  });
+  assert.equal(tts_result.success, false);
+  assert.match(tts_result.error, /must return an AI SDK UIMessage/);
+});
+
+test("sound.asr 只接受一种音频来源", async () => {
+  const plugin = new SoundPlugin({
+    asr: async () => ({ text: "ok" }),
+    tts: async () => create_tts_message(),
+  });
+  const result = await run_action(plugin, "asr", create_context(process.cwd()), {
+    model: "fed-asr",
+    url: "https://example.com/input.mp3",
+    data_url: "data:audio/mpeg;base64,dGVzdA==",
+  });
+  assert.equal(result.success, false);
+  assert.match(result.error, /requires exactly one/);
+});
+
+test("sound.tts 要求 UIMessage 包含音频 file part", async () => {
+  const plugin = new SoundPlugin({
+    asr: async () => ({ text: "ok" }),
+    tts: async () => ({
+      id: "sound:text-only",
+      role: "assistant",
+      parts: [{ type: "text", text: "not audio" }],
+    }),
+  });
+  const result = await run_action(plugin, "tts", create_context(process.cwd()), {
+    model: "fed-tts",
+    text: "hello",
+  });
+  assert.equal(result.success, false);
+  assert.match(result.error, /must contain an audio file part/);
+});
+
+test("auto_asr 必须配置默认 ASR 模型", () => {
+  assert.throws(
+    () => new SoundPlugin({
+      auto_asr: true,
+      asr: async () => ({ text: "ok" }),
+      tts: async () => create_tts_message(),
+    }),
+    /auto_asr requires default_asr_model/,
+  );
+});
+
+test("auto_asr 把 chat 语音附件转写追加到正文", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-sound-auto-"));
+  const audio_path = path.join(root_path, "message.ogg");
+  await fs.writeFile(audio_path, Buffer.from("voice"));
+  const plugin = new SoundPlugin({
+    auto_asr: true,
+    default_asr_model: "fed-asr",
+    asr: async () => ({ text: "hello <world>" }),
+    tts: async () => create_tts_message(),
+  });
+
+  try {
+    const hook = Object.values(plugin.hooks.pipeline)[0][0];
+    const result = await hook({
+      context: create_context(root_path),
+      value: {
+        channel: "telegram",
+        chatId: "chat-1",
+        rootPath: root_path,
+        bodyText: "original",
+        attachments: [
+          {
+            channel: "telegram",
+            kind: "voice",
+            path: audio_path,
+            fileName: "message.ogg",
+            contentType: "audio/ogg",
+          },
+        ],
+      },
+    });
+    assert.equal(
+      result.bodyText,
+      "original\n\n<voice src=\"message.ogg\">hello &lt;world&gt;</voice>",
+    );
+  } finally {
+    await fs.rm(root_path, { recursive: true, force: true });
+  }
+});

package/scripts/web-plugin.test.mjs

@@ -0,0 +1,85 @@
+/**
+ * WebPlugin 纯提示 install action 回归测试。
+ *
+ * 关键点（中文）
+ * - install action 只返回 Agent 操作提示，不能执行命令或写入文件。
+ * - Skill 安装必须委托给 skill.install，避免 WebPlugin 重复维护扫描根规则。
+ * - agent-browser CLI 提示需要根据 user / project 作用域生成。
+ */
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { WebPlugin } from "../bin/index.js";
+
+test("WebPlugin 仅暴露纯提示 install action", () => {
+  const plugin = new WebPlugin();
+
+  assert.deepEqual(Object.keys(plugin.actions), ["install"]);
+  assert.equal(plugin.setup, undefined);
+  assert.match(plugin.actions.install.description, /does not install anything/);
+});
+
+test("install action 默认返回 web-access 安装工作流", async () => {
+  const project_root = path.resolve("fixtures/web-install-instructions");
+  const plugin = new WebPlugin();
+
+  assert.equal(fs.existsSync(project_root), false);
+
+  const result = await plugin.actions.install.execute({
+    context: { rootPath: project_root },
+    input: {},
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(result.data.kind, "instructions");
+  assert.equal(result.data.target, "web-access");
+  assert.equal(result.data.scope, "user");
+  assert.match(result.data.prompt, /plugin: "skill", action: "install"/);
+  assert.match(result.data.prompt, /spec: "web-access"/);
+  assert.match(result.data.prompt, /has not executed commands/);
+  assert.match(result.data.prompt, /action: "list"/);
+  assert.equal(fs.existsSync(project_root), false);
+});
+
+test("agent-browser project 提示包含 Skill 与项目 CLI 安装步骤", async () => {
+  const plugin = new WebPlugin();
+  const result = await plugin.actions.install.execute({
+    context: { rootPath: path.resolve("fixtures/web-agent-browser-instructions") },
+    input: { target: "agent-browser", scope: "project" },
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(result.data.target, "agent-browser");
+  assert.equal(result.data.scope, "project");
+  assert.match(result.data.prompt, /spec: "agent-browser"/);
+  assert.match(result.data.prompt, /pnpm add -D agent-browser/);
+  assert.match(result.data.prompt, /npm install -D agent-browser/);
+  assert.match(result.data.prompt, /yarn add -D agent-browser/);
+  assert.match(result.data.prompt, /skill\.lookup/);
+});
+
+test("all 目标返回两个 Skill 和用户级 CLI 提示", async () => {
+  const plugin = new WebPlugin();
+  const result = await plugin.actions.install.execute({
+    context: { rootPath: path.resolve("fixtures/web-all-instructions") },
+    input: { target: "all", scope: "user" },
+  });
+
+  assert.equal(result.success, true);
+  assert.match(result.data.prompt, /spec: "web-access"/);
+  assert.match(result.data.prompt, /spec: "agent-browser"/);
+  assert.match(result.data.prompt, /npm install -g agent-browser/);
+  assert.match(result.data.prompt, /no files were changed|changed files/i);
+});
+
+test("system prompt 明确 install 只返回提示", () => {
+  const plugin = new WebPlugin();
+  const prompt = plugin.system({ rootPath: process.cwd() });
+
+  assert.match(prompt, /return installation instructions/);
+  assert.match(prompt, /never executes commands/);
+  assert.match(prompt, /skill\.install/);
+  assert.match(prompt, /skill\.list/);
+});

package/src/BuiltinPlugins.ts

@@ -16,11 +16,9 @@ import { ContactPlugin } from "@/contact/ContactPlugin.js";
 import { TaskPlugin } from "@/task/TaskPlugin.js";
 import { MemoryPlugin } from "@/memory/MemoryPlugin.js";
 import { ImagePlugin } from "@/image/ImagePlugin.js";
-import { AsrPlugin } from "@/asr/Plugin.js";
-import { TtsPlugin } from "@/tts/Plugin.js";
+import { SoundPlugin } from "@/sound/Plugin.js";
 import type { ImagePluginOptions } from "@/image/types/ImagePlugin.js";
-import type { AsrPluginOptions } from "@/asr/types/AsrPlugin.js";
-import type { TtsPluginOptions } from "@/tts/types/TtsPlugin.js";
+import type { SoundPluginOptions } from "@/sound/types/SoundPlugin.js";
 import type { TaskPluginOptions } from "@/task/types/TaskPluginOptions.js";
 import type { MemoryPluginOptions } from "@/memory/types/Memory.js";
 
@@ -32,7 +30,7 @@ export type BuiltinPluginClass<T extends BasePlugin = BasePlugin> = new () => T;
 /**
  * 可直接无参创建的内建 plugin classes。
  *
- * 关键点（中文）：image / asr / tts 需要宿主注入 City AI 能力，不能放入无参 class 列表。
+ * 关键点（中文）：image / sound 需要宿主注入 City AI 能力，不能放入无参 class 列表。
  */
 export const BUILTIN_PLUGIN_CLASSES: BuiltinPluginClass[] = [
   SkillPlugin,
@@ -54,14 +52,9 @@ export interface BuiltinPluginOptions {
   image?: ImagePluginOptions;
 
   /**
-   * 语音转写 plugin 的 City AI 能力注入。
+   * 统一语音 plugin 的 FED 模型目录、ASR 与 TTS 能力注入。
    */
-  asr?: AsrPluginOptions;
-
-  /**
-   * 文本转语音 plugin 的 City AI 能力注入。
-   */
-  tts?: TtsPluginOptions;
+  sound?: SoundPluginOptions;
 
   /**
    * task plugin 的定时任务运行参数。
@@ -89,11 +82,8 @@ export function createBuiltinPlugins(options: BuiltinPluginOptions = {}): BasePl
   if (options.image?.image_create && options.image?.image_result) {
     plugins.push(new ImagePlugin(options.image));
   }
-  if (options.asr?.asr) {
-    plugins.push(new AsrPlugin(options.asr));
-  }
-  if (options.tts?.tts) {
-    plugins.push(new TtsPlugin(options.tts));
+  if (options.sound) {
+    plugins.push(new SoundPlugin(options.sound));
   }
   return plugins;
 }