import { describe, expect, it, vi } from "vitest";

import type { OpenClawConfig } from "../config/types.js";

import { withEnvAsync } from "../test-utils/env.js";

import { runCapability } from "./runner.js";

import { clearMediaUnderstandingBinaryCacheForTests, runCapability } from "./runner.js";

import { withAudioFixture } from "./runner.test-utils.js";

import type { AudioTranscriptionRequest, MediaUnderstandingProvider } from "./types.js";

} as unknown as OpenClawConfig;

}

async function createMockExecutable(dir: string, name: string) {

const executablePath = path.join(dir, name);

await fs.writeFile(executablePath, "#!/bin/sh\necho mocked-local-whisper\n", { mode: 0o755 });

return executablePath;

}

async function runAutoAudioCase(params: {

transcribeAudio: (req: AudioTranscriptionRequest) => Promise<{ text: string; model: string }>;

cfgExtra?: Partial<OpenClawConfig>;

expect(result.decision.outcome).toBe("success");

});

it("prefers provider keys over auto-detected local whisper", async () => {

const binDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-auto-audio-bin-"));

try {

await createMockExecutable(binDir, "whisper");

clearMediaUnderstandingBinaryCacheForTests();

let seenModel: string | undefined;

const result = await withEnvAsync(

{

PATH: binDir,

SHERPA_ONNX_MODEL_DIR: undefined,

WHISPER_CPP_MODEL: undefined,

GEMINI_API_KEY: undefined,

},

async () =>

await runAutoAudioCase({

transcribeAudio: async (req) => {

seenModel = req.model;

return { text: "provider transcription", model: req.model ?? "unknown" };

},

}),

);

expect(result.outputs[0]?.provider).toBe("openai");

expect(result.outputs[0]?.text).toBe("provider transcription");

expect(seenModel).toBe("gpt-4o-transcribe");

} finally {

clearMediaUnderstandingBinaryCacheForTests();

await fs.rm(binDir, { recursive: true, force: true });

}

});

it("skips auto audio when disabled", async () => {

const result = await runAutoAudioCase({

transcribeAudio: async () => ({