test(media): dedupe auto-audio fixture wiring

src/media-understanding/runner.auto-audio.test.ts

@@ -11,8 +11,13 @@ import {
   runCapability,
 } from "./runner.js";
 
-describe("runCapability auto audio entries", () => {
+async function withAudioFixture(
-  it("uses provider keys to auto-enable audio transcription", async () => {
+  run: (params: {
+    ctx: MsgContext;
+    media: ReturnType<typeof normalizeMediaAttachments>;
+    cache: ReturnType<typeof createMediaAttachmentCache>;
+  }) => Promise<void>,
+) {
   const originalPath = process.env.PATH;
   process.env.PATH = "/usr/bin:/bin";
   const tmpPath = path.join(os.tmpdir(), `openclaw-auto-audio-${Date.now()}.wav`);
@@ -21,19 +26,29 @@ describe("runCapability auto audio entries", () => {
   const media = normalizeMediaAttachments(ctx);
   const cache = createMediaAttachmentCache(media);
 
-    let seenModel: string | undefined;
+  try {
-    const providerRegistry = buildProviderRegistry({
+    await run({ ctx, media, cache });
+  } finally {
+    process.env.PATH = originalPath;
+    await cache.cleanup();
+    await fs.unlink(tmpPath).catch(() => {});
+  }
+}
+
+function createOpenAiAudioProvider(
+  transcribeAudio: (req: { model?: string }) => Promise<{ text: string; model: string }>,
+) {
+  return buildProviderRegistry({
     openai: {
       id: "openai",
       capabilities: ["audio"],
-        transcribeAudio: async (req) => {
+      transcribeAudio,
-          seenModel = req.model;
-          return { text: "ok", model: req.model };
-        },
     },
   });
+}
 
-    const cfg = {
+function createOpenAiAudioCfg(extra?: Partial<OpenClawConfig>): OpenClawConfig {
+  return {
     models: {
       providers: {
         openai: {
@@ -42,9 +57,20 @@ describe("runCapability auto audio entries", () => {
         },
       },
     },
+    ...extra,
   } as unknown as OpenClawConfig;
+}
+
+describe("runCapability auto audio entries", () => {
+  it("uses provider keys to auto-enable audio transcription", async () => {
+    await withAudioFixture(async ({ ctx, media, cache }) => {
+      let seenModel: string | undefined;
+      const providerRegistry = createOpenAiAudioProvider(async (req) => {
+        seenModel = req.model;
+        return { text: "ok", model: req.model ?? "unknown" };
+      });
+      const cfg = createOpenAiAudioCfg();
 
-    try {
       const result = await runCapability({
         capability: "audio",
         cfg,
@@ -56,39 +82,16 @@ describe("runCapability auto audio entries", () => {
       expect(result.outputs[0]?.text).toBe("ok");
       expect(seenModel).toBe("gpt-4o-mini-transcribe");
       expect(result.decision.outcome).toBe("success");
-    } finally {
+    });
-      process.env.PATH = originalPath;
-      await cache.cleanup();
-      await fs.unlink(tmpPath).catch(() => {});
-    }
   });
 
   it("skips auto audio when disabled", async () => {
-    const originalPath = process.env.PATH;
+    await withAudioFixture(async ({ ctx, media, cache }) => {
-    process.env.PATH = "/usr/bin:/bin";
+      const providerRegistry = createOpenAiAudioProvider(async () => ({
-    const tmpPath = path.join(os.tmpdir(), `openclaw-auto-audio-${Date.now()}.wav`);
+        text: "ok",
-    await fs.writeFile(tmpPath, Buffer.from("RIFF"));
+        model: "whisper-1",
-    const ctx: MsgContext = { MediaPath: tmpPath, MediaType: "audio/wav" };
+      }));
-    const media = normalizeMediaAttachments(ctx);
+      const cfg = createOpenAiAudioCfg({
-    const cache = createMediaAttachmentCache(media);
-
-    const providerRegistry = buildProviderRegistry({
-      openai: {
-        id: "openai",
-        capabilities: ["audio"],
-        transcribeAudio: async () => ({ text: "ok", model: "whisper-1" }),
-      },
-    });
-
-    const cfg = {
-      models: {
-        providers: {
-          openai: {
-            apiKey: "test-key",
-            models: [],
-          },
-        },
-      },
         tools: {
           media: {
             audio: {
@@ -96,9 +99,8 @@ describe("runCapability auto audio entries", () => {
             },
           },
         },
-    } as unknown as OpenClawConfig;
+      });
 
-    try {
       const result = await runCapability({
         capability: "audio",
         cfg,
@@ -109,10 +111,37 @@ describe("runCapability auto audio entries", () => {
       });
       expect(result.outputs).toHaveLength(0);
       expect(result.decision.outcome).toBe("disabled");
-    } finally {
+    });
-      process.env.PATH = originalPath;
+  });
-      await cache.cleanup();
+
-      await fs.unlink(tmpPath).catch(() => {});
+  it("prefers explicitly configured audio model entries", async () => {
-    }
+    await withAudioFixture(async ({ ctx, media, cache }) => {
+      let seenModel: string | undefined;
+      const providerRegistry = createOpenAiAudioProvider(async (req) => {
+        seenModel = req.model;
+        return { text: "ok", model: req.model ?? "unknown" };
+      });
+      const cfg = createOpenAiAudioCfg({
+        tools: {
+          media: {
+            audio: {
+              models: [{ provider: "openai", model: "whisper-1" }],
+            },
+          },
+        },
+      });
+
+      const result = await runCapability({
+        capability: "audio",
+        cfg,
+        ctx,
+        attachments: cache,
+        media,
+        providerRegistry,
+      });
+
+      expect(result.outputs[0]?.text).toBe("ok");
+      expect(seenModel).toBe("whisper-1");
+    });
   });
 });