@mycadet/assistant 0.12.10 → 0.13.0

package/src/tts/provider-catalog.ts

@@ -21,7 +21,6 @@ import type {
   TtsProviderCatalogEntry,
   TtsProviderDefinition,
 } from "./provider-definition.js";
-import { cadetTtsProviderDefinition } from "./providers/cadet-provider.js";
 import { deepgramTtsProviderDefinition } from "./providers/deepgram-provider.js";
 import { elevenLabsTtsProviderDefinition } from "./providers/elevenlabs-provider.js";
 import { fishAudioTtsProviderDefinition } from "./providers/fish-audio-provider.js";
@@ -48,15 +47,12 @@ const DEFINITIONS = {
   "fish-audio": fishAudioTtsProviderDefinition,
   deepgram: deepgramTtsProviderDefinition,
   xai: xaiTtsProviderDefinition,
-  cadet: cadetTtsProviderDefinition,
 } as const satisfies Record<TtsProviderId, TtsProviderDefinition>;
 
 /**
  * Definitions in display order (e.g. settings dropdowns).
  */
-// cadet leads: it is the cloud option, selected like any other provider.
 const CATALOG: readonly TtsProviderDefinition[] = [
-  DEFINITIONS.cadet,
   DEFINITIONS.elevenlabs,
   DEFINITIONS["fish-audio"],
   DEFINITIONS.deepgram,

package/src/tts/types.ts

@@ -28,7 +28,6 @@ export const TTS_PROVIDER_IDS = [
   "fish-audio",
   "deepgram",
   "xai",
-  "cadet",
 ] as const;
 
 /**

package/src/__tests__/cloud-speech-defaults.test.ts

@@ -1,330 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import * as actualTtsCapability from "../calls/telephony-tts-capability.js";
-import * as actualCloudSpeech from "../cloud/cloud-speech.js";
-import * as actualResolve from "../providers/speech-to-text/resolve.js";
-
-let mockCloudSpeechAvailable = false;
-let mockSttKeyResolves = false;
-let mockTtsSecretResolves = false;
-
-mock.module("../cloud/cloud-speech.js", () => ({
-  ...actualCloudSpeech,
-  managedSpeechAvailable: async () => mockCloudSpeechAvailable,
-}));
-
-mock.module("../providers/speech-to-text/resolve.js", () => ({
-  ...actualResolve,
-  sttProviderKeyResolves: async () => mockSttKeyResolves,
-}));
-
-mock.module("../calls/telephony-tts-capability.js", () => ({
-  ...actualTtsCapability,
-  ttsSecretResolves: async () => mockTtsSecretResolves,
-}));
-
-import {
-  maybeDefaultSpeechToCloud,
-  resolveEffectiveSpeechProviders,
-} from "../config/cloud-speech-defaults.js";
-import { getConfig, invalidateConfigCache } from "../config/loader.js";
-import { sttCatalogKeyForRole } from "../stt/roles.js";
-
-const WORKSPACE_DIR = process.env.CADET_WORKSPACE_DIR!;
-const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
-
-function ensureTestDir(): void {
-  if (!existsSync(WORKSPACE_DIR)) {
-    mkdirSync(WORKSPACE_DIR, { recursive: true });
-  }
-}
-
-function writeConfig(obj: unknown): void {
-  writeFileSync(CONFIG_PATH, JSON.stringify(obj));
-  invalidateConfigCache();
-}
-
-function readConfig(): Record<string, unknown> {
-  return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
-}
-
-beforeEach(() => {
-  ensureTestDir();
-  writeConfig({});
-  mockCloudSpeechAvailable = false;
-  mockSttKeyResolves = false;
-  mockTtsSecretResolves = false;
-});
-
-describe("maybeDefaultSpeechToCloud", () => {
-  test("no-ops when cloud speech is unavailable", async () => {
-    await maybeDefaultSpeechToCloud();
-
-    const config = readConfig();
-    expect(config.services).toBeUndefined();
-  });
-
-  test("defaults both services to cadet when no BYOK credentials resolve", async () => {
-    mockCloudSpeechAvailable = true;
-
-    await maybeDefaultSpeechToCloud();
-
-    const config = readConfig();
-    expect((config.services as any)?.stt?.provider).toBe("cadet");
-    expect((config.services as any)?.tts?.provider).toBe("cadet");
-    expect(getConfig().services.stt.provider).toBe("cadet");
-  });
-
-  test("leaves a service alone when its BYOK credential resolves", async () => {
-    mockCloudSpeechAvailable = true;
-    mockSttKeyResolves = true;
-
-    await maybeDefaultSpeechToCloud();
-
-    const config = readConfig();
-    expect((config.services as any)?.stt?.provider).toBeUndefined();
-    expect((config.services as any)?.tts?.provider).toBe("cadet");
-  });
-
-  test("no-ops when both BYOK credentials resolve", async () => {
-    mockCloudSpeechAvailable = true;
-    mockSttKeyResolves = true;
-    mockTtsSecretResolves = true;
-
-    await maybeDefaultSpeechToCloud();
-
-    const config = readConfig();
-    expect(config.services).toBeUndefined();
-  });
-
-  test("no-ops when services are already on cadet", async () => {
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: {
-        stt: { provider: "cadet" },
-        tts: { provider: "cadet" },
-      },
-    });
-
-    await maybeDefaultSpeechToCloud();
-
-    const config = readConfig();
-    expect(config).toEqual({
-      services: {
-        stt: { provider: "cadet" },
-        tts: { provider: "cadet" },
-      },
-    });
-  });
-
-  test("a narrowing stand-in is written to the live-voice role, not the global", async () => {
-    // BYOK Flux with no key: the stand-in preserves turn detection, so it is
-    // cadet-flux, which streams and nothing else. Writing that globally is
-    // how batch transcription and telephony disappear for a cloud user.
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: {
-        stt: {
-          provider: "deepgram",
-          providers: { deepgram: { model: "flux" } },
-        },
-        tts: { provider: "cadet" },
-      },
-    });
-
-    await maybeDefaultSpeechToCloud();
-
-    const stt = (readConfig().services as any).stt;
-    expect(stt.roles.liveVoice).toEqual({ provider: "cadet", model: "flux" });
-    // The other consumers land on the stand-in's base, which serves them all.
-    expect(stt.provider).toBe("cadet");
-    expect(stt.providers.cadet.model).toBe("nova-3");
-  });
-
-  test("the role write leaves batch and telephony on a provider that answers", async () => {
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: {
-        stt: {
-          provider: "deepgram",
-          providers: { deepgram: { model: "flux" } },
-        },
-        tts: { provider: "cadet" },
-      },
-    });
-
-    await maybeDefaultSpeechToCloud();
-
-    invalidateConfigCache();
-    const stt = getConfig().services.stt;
-    expect(sttCatalogKeyForRole(stt, "liveVoice")).toBe("cadet-flux");
-    expect(sttCatalogKeyForRole(stt, "batch")).toBe("cadet");
-    expect(sttCatalogKeyForRole(stt, "telephony")).toBe("cadet");
-  });
-
-  test("a language Flux has no model for keeps live voice on nova-3", async () => {
-    // Korean is outside Flux's ten-language roster, so the relay would reject
-    // the dial. Standing in with Flux hands the speaker a dead mic rather
-    // than a worse transcriber.
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: {
-        stt: {
-          provider: "deepgram",
-          language: "ko",
-          providers: { deepgram: { model: "flux" } },
-        },
-        tts: { provider: "cadet" },
-      },
-    });
-
-    await maybeDefaultSpeechToCloud();
-
-    const stt = (readConfig().services as any).stt;
-    expect(stt.provider).toBe("cadet");
-    expect(stt.providers.cadet.model).toBe("nova-3");
-    expect(stt.roles).toBeUndefined();
-  });
-
-  test("a language Flux does serve still reaches the flux stand-in", async () => {
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: {
-        stt: {
-          provider: "deepgram",
-          language: "hi",
-          providers: { deepgram: { model: "flux" } },
-        },
-        tts: { provider: "cadet" },
-      },
-    });
-
-    await maybeDefaultSpeechToCloud();
-
-    const stt = (readConfig().services as any).stt;
-    expect(stt.roles.liveVoice).toEqual({ provider: "cadet", model: "flux" });
-  });
-
-  test("a capability-preserving stand-in still writes the global provider", async () => {
-    // Plain deepgram has no turn detection, so the stand-in is plain cadet,
-    // which serves every role. That one belongs on the global, not a role.
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: {
-        stt: { provider: "deepgram" },
-        tts: { provider: "cadet" },
-      },
-    });
-
-    await maybeDefaultSpeechToCloud();
-
-    const stt = (readConfig().services as any).stt;
-    expect(stt.provider).toBe("cadet");
-    expect(stt.roles).toBeUndefined();
-  });
-
-  test("never repoints an explicit BYOK provider with resolving credentials", async () => {
-    mockCloudSpeechAvailable = true;
-    mockSttKeyResolves = true;
-    mockTtsSecretResolves = true;
-    writeConfig({
-      services: {
-        stt: { provider: "deepgram" },
-        tts: { provider: "elevenlabs" },
-      },
-    });
-
-    await maybeDefaultSpeechToCloud();
-
-    const config = readConfig();
-    expect((config.services as any).stt.provider).toBe("deepgram");
-    expect((config.services as any).tts.provider).toBe("elevenlabs");
-  });
-});
-
-describe("managed live voice runs Flux", () => {
-  // Turn detection is the only reason to reach for that family, and a cloud
-  // user cannot ask for it: the provider picker offers no family, so `cadet`
-  // is as specific as they can be.
-  test("live voice upgrades to the flux family", async () => {
-    mockCloudSpeechAvailable = true;
-    writeConfig({ services: { stt: { provider: "cadet" } } });
-
-    const { stt } = await resolveEffectiveSpeechProviders(undefined, {
-      role: "liveVoice",
-    });
-
-    expect(stt).toBe("cadet-flux");
-  });
-
-  test("no other consumer follows it there", async () => {
-    // The family streams and nothing else, so batch and telephony would lose
-    // their transcriber entirely.
-    mockCloudSpeechAvailable = true;
-    writeConfig({ services: { stt: { provider: "cadet" } } });
-
-    for (const role of ["batch", "telephony", "dictation", "watch"] as const) {
-      const { stt } = await resolveEffectiveSpeechProviders(undefined, {
-        role,
-      });
-      expect(stt).toBe("cadet");
-    }
-    const { stt: roleless } = await resolveEffectiveSpeechProviders();
-    expect(roleless).toBe("cadet");
-  });
-
-  test("a family the user named wins", async () => {
-    // `services.stt.providers.cadet.model` accepts nova-3, so quietly
-    // overriding it would be the silent substitution roles exist to prevent.
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: {
-        stt: { provider: "cadet", providers: { cadet: { model: "nova-3" } } },
-      },
-    });
-
-    const { stt } = await resolveEffectiveSpeechProviders(undefined, {
-      role: "liveVoice",
-    });
-
-    expect(stt).toBe("cadet");
-  });
-
-  test("a language the family cannot serve stays on nova-3", async () => {
-    mockCloudSpeechAvailable = true;
-    writeConfig({
-      services: { stt: { provider: "cadet", language: "ko" } },
-    });
-
-    const { stt } = await resolveEffectiveSpeechProviders(undefined, {
-      role: "liveVoice",
-    });
-
-    expect(stt).toBe("cadet");
-  });
-
-  test("nothing is upgraded while cloud speech is unavailable", async () => {
-    mockCloudSpeechAvailable = false;
-    writeConfig({ services: { stt: { provider: "cadet" } } });
-
-    const { stt } = await resolveEffectiveSpeechProviders(undefined, {
-      role: "liveVoice",
-    });
-
-    expect(stt).toBe("cadet");
-  });
-
-  test("the upgrade writes no config", async () => {
-    // A resolution rule, not a substitution: nothing lands on disk for a user
-    // to discover, reset, or have to migrate.
-    mockCloudSpeechAvailable = true;
-    writeConfig({ services: { stt: { provider: "cadet" } } });
-    const before = JSON.stringify(readConfig());
-
-    await resolveEffectiveSpeechProviders(undefined, { role: "liveVoice" });
-
-    expect(JSON.stringify(readConfig())).toBe(before);
-  });
-});