transcribeElevenLabsAudio,

} from "./media-understanding-provider.js";

function requireFirstFetchCall(fetchMock: ReturnType<typeof vi.fn>): [string, RequestInit] {

const [call] = fetchMock.mock.calls;

if (!call) {

throw new Error("expected ElevenLabs media fetch call");

}

return call as [string, RequestInit];

}

describe("elevenLabsMediaUnderstandingProvider", () => {

let ssrfMock: { mockRestore: () => void } | undefined;

expect(result).toEqual({ text: "hello", model: "scribe_v2" });

expect(fetchMock).toHaveBeenCalledTimes(1);

expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.elevenlabs.io/v1/speech-to-text");

const init = fetchMock.mock.calls[0]?.[1] as RequestInit;

const [url, init] = requireFirstFetchCall(fetchMock);

expect(url).toBe("https://api.elevenlabs.io/v1/speech-to-text");

expect(init.method).toBe("POST");

const headers = new Headers(init.headers);

expect(headers.get("xi-api-key")).toBe("eleven-key");

}

function getHeadersFromFirstFetchCall(fetchMock: ReturnType<typeof vi.fn>): Headers {

const init = fetchMock.mock.calls[0]?.[1] as RequestInit | undefined;

return new Headers(init?.headers);

return new Headers(getInitFromFirstFetchCall(fetchMock).headers);

}

function requireFirstFetchCall(fetchMock: ReturnType<typeof vi.fn>): [string | URL, RequestInit] {

const [call] = fetchMock.mock.calls;

if (!call) {

throw new Error("expected ElevenLabs fetch call");

}

return call as [string | URL, RequestInit];

}

function getInitFromFirstFetchCall(fetchMock: ReturnType<typeof vi.fn>): RequestInit {

return (fetchMock.mock.calls[0] as unknown[])[1] as RequestInit;

const [, init] = requireFirstFetchCall(fetchMock);

return init;

}

function getUrlFromFirstFetchCall(fetchMock: ReturnType<typeof vi.fn>): URL {

const url = fetchMock.mock.calls[0]?.[0] as string | URL;

const [url] = requireFirstFetchCall(fetchMock);

return new URL(url.toString());

}

);

}

function requireFetchGuardCall(callNumber: number): { init?: RequestInit; url?: string } {

const call = fetchGuardMock.mock.calls[callNumber - 1];

if (!call) {

throw new Error(`expected fal fetch guard call ${callNumber}`);

}

const [request] = call;

if (!request || typeof request !== "object" || Array.isArray(request)) {

throw new Error(`expected fal fetch guard request ${callNumber}`);

}

return request as { init?: RequestInit; url?: string };

}

function getSubmitBody(): Record<string, unknown> {

return JSON.parse(String(fetchGuardMock.mock.calls[0]?.[0]?.init?.body ?? "{}")) as Record<

string,

unknown

>;

const body = requireFetchGuardCall(1).init?.body;

if (typeof body !== "string") {

throw new Error("expected fal submit JSON body");

}

return JSON.parse(body) as Record<string, unknown>;

}

function fetchGuardUrl(callNumber: number): string | undefined {

return (fetchGuardMock.mock.calls[callNumber - 1]?.[0] as { url?: string } | undefined)?.url;

return requireFetchGuardCall(callNumber).url;

}

afterEach(() => {

});

expect(fetchGuardUrl(1)).toBe("https://queue.fal.run/fal-ai/minimax/video-01-live");

const submitBody = JSON.parse(

String(fetchGuardMock.mock.calls[0]?.[0]?.init?.body ?? "{}"),

) as Record<string, unknown>;

const submitBody = getSubmitBody();

expect(submitBody).toEqual({

prompt: "A spaceship emerges from the clouds",

});

expect(init?.method).toBe("POST");

}

function requireFirstPostJsonRequest(mock: ReturnType<typeof vi.fn>): {

body?: unknown;

ssrfPolicy?: unknown;

url?: string;

} {

const [call] = mock.mock.calls;

if (!call) {

throw new Error("expected MiniMax image request");

}

const [request] = call;

if (!request || typeof request !== "object" || Array.isArray(request)) {

throw new Error("expected MiniMax image request");

}

return request as { body?: unknown; url?: string };

}

it("generates PNG buffers through the shared provider HTTP path", async () => {

mockMinimaxApiKey();

const fetchMock = mockSuccessfulMinimaxImageResponse();

});

expect(postJsonRequest).toHaveBeenCalledOnce();

const request = postJsonRequest.mock.calls[0]?.[0];

if (!request) {

throw new Error("expected MiniMax image request");

}

const request = requireFirstPostJsonRequest(postJsonRequest);

expect(request.url).toBe("https://api.minimax.io/v1/image_generation");

expect(request.body).toEqual({

model: "image-01",

fetchWithSsrFGuard: fetchWithSsrFGuardMock,

}));

function requireFirstGuardedFetchCall(): unknown {

const [call] = fetchWithSsrFGuardMock.mock.calls;

if (!call) {

throw new Error("expected Volcengine guarded fetch call");

}

return call[0];

}

function makeProviderConfig(overrides?: Record<string, unknown>) {

return {

apiKey: "test-api-key",

expect(result.fileExtension).toBe(".opus");

expect(result.voiceCompatible).toBe(true);

const call = fetchWithSsrFGuardMock.mock.calls[0]?.[0];

const call = requireFirstGuardedFetchCall();

expect(call).toEqual({

url: "https://voice.ap-southeast-1.bytepluses.com/api/v3/tts/unidirectional",

init: {