Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

11.6 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");

// Exhaustive settings-state × context matrix for dictation/notes realtime STT:
// which provider each state resolves to, the FULL session options object it
// sends over IPC (presence and absence), and the cross-boundary closure that
// every emittable provider id is accepted on the main-process side. #1624
// shipped because no test looked at the whole renderer→main contract: the
// openai-realtime path never sent `provider` and the token allowlist rejected
// undefined, while every per-module test stayed green.

const loadRouting = () => import("../../src/helpers/dictationStreamingRouting.js");
const loadTokens = () => import("../../src/helpers/realtimeTokenProviders.js");
const loadMeeting = () => import("../../src/helpers/meetingStreamingProviders.js");

// Keys of audioManager's STREAMING_PROVIDERS channel-binding table. audioManager
// imports window APIs so it can't load under node:test; this list is the
// renderer-side contract the resolver must stay within.
const RENDERER_STREAMING_PROVIDERS = [
  "deepgram",
  "assemblyai",
  "openai-realtime",
  "gemini",
  "corti",
  "tinfoil-realtime",
];

// Providers that share the dictation-realtime-* IPC channels and therefore
// need a fetchRealtimeToken entry under exactly their renderer name.
const SHARED_CHANNEL_PROVIDERS = ["openai-realtime", "tinfoil-realtime"];

const SETTINGS_DEFAULTS = {
  cloudTranscriptionProvider: "openai",
  cloudTranscriptionModel: "gpt-4o-mini-transcribe",
  cloudTranscriptionMode: "openwhispr",
  cortiEnvironment: undefined,
  cortiTenant: undefined,
};

const settingsWith = (overrides) => ({ ...SETTINGS_DEFAULTS, ...overrides });

// [description, { settings, context, sttConfig }, expected provider name]
const RESOLUTION_MATRIX = [
  ["default config (the #1624 repro) resolves to openai-realtime", {}, "openai-realtime"],
  [
    "gpt-4o-transcribe also resolves to openai-realtime",
    { settings: settingsWith({ cloudTranscriptionModel: "gpt-4o-transcribe" }) },
    "openai-realtime",
  ],
  [
    "tinfoil provider wins regardless of model",
    { settings: settingsWith({ cloudTranscriptionProvider: "tinfoil" }) },
    "tinfoil-realtime",
  ],
  [
    "corti byok streams over corti's own channels",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "corti",
        cloudTranscriptionMode: "byok",
      }),
    },
    "corti",
  ],
  [
    "corti on openwhispr cloud is not corti streaming; realtime model still wins",
    { settings: settingsWith({ cloudTranscriptionProvider: "corti" }) },
    "openai-realtime",
  ],
  [
    "gemini's live model routes to its own channels",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "gemini",
        cloudTranscriptionModel: "gemini-3.5-transcribe-live",
      }),
    },
    "gemini",
  ],
  [
    "gemini's batch model keeps the dictation default (HTTP, not streaming)",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "gemini",
        cloudTranscriptionModel: "gemini-3.5-transcribe",
      }),
    },
    "openai-realtime",
  ],
  [
    "deepgram byok streams over deepgram's own channels",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "deepgram",
        cloudTranscriptionModel: "nova-3",
        cloudTranscriptionMode: "byok",
      }),
    },
    "deepgram",
  ],
  [
    "assemblyai byok streams over assemblyai's own channels",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "assemblyai",
        cloudTranscriptionModel: "universal-streaming-english",
        cloudTranscriptionMode: "byok",
      }),
    },
    "assemblyai",
  ],
  [
    "a stale OpenAI realtime model cannot hijack a byok streaming-only provider",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "deepgram",
        cloudTranscriptionModel: "gpt-4o-mini-transcribe",
        cloudTranscriptionMode: "byok",
      }),
    },
    "deepgram",
  ],
  [
    "deepgram on openwhispr cloud stays on the managed path",
    { settings: settingsWith({ cloudTranscriptionProvider: "deepgram" }) },
    "openai-realtime",
  ],
  [
    "batch model in notes context defaults to deepgram",
    { settings: settingsWith({ cloudTranscriptionModel: "whisper-1" }), context: "notes" },
    "deepgram",
  ],
  [
    "batch model in dictation context defaults to openai-realtime",
    { settings: settingsWith({ cloudTranscriptionModel: "whisper-1" }) },
    "openai-realtime",
  ],
  [
    "server sttConfig picks the streaming provider for batch models",
    {
      settings: settingsWith({ cloudTranscriptionModel: "whisper-1" }),
      sttConfig: { streamingProvider: "assemblyai" },
    },
    "assemblyai",
  ],
];

for (const [
  name,
  { settings = settingsWith({}), context = "dictation", sttConfig = null },
  expected,
] of RESOLUTION_MATRIX) {
  test(`resolution: ${name}`, async () => {
    const { resolveStreamingProviderName } = await loadRouting();
    assert.equal(resolveStreamingProviderName({ settings, context, sttConfig }), expected);
  });
}

test("resolution: every matrix outcome is a renderer channel binding", async () => {
  const { resolveStreamingProviderName } = await loadRouting();
  for (const [
    ,
    { settings = settingsWith({}), context = "dictation", sttConfig = null },
  ] of RESOLUTION_MATRIX) {
    const name = resolveStreamingProviderName({ settings, context, sttConfig });
    assert.ok(
      RENDERER_STREAMING_PROVIDERS.includes(name),
      `resolver emitted "${name}", which has no STREAMING_PROVIDERS entry`
    );
  }
});

const GEMINI_LIVE = {
  cloudTranscriptionProvider: "gemini",
  cloudTranscriptionModel: "gemini-3.5-transcribe-live",
};

// [description, { settings, sttConfig }, resolved provider, counts toward Cloud usage]
const METERING_MATRIX = [
  ["managed openai-realtime", {}, "openai-realtime", true],
  [
    "openai-realtime on the user's key",
    { settings: settingsWith({ cloudTranscriptionMode: "byok" }) },
    "openai-realtime",
    false,
  ],
  ["managed gemini live", { settings: settingsWith(GEMINI_LIVE) }, "gemini", true],
  [
    "gemini live on the user's key (#2558)",
    { settings: settingsWith({ ...GEMINI_LIVE, cloudTranscriptionMode: "byok" }) },
    "gemini",
    false,
  ],
  [
    "tinfoil left selected in Cloud mode still streams on the user's key",
    { settings: settingsWith({ cloudTranscriptionProvider: "tinfoil" }) },
    "tinfoil-realtime",
    false,
  ],
  [
    "corti on the user's credentials",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "corti",
        cloudTranscriptionMode: "byok",
      }),
    },
    "corti",
    false,
  ],
  [
    "deepgram on the user's key",
    {
      settings: settingsWith({
        cloudTranscriptionProvider: "deepgram",
        cloudTranscriptionModel: "nova-3",
        cloudTranscriptionMode: "byok",
      }),
    },
    "deepgram",
    false,
  ],
  [
    "managed orukeet",
    { sttConfig: { dictation: { mode: "streaming" }, streamingProvider: "orukeet" } },
    "orukeet",
    true,
  ],
  [
    "self-hosted orukeet",
    {
      settings: settingsWith({
        cloudTranscriptionMode: "byok",
        cloudTranscriptionProvider: "custom",
        cloudTranscriptionModel: "orukeet-v0.1.0",
        cloudTranscriptionBaseUrl: "http://localhost:9000",
      }),
    },
    "orukeet",
    false,
  ],
];

for (const [
  name,
  { settings = settingsWith({}), sttConfig = null },
  provider,
  metered,
] of METERING_MATRIX) {
  test(`metering: ${name}`, async () => {
    const { resolveStreamingProviderName, buildStreamingSessionOptions, isCloudMeteredStream } =
      await loadRouting();
    const providerName = resolveStreamingProviderName({
      settings,
      context: "dictation",
      sttConfig,
    });
    assert.equal(providerName, provider);
    const options = buildStreamingSessionOptions({ providerName, settings, language: "auto" });
    assert.equal(isCloudMeteredStream(options), metered);
  });
}

test("options: openai-realtime sends provider explicitly and no preview (#1624)", async () => {
  const { buildStreamingSessionOptions } = await loadRouting();
  const options = buildStreamingSessionOptions({
    providerName: "openai-realtime",
    settings: settingsWith({}),
    language: "en",
    keyterms: ["OpenWhispr"],
  });
  assert.deepEqual(options, {
    provider: "openai-realtime",
    sampleRate: 16000,
    language: "en",
    keyterms: ["OpenWhispr"],
    model: "gpt-4o-mini-transcribe",
    mode: "openwhispr",
    environment: undefined,
    tenant: undefined,
  });
});

test("options: tinfoil-realtime keeps its always-on preview (#1120)", async () => {
  const { buildStreamingSessionOptions } = await loadRouting();
  const options = buildStreamingSessionOptions({
    providerName: "tinfoil-realtime",
    settings: settingsWith({
      cloudTranscriptionProvider: "tinfoil",
      cloudTranscriptionModel: "kyutai-stt",
      cloudTranscriptionMode: "byok",
    }),
    language: "auto",
    keyterms: [],
  });
  assert.deepEqual(options, {
    provider: "tinfoil-realtime",
    sampleRate: 16000,
    language: undefined,
    keyterms: [],
    model: "kyutai-stt",
    mode: "byok",
    environment: undefined,
    tenant: undefined,
    preview: true,
  });
});

test("tinfoil realtime does not request the main-side preview for a voice-assistant recording", async () => {
  const { buildStreamingSessionOptions } = await loadRouting();
  const options = buildStreamingSessionOptions({
    providerName: "tinfoil-realtime",
    settings: { cloudTranscriptionModel: "m", cloudTranscriptionMode: "byok" },
    language: "en",
    keyterms: [],
    voiceAgentRequested: true,
  });
  assert.equal(options.preview, undefined);
});

test("options: corti carries environment and tenant; auto language is omitted", async () => {
  const { buildStreamingSessionOptions } = await loadRouting();
  const options = buildStreamingSessionOptions({
    providerName: "corti",
    settings: settingsWith({
      cloudTranscriptionProvider: "corti",
      cloudTranscriptionMode: "byok",
      cloudTranscriptionModel: "corti-stt",
      cortiEnvironment: "eu",
      cortiTenant: "acme",
    }),
    language: "auto",
    keyterms: ["hba1c"],
  });
  assert.equal(options.provider, "corti");
  assert.equal(options.mode, "byok");
  assert.equal(options.environment, "eu");
  assert.equal(options.tenant, "acme");
  assert.equal(options.language, undefined);
});

test("options: provider is stamped for every renderer channel binding", async () => {
  const { buildStreamingSessionOptions } = await loadRouting();
  for (const providerName of RENDERER_STREAMING_PROVIDERS) {
    const options = buildStreamingSessionOptions({
      providerName,
      settings: settingsWith({}),
      language: "en",
      keyterms: [],
    });
    assert.equal(options.provider, providerName);
  }
});

test("closure: shared-channel dictation providers have token entries under their own names", async () => {
  const { REALTIME_TOKEN_PROVIDERS } = await loadTokens();
  for (const provider of SHARED_CHANNEL_PROVIDERS) {
    assert.equal(
      typeof REALTIME_TOKEN_PROVIDERS[provider],
      "function",
      `${provider} reaches fetchRealtimeToken but has no token entry`
    );
  }
});

test("closure: every allowed meeting provider has a token entry", async () => {
  const { REALTIME_TOKEN_PROVIDERS } = await loadTokens();
  const { ALLOWED_MEETING_PROVIDERS } = await loadMeeting();
  for (const provider of ALLOWED_MEETING_PROVIDERS) {
    if (provider === "local") continue;
    assert.equal(
      typeof REALTIME_TOKEN_PROVIDERS[provider],
      "function",
      `${provider} is meeting-allowed but has no token entry`
    );
  }
});