Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
const test = require("node:test");
const assert = require("node:assert/strict");
const load = () => import("../../src/helpers/realtimeTokenProviders.js");
const jsonResponse = (status, body) => ({
ok: status >= 200 && status < 300,
status,
json: async () => body,
});
const deps = (overrides = {}) => ({
environmentManager: {
getOpenAIKey: () => "sk-openai",
getTinfoilKey: () => "tk-tinfoil",
getDeepgramKey: () => "dg-key",
getAssemblyAIKey: () => "aai-key",
getGeminiKey: () => "gm-key",
...overrides.environmentManager,
},
proxyFetch: overrides.proxyFetch || (async () => jsonResponse(200, { token: "aai-token" })),
postServerToken: overrides.postServerToken || (async () => ({ token: "server-token" })),
mintCortiToken: overrides.mintCortiToken || (async () => ({ token: "corti-token" })),
});
test("provider-less and unknown providers fail closed with the exact #1480 message", async () => {
const { fetchRealtimeTokenForProvider } = await load();
for (const provider of [undefined, "grok-realtime", "openai"]) {
await assert.rejects(
fetchRealtimeTokenForProvider(provider, deps(), { mode: "byok" }),
new Error(`Unsupported realtime token provider: ${provider}`)
);
}
});
test("openai byok returns the key; dual-stream duplicates it", async () => {
const { fetchRealtimeTokenForProvider } = await load();
assert.equal(
await fetchRealtimeTokenForProvider("openai-realtime", deps(), { mode: "byok" }),
"sk-openai"
);
assert.deepEqual(
await fetchRealtimeTokenForProvider(
"openai-realtime",
deps(),
{ mode: "byok" },
{ streams: 2 }
),
["sk-openai", "sk-openai"]
);
});
test("openai cloud mints per-stream client secrets and validates the dual pair", async () => {
const { fetchRealtimeTokenForProvider } = await load();
const calls = [];
const cloudDeps = deps({
postServerToken: async (path, body) => {
calls.push({ path, body });
return { clientSecret: "cs-single", clientSecrets: ["cs-a", "cs-b"] };
},
});
const options = { mode: "openwhispr", model: "gpt-4o-mini-transcribe", language: "en" };
assert.equal(
await fetchRealtimeTokenForProvider("openai-realtime", cloudDeps, options),
"cs-single"
);
assert.deepEqual(
await fetchRealtimeTokenForProvider("openai-realtime", cloudDeps, options, { streams: 2 }),
["cs-a", "cs-b"]
);
assert.deepEqual(calls[0], {
path: "/api/openai-realtime-token",
body: { model: "gpt-4o-mini-transcribe", language: "en", streams: 1 },
});
assert.equal(calls[1].body.streams, 2);
await assert.rejects(
fetchRealtimeTokenForProvider(
"openai-realtime",
deps({ postServerToken: async () => ({ clientSecrets: ["only-one"] }) }),
options,
{ streams: 2 }
),
/Expected two client secrets/
);
});
test("tinfoil missing key carries the NO_API code the renderer's fallback keys on", async () => {
const { fetchRealtimeTokenForProvider } = await load();
const noKey = deps({ environmentManager: { getTinfoilKey: () => "" } });
await assert.rejects(
fetchRealtimeTokenForProvider("tinfoil-realtime", noKey, { mode: "byok" }),
(err) => err.code === "NO_API"
);
});
test("assemblyai byok mints one live token per stream", async () => {
const { fetchRealtimeTokenForProvider } = await load();
let mints = 0;
const liveDeps = deps({
proxyFetch: async () => jsonResponse(200, { token: `aai-${++mints}` }),
});
assert.deepEqual(
await fetchRealtimeTokenForProvider(
"assemblyai-realtime",
liveDeps,
{ mode: "byok" },
{ streams: 2 }
),
["aai-1", "aai-2"]
);
});
test("deepgram byok duplicates the key; cloud mints per stream", async () => {
const { fetchRealtimeTokenForProvider } = await load();
assert.deepEqual(
await fetchRealtimeTokenForProvider(
"deepgram-realtime",
deps(),
{ mode: "byok" },
{ streams: 2 }
),
["dg-key", "dg-key"]
);
let mints = 0;
const cloudDeps = deps({ postServerToken: async () => ({ token: `dg-${++mints}` }) });
assert.deepEqual(
await fetchRealtimeTokenForProvider(
"deepgram-realtime",
cloudDeps,
{ mode: "openwhispr" },
{ streams: 2 }
),
["dg-1", "dg-2"]
);
});
test("gemini byok duplicates the raw key; cloud mints one token per stream", async () => {
const { fetchRealtimeTokenForProvider } = await load();
// The raw key opens the Live socket itself and survives any number of
// handshakes, so both streams share it.
assert.deepEqual(
await fetchRealtimeTokenForProvider(
"gemini-realtime",
deps(),
{ mode: "byok" },
{ streams: 2 }
),
["gm-key", "gm-key"]
);
// Managed tokens are minted with uses:1 — a shared token would be rejected
// at the second handshake with close code 1011.
let mints = 0;
const cloudDeps = deps({ postServerToken: async () => ({ token: `gm-${++mints}` }) });
assert.deepEqual(
await fetchRealtimeTokenForProvider(
"gemini-realtime",
cloudDeps,
{ mode: "openwhispr" },
{ streams: 2 }
),
["gm-1", "gm-2"]
);
await assert.rejects(
fetchRealtimeTokenForProvider("gemini-realtime", deps({ postServerToken: async () => ({}) }), {
mode: "openwhispr",
}),
/No Gemini token received/
);
});
test("corti mints one token and shares it across both streams", async () => {
const { fetchRealtimeTokenForProvider } = await load();
let mints = 0;
const cortiDeps = deps({ mintCortiToken: async () => ({ token: `corti-${++mints}` }) });
assert.deepEqual(
await fetchRealtimeTokenForProvider("corti-realtime", cortiDeps, {}, { streams: 2 }),
["corti-1", "corti-1"]
);
assert.equal(mints, 1);
});
test("missing byok keys throw configuration errors, not token errors", async () => {
const { fetchRealtimeTokenForProvider } = await load();
const empty = {
getOpenAIKey: () => "",
getDeepgramKey: () => "",
getAssemblyAIKey: () => "",
getGeminiKey: () => "",
};
for (const provider of [
"openai-realtime",
"deepgram-realtime",
"assemblyai-realtime",
"gemini-realtime",
]) {
await assert.rejects(
fetchRealtimeTokenForProvider(provider, deps({ environmentManager: empty }), {
mode: "byok",
}),
/key configured/
);
}
});
test("wire bodies: dictation posts language+streams; meetings post model+language+streams", async () => {
const { fetchRealtimeTokenForProvider } = await load();
const wire = [];
const cloudDeps = deps({
// `body = {}` mirrors ipcHandlers' postServerToken default, so an entry that
// posts no body at all is recorded as the `{}` it really sends.
postServerToken: async (path, body = {}) => {
// JSON.stringify drops undefined keys exactly like the real fetch does.
wire.push({ path, json: JSON.stringify(body) });
return { clientSecret: "cs-single", clientSecrets: ["cs-a", "cs-b"], token: "gm-token" };
},
});
// Dictation: ipcHandlers' connectDictationStreaming passes { mode, provider, language }
// (base ISO-639-1, undefined for Auto) and never a model — the server owns it (#2050).
await fetchRealtimeTokenForProvider("openai-realtime", cloudDeps, {
mode: "openwhispr",
language: "de",
});
await fetchRealtimeTokenForProvider("openai-realtime", cloudDeps, {
mode: "openwhispr",
language: undefined,
});
// Meeting with system audio.
await fetchRealtimeTokenForProvider(
"openai-realtime",
cloudDeps,
{ mode: "openwhispr", model: "gpt-4o-mini-transcribe", language: "en" },
{ streams: 2 }
);
// Meeting whose system audio is unsupported (connectRealtimeStreaming's single-stream
// branch) — still carries model+language; streams defaults to 1.
await fetchRealtimeTokenForProvider(
"openai-realtime",
cloudDeps,
{ mode: "openwhispr", model: "gpt-4o-mini-transcribe", language: undefined },
{ streams: 1 }
);
// Gemini's endpoint reads nothing from the request; it must post a bare body.
await fetchRealtimeTokenForProvider("gemini-realtime", cloudDeps, { mode: "openwhispr" });
assert.deepEqual(wire, [
{ path: "/api/openai-realtime-token", json: '{"language":"de","streams":1}' },
{ path: "/api/openai-realtime-token", json: '{"streams":1}' },
{
path: "/api/openai-realtime-token",
json: '{"model":"gpt-4o-mini-transcribe","language":"en","streams":2}',
},
{ path: "/api/openai-realtime-token", json: '{"model":"gpt-4o-mini-transcribe","streams":1}' },
{ path: "/api/gemini-live-token", json: "{}" },
]);
});
// A Cloud note recording whose token request is refused used to toast the API's
// bare "Invalid session" / "Not authenticated"; these codes let it offer sign-in (#2427).
const serverTokenPoster = async (overrides = {}) => {
const { createServerTokenPoster } = await load();
return createServerTokenPoster({
getApiUrl: () => "https://api.example",
getAuthHeader: async () => ({ Authorization: "Bearer stale" }),
proxyFetch: async () => jsonResponse(200, { clientSecret: "secret" }),
withPolicyHeaders: (headers) => headers,
classifyAndLog: () => ({ isNetworkError: false }),
...overrides,
});
};
test("server tokens: a code-less 401 is AUTH_EXPIRED and keeps the server's message", async () => {
const post = await serverTokenPoster({
proxyFetch: async () => jsonResponse(401, { error: "Invalid session" }),
});
await assert.rejects(post("/api/openai-realtime-token"), {
message: "Invalid session",
code: "AUTH_EXPIRED",
status: 401,
});
});
test("server tokens: a missing credential is AUTH_REQUIRED and never reaches the API", async () => {
let fetched = false;
const post = await serverTokenPoster({
getAuthHeader: async () => ({}),
proxyFetch: async () => {
fetched = true;
return jsonResponse(200, {});
},
});
await assert.rejects(post("/api/openai-realtime-token"), {
message: "Not authenticated",
code: "AUTH_REQUIRED",
});
assert.equal(fetched, false);
});
test("server tokens: codes the API sends are kept, and other refusals stay untagged", async () => {
const refuse = async (status, body) =>
(await serverTokenPoster({ proxyFetch: async () => jsonResponse(status, body) }))(
"/api/openai-realtime-token"
);
await assert.rejects(refuse(401, { error: "Session expired", code: "SESSION_REVOKED" }), {
code: "SESSION_REVOKED",
});
await assert.rejects(refuse(403, { error: "Blocked", code: "POLICY_BLOCKED" }), {
code: "POLICY_BLOCKED",
});
await assert.rejects(refuse(500, null), (error) => {
assert.equal(error.message, "Token request failed: 500");
assert.equal(error.code, undefined);
return true;
});
});
test("server tokens: a network failure is NETWORK_ERROR, not a sign-in prompt", async () => {
const post = await serverTokenPoster({
proxyFetch: async () => {
throw Object.assign(new Error("getaddrinfo ENOTFOUND"), { code: "ENOTFOUND" });
},
classifyAndLog: () => ({
isNetworkError: true,
code: "ENOTFOUND",
messageKey: "streaming.errors.cloudUnreachable.dnsBlocked",
}),
});
await assert.rejects(post("/api/openai-realtime-token"), {
code: "NETWORK_ERROR",
networkCode: "ENOTFOUND",
});
});
test("server tokens: a success posts the body with credential and policy headers", async () => {
const requests = [];
const post = await serverTokenPoster({
proxyFetch: async (url, init) => {
requests.push({ url, init });
return jsonResponse(200, { clientSecret: "secret" });
},
withPolicyHeaders: (headers) => ({ ...headers, "x-policy": "applied" }),
});
assert.deepEqual(await post("/api/openai-realtime-token", { streams: 1 }), {
clientSecret: "secret",
});
assert.equal(requests[0].url, "https://api.example/api/openai-realtime-token");
assert.equal(requests[0].init.headers.Authorization, "Bearer stale");
assert.equal(requests[0].init.headers["x-policy"], "applied");
assert.equal(requests[0].init.body, '{"streams":1}');
});
test("server tokens: only session refusals count as sign-in refusals", async () => {
const { isSignInRefusal } = await load();
const refusal = async (overrides) => {
try {
await (
await serverTokenPoster(overrides)
)("/api/openai-realtime-token");
} catch (error) {
return error;
}
assert.fail("expected the token request to be refused");
};
assert.equal(
isSignInRefusal(await refusal({ proxyFetch: async () => jsonResponse(401, {}) })),
true
);
assert.equal(isSignInRefusal(await refusal({ getAuthHeader: async () => ({}) })), true);
assert.equal(
isSignInRefusal(
await refusal({ proxyFetch: async () => jsonResponse(403, { code: "POLICY_BLOCKED" }) })
),
false
);
assert.equal(
isSignInRefusal(await refusal({ proxyFetch: async () => jsonResponse(500, null) })),
false
);
});