@mycadet/assistant 0.12.11 → 0.13.0

package/src/__tests__/voice-config-update.test.ts

@@ -1,15 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import * as actualCloudSpeech from "../cloud/cloud-speech.js";
-
-let mockCloudSpeechAvailable = false;
-
-mock.module("../cloud/cloud-speech.js", () => ({
-  ...actualCloudSpeech,
-  managedSpeechAvailable: async () => mockCloudSpeechAvailable,
-}));
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks — declared before imports that depend on platform/logger
@@ -71,7 +62,6 @@ beforeEach(() => {
   ensureTestDir();
   writeConfig({});
   invalidateConfigCache();
-  mockCloudSpeechAvailable = false;
 });
 
 afterEach(() => {
@@ -144,18 +134,6 @@ describe("voice_config_update — tts_provider", () => {
     expect(tts).not.toHaveProperty("mode");
   });
 
-  test("tts_provider cadet persists when a cloud connection is available", async () => {
-    mockCloudSpeechAvailable = true;
-
-    const result = await run(
-      { setting: "tts_provider", value: "cadet" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect((readConfig().services as any).tts.provider).toBe("cadet");
-  });
-
   test("broadcasts ttsProvider to client", async () => {
     const messages: any[] = [];
     const ctx = makeContext({
@@ -220,130 +198,36 @@ describe("voice_config_update — tts_voice_id", () => {
 // Tests: tts_voice_id targets the active provider's voice field
 // ---------------------------------------------------------------------------
 
-describe("voice_config_update — tts_voice_id (managed/cadet active)", () => {
-  function makeCadetActive(): void {
-    writeConfig({ services: { tts: { provider: "cadet" } } });
+describe("voice_config_update — tts_voice_id", () => {
+  test("writes the voice id and broadcasts the ttsVoiceId key", async () => {
+    writeConfig({ services: { tts: { provider: "elevenlabs" } } });
     invalidateConfigCache();
-  }
-
-  test("writes a Deepgram Aura model id to services.tts.providers.cadet.model", async () => {
-    makeCadetActive();
-
-    const result = await run(
-      { setting: "tts_voice_id", value: "aura-2-zeus-en" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    const config = readConfig();
-    expect((config.services as any)?.tts?.providers?.cadet?.model).toBe(
-      "aura-2-zeus-en",
-    );
-    // The ElevenLabs field is never touched when cadet is active.
-    expect(
-      (config.services as any)?.tts?.providers?.elevenlabs?.voiceId,
-    ).toBeUndefined();
-  });
-
-  test("accepts an ElevenLabs voice id as a cloud model (managed serves ElevenLabs voices)", async () => {
-    makeCadetActive();
-
-    const result = await run(
-      { setting: "tts_voice_id", value: "EXAVITQu4vr4xnSDxMaL" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect((readConfig().services as any)?.tts?.providers?.cadet?.model).toBe(
-      "EXAVITQu4vr4xnSDxMaL",
-    );
-  });
-
-  test("does not broadcast the ElevenLabs ttsVoiceId key for a cloud voice", async () => {
-    makeCadetActive();
     const messages: any[] = [];
     const ctx = makeContext({
       sendToClient: (msg: any) => messages.push(msg),
     });
 
-    const result = await run(
-      { setting: "tts_voice_id", value: "aura-2-zeus-en" },
-      ctx,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(messages).toHaveLength(0);
-    expect(result.content).not.toContain("broadcast");
-  });
-
-  test("hints the inline picker for the next cloud voice change", async () => {
-    makeCadetActive();
-
-    const result = await run(
-      { setting: "tts_voice_id", value: "aura-2-zeus-en" },
-      makeContext(),
-    );
+    const result = await run({ setting: "tts_voice_id", value: "abc123" }, ctx);
 
     expect(result.isError).toBe(false);
-    expect(result.content).toStartWith("Cadet Cloud voice updated to");
-    expect(result.content).toContain(
-      'ui_show { surface_type: "voice_picker", data: {} }',
-    );
+    expect(messages).toHaveLength(1);
+    expect(messages[0].key).toBe("ttsVoiceId");
+    expect(messages[0].value).toBe("abc123");
   });
 
-  test("does not hint the picker when the voice is not managed", async () => {
+  test("rejects a value with characters invalid for any voice id", async () => {
     writeConfig({ services: { tts: { provider: "elevenlabs" } } });
     invalidateConfigCache();
 
-    const result = await run(
-      { setting: "tts_voice_id", value: "abc123" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).not.toContain("voice_picker");
-  });
-
-  test("does not hint the picker for a non-voice setting", async () => {
-    makeCadetActive();
-
-    const result = await run(
-      { setting: "conversation_timeout", value: 30 },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).not.toContain("voice_picker");
-  });
-
-  test("rejects a value with characters invalid for any voice id", async () => {
-    makeCadetActive();
-
     const result = await run(
       { setting: "tts_voice_id", value: "a british man" },
       makeContext(),
     );
 
     expect(result.isError).toBe(true);
-    expect((readConfig().services as any)?.tts?.providers?.cadet?.model).toBe(
-      undefined,
-    );
-  });
-
-  test("broadcasts the ElevenLabs ttsVoiceId key when elevenlabs is active", async () => {
-    writeConfig({ services: { tts: { provider: "elevenlabs" } } });
-    invalidateConfigCache();
-    const messages: any[] = [];
-    const ctx = makeContext({
-      sendToClient: (msg: any) => messages.push(msg),
-    });
-
-    const result = await run({ setting: "tts_voice_id", value: "abc123" }, ctx);
-
-    expect(result.isError).toBe(false);
-    expect(messages).toHaveLength(1);
-    expect(messages[0].key).toBe("ttsVoiceId");
-    expect(messages[0].value).toBe("abc123");
+    expect(
+      (readConfig().services as any)?.tts?.providers?.elevenlabs?.voiceId,
+    ).toBeUndefined();
   });
 });
 
@@ -536,31 +420,6 @@ describe("voice_config_update — stt_provider", () => {
     );
   });
 
-  test("persists the cadet provider when a cloud connection is available", async () => {
-    mockCloudSpeechAvailable = true;
-
-    const result = await run(
-      { setting: "stt_provider", value: "cadet" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect((readConfig().services as any)?.stt?.provider).toBe("cadet");
-  });
-
-  test("rejects the cadet provider without a cloud connection", async () => {
-    mockCloudSpeechAvailable = false;
-
-    const result = await run(
-      { setting: "stt_provider", value: "cadet" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("assistant cloud connect");
-    expect((readConfig().services as any)?.stt?.provider).toBeUndefined();
-  });
-
   test("stt_model persists under the active provider", async () => {
     // Flux stays reachable from this surface after ceasing to be a provider
     // id: it is a model family on whichever provider is active.
@@ -916,22 +775,8 @@ describe("voice_config_update - stt_language", () => {
 // ---------------------------------------------------------------------------
 
 describe("voice_config_update — catalog-driven provider validation", () => {
-  test("rejects tts_provider cadet without a cloud connection", async () => {
-    mockCloudSpeechAvailable = false;
-
-    const result = await run(
-      { setting: "tts_provider", value: "cadet" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("assistant cloud connect");
-    expect((readConfig().services as any)?.tts?.provider).toBeUndefined();
-  });
-
   test("accepts every provider ID in the catalog", async () => {
     // The catalog includes cadet, which is gated on a cloud connection.
-    mockCloudSpeechAvailable = true;
     const catalogIds = listCatalogProviderIds();
     expect(catalogIds.length).toBeGreaterThanOrEqual(1);
 

package/src/__tests__/web-search-catalog-parity.test.ts

@@ -23,7 +23,6 @@ interface JsonCatalogEntry {
   id: string;
   displayName: string;
   displayNameLong?: string;
-  kind: "managed" | "byok";
   apiKeyPrefix?: string;
   envVar?: string;
   secretKey?: string;
@@ -61,7 +60,6 @@ function entryToPlain(
   if (entry.displayNameLong !== undefined) {
     out.displayNameLong = entry.displayNameLong;
   }
-  out.kind = entry.kind;
   if (entry.apiKeyPrefix !== undefined) {
     out.apiKeyPrefix = entry.apiKeyPrefix;
   }

package/src/__tests__/workspace-migration-130-speech-mode-to-provider.test.ts

@@ -9,7 +9,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { AssistantConfigSchema } from "../config/schema.js";
 import { speechModeToProviderMigration } from "../workspace/migrations/130-speech-mode-to-provider.js";
 import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
 import { getLastWorkspaceMigrationId } from "../workspace/migrations/runner.js";
@@ -146,9 +145,10 @@ describe("130-speech-mode-to-provider", () => {
     expect(() => speechModeToProviderMigration.run(workspaceDir)).not.toThrow();
   });
 
-  // The migrated shape is what the daemon actually parses, so a cloud user
-  // must land on cadet rather than falling back to a keyless BYOK provider.
-  test("migrated output parses to the cadet provider", () => {
+  // The migrated shape is frozen (the migration never reruns), asserted raw:
+  // the current config schema no longer knows the cadet provider id, so a
+  // schema parse of a migrated cloud config is no longer a valid invariant.
+  test("migrated output folds managed mode into the cadet provider", () => {
     writeConfig({
       services: {
         stt: { mode: "managed", provider: "deepgram", providers: {} },
@@ -157,10 +157,12 @@ describe("130-speech-mode-to-provider", () => {
     });
 
     speechModeToProviderMigration.run(workspaceDir);
-    const parsed = AssistantConfigSchema.parse(readConfig());
 
-    expect(parsed.services.stt.provider).toBe("cadet");
-    expect(parsed.services.tts.provider).toBe("cadet");
+    expect(services(readConfig()).stt).toEqual({
+      provider: "cadet",
+      providers: {},
+    });
+    expect(services(readConfig()).tts).toEqual({ provider: "cadet" });
   });
 
   describe("down", () => {

package/src/__tests__/workspace-migration-132-web-search-mode-to-provider.test.ts

@@ -9,7 +9,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { AssistantConfigSchema } from "../config/schema.js";
 import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
 import { getLastWorkspaceMigrationId } from "../workspace/migrations/runner.js";
 
@@ -163,17 +162,18 @@ describe("132-web-search-mode-to-provider", () => {
     ).not.toThrow();
   });
 
-  // The migrated shape is what the daemon actually parses, so a cloud user
-  // must land on cadet rather than falling back to a keyless BYOK provider.
-  test("migrated output parses to the cadet provider", () => {
+  // The migrated shape is frozen (the migration never reruns), asserted raw:
+  // the current config schema no longer knows the cadet provider id, so a
+  // schema parse of a migrated cloud config is no longer a valid invariant —
+  // the config loader's recovery ladder owns any on-disk 'cadet' values.
+  test("migrated output folds managed mode into the cadet provider", () => {
     writeConfig({
       services: { "web-search": { mode: "managed", provider: "brave" } },
     });
 
     webSearchModeToProviderMigration.run(workspaceDir);
-    const parsed = AssistantConfigSchema.parse(readConfig());
 
-    expect(parsed.services["web-search"].provider).toBe("cadet");
+    expect(webSearch(readConfig())).toEqual({ provider: "cadet" });
   });
 
   describe("down", () => {

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -1091,16 +1091,13 @@ describe("default call protocol numbered rules", () => {
 
   test("a monolingual listening language becomes the pre-speech fallback", () => {
     // An assistant pinned to services.stt.language = "es" on a provider that
-    // honors the pin (deepgram, cadet) is already transcribing Spanish, so
+    // honors the pin (deepgram) is already transcribing Spanish, so
     // the opener must not default to English. The default test config runs
     // the auto-detect branch ("multi"), so the pinned branch is covered at
     // the fragment level.
     expect(preSpeechLanguageRuleFragment("es", "deepgram")).toContain(
       'configured listening language ("es")',
     );
-    expect(preSpeechLanguageRuleFragment("es", "cadet")).toContain(
-      "default to English only when neither gives a language",
-    );
     for (const autoDetect of ["multi", "", "  ", undefined]) {
       expect(preSpeechLanguageRuleFragment(autoDetect, "deepgram")).toBe(
         "use the language the Task context implies, if any; otherwise default to English",

package/src/calls/resolve-call-tts-provider.ts

@@ -7,7 +7,6 @@
  * native-vs-synthesized strategy decision stay in one implementation.
  */
 
-import { resolveEffectiveSpeechProviders } from "../config/cloud-speech-defaults.js";
 import { getConfig } from "../config/loader.js";
 import {
   getCatalogProvider,
@@ -74,13 +73,6 @@ export interface ResolveCallTtsOptions {
 /**
  * Resolve the active TTS provider via the global provider abstraction.
  *
- * The provider is the effective one after cloud-speech defaulting
- * ({@link resolveEffectiveSpeechProviders}): a configured BYOK provider
- * whose credential does not resolve is stood in for by cloud speech
- * while the cloud connection is usable, the same substitution live
- * voice makes, so a fresh Cadet connection speaks on the phone with zero
- * TTS configuration.
- *
  * The native-vs-synthesized decision is driven by the catalog's
  * `callMode` field via {@link resolveCallStrategy}. Providers with
  * `callMode: "synthesized-play"` have their audio streamed through the
@@ -185,25 +177,14 @@ export async function resolveCallTtsProvider(
 }
 
 /**
- * The TTS provider the call actually uses after cloud-speech defaulting.
- * A failure inside the cloud lookup (platform client, credential store)
- * keeps the configured provider: a cloud-speech hiccup must not demote a
- * working BYOK provider, and the outer resolver's own fallback is the
- * silent native path.
+ * The TTS provider the call actually uses — the configured one. Kept as a
+ * named seam because the outer resolver's own fallback is the silent
+ * native path when the config has no services.tts block.
  */
-async function effectiveTtsProviderId(
+function effectiveTtsProviderId(
   config: ReturnType<typeof getConfig>,
-): Promise<TtsProviderId | undefined> {
-  try {
-    const { tts } = await resolveEffectiveSpeechProviders(config);
-    return tts;
-  } catch (err) {
-    log.warn(
-      { err },
-      "Managed-speech defaulting failed for call TTS; keeping the configured provider",
-    );
-    return undefined;
-  }
+): TtsProviderId | undefined {
+  return config.services.tts?.provider;
 }
 
 /**

package/src/calls/telephony-credential-preflight.ts

@@ -140,16 +140,6 @@ function ttsGap(
         clause: `an API key for the text-to-speech provider "${providerId}" (no fallback provider has usable credentials)`,
       };
     }
-    case "missing-cloud-connection": {
-      return {
-        gap: {
-          kind: "tts",
-          providerId,
-          reason: `Managed TTS has no usable Cadet Cloud connection and no playable fallback provider is available`,
-        },
-        clause: `a Cadet Cloud connection for cloud speech (run 'assistant cloud connect'; no fallback provider has usable credentials)`,
-      };
-    }
     case "missing-fish-audio-reference-id": {
       return {
         gap: {

package/src/calls/telephony-tts-capability.ts

@@ -37,8 +37,7 @@ import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
 export type TelephonyTtsNotPlayableReason =
   | "unsupported-format"
   | "missing-credentials"
-  | "missing-fish-audio-reference-id"
-  | "missing-cloud-connection";
+  | "missing-fish-audio-reference-id";
 
 /**
  * Result of resolving whether a TTS provider is playable over the
@@ -113,21 +112,6 @@ export async function evaluateTelephonyTtsPlayability(
     }
   }
 
-  // The cadet secret alone doesn't prove usability: cloud speech also
-  // needs the cloud assistant identity, or synthesis fails before any
-  // request is made — with allowNativeFallback false, that would mean
-  // silent call failures instead of a BYOK fallback.
-  if (entry.id === "cadet") {
-    const { managedSpeechAvailable } = await import("../cloud/cloud-speech.js");
-    if (!(await managedSpeechAvailable())) {
-      return {
-        status: "not-playable",
-        providerId: entry.id,
-        reason: "missing-cloud-connection",
-      };
-    }
-  }
-
   if (entry.id === "fish-audio" && !fishAudioReferenceIdConfigured()) {
     return {
       status: "not-playable",

package/src/cli/commands/tts.ts

@@ -222,8 +222,7 @@ export function registerTtsCommand(program: Command): void {
           }
 
           // Read the active TTS provider so the voice lands on the field that
-          // provider actually reads. Writing the ElevenLabs field while the
-          // active provider is `cadet` is a silent no-op.
+          // provider actually reads.
           const cfg = await cliIpcCall<{
             services?: { tts?: { provider?: string } };
           }>("config_get");

package/src/cli/index.help.ts

@@ -16,7 +16,6 @@ import { attachmentHelp } from "./commands/attachment.help.js";
 import { auditHelp } from "./commands/audit.help.js";
 import { authHelp } from "./commands/auth.help.js";
 import { avatarHelp } from "./commands/avatar.help.js";
-import { backupHelp } from "./commands/backup.help.js";
 import { bashHelp } from "./commands/bash.help.js";
 import { browserHelp } from "./commands/browser.help.js";
 import { cacheHelp } from "./commands/cache.help.js";
@@ -67,7 +66,6 @@ export const CLI_COMMAND_HELP: readonly CliCommandHelp[] = [
   auditHelp,
   authHelp,
   avatarHelp,
-  backupHelp,
   bashHelp,
   browserHelp,
   cacheHelp,

package/src/cli/program.ts

@@ -10,7 +10,6 @@ import { registerAttachmentCommand } from "./commands/attachment.js";
 import { registerAuditCommand } from "./commands/audit.js";
 import { registerAuthCommand } from "./commands/auth.js";
 import { registerAvatarCommand } from "./commands/avatar.js";
-import { registerBackupCommand } from "./commands/backup.js";
 import { registerBashCommand } from "./commands/bash.js";
 import { registerBrowserCommand } from "./commands/browser.js";
 import { registerCacheCommand } from "./commands/cache.js";
@@ -108,7 +107,6 @@ Examples:
   registerAuditCommand(program);
   registerAuthCommand(program);
   registerAvatarCommand(program);
-  registerBackupCommand(program);
   registerBashCommand(program);
   registerBrowserCommand(program);
   registerCacheCommand(program);

package/src/config/bundled-skills/settings/tools/voice-config-update.ts

@@ -1,13 +1,9 @@
-import { managedSpeechAvailable } from "../../../../cloud/cloud-speech.js";
 import { normalizeActivationKey } from "../../../../daemon/handlers/config-voice.js";
 import {
   DEEPGRAM_MULTI_LANGUAGE_CODES,
   DEEPGRAM_NOVA3_MONOLINGUAL_CODES,
 } from "../../../../providers/speech-to-text/deepgram.js";
-import {
-  isCloudSttProvider,
-  listProviderModelFamilies,
-} from "../../../../providers/speech-to-text/provider-catalog.js";
+import { listProviderModelFamilies } from "../../../../providers/speech-to-text/provider-catalog.js";
 import type { SttProviderId } from "../../../../stt/types.js";
 import { throwIfCancelled } from "../../../../tools/shared/abort.js";
 import type {
@@ -28,7 +24,6 @@ import {
   normalizeSttProviderId,
   VALID_STT_PROVIDERS,
 } from "../../../schemas/stt.js";
-import { voicePickerHint } from "./shared.js";
 
 /**
  * Valid voice config settings and their UserDefaults key mappings.
@@ -199,19 +194,6 @@ const STT_LANGUAGE_ALIASES: Record<
   "code-switching": "multi",
 };
 
-/**
- * Same steer `navigate_settings_tab` puts on the Voice tab, applied to the
- * strongest competing affordance: this tool's description coaches the model to
- * read the cloud catalog and set `tts_voice_id` itself, which is exactly the
- * "assistant names voices in prose" outcome the inline picker exists to
- * replace. Managed only, because that is the catalog the picker renders. The
- * write still happens and the result stays non-error; this only redirects the
- * next request.
- */
-const MANAGED_VOICE_PICKER_HINT = voicePickerHint(
-  "which lets them hear and pick from the cloud catalog in the conversation. Set the id here only when the user named a specific voice.",
-);
-
 function validateSetting(
   setting: string,
   value: unknown,
@@ -469,24 +451,8 @@ export async function run(
     return { content: `Error: ${validation.error}`, isError: true };
   }
 
-  // Cloud speech has more than one STT id, so the gate reads the catalog
-  // rather than a literal: without this, setting a cloud provider other
-  // than "cadet" on a disconnected assistant persists happily and then
-  // resolves no transcriber at all.
-  const wantsCloudSpeech =
-    (setting === "stt_provider" &&
-      isCloudSttProvider(validation.coerced as SttProviderId)) ||
-    (setting === "tts_provider" && validation.coerced === "cadet");
-  if (wantsCloudSpeech && !(await managedSpeechAvailable())) {
-    return {
-      content:
-        "Error: cloud speech requires a Cadet Cloud connection. Run 'assistant cloud connect' first.",
-      isError: true,
-    };
-  }
-
-  // Recheck: the cloud-speech reachability probe above is an await, and the
-  // client broadcast and config write below are what the user would notice.
+  // Recheck: the reachability probe above is an await, and the client
+  // broadcast and config write below are what the user would notice.
   throwIfCancelled(context);
 
   const meta: VoiceSettingMeta = VOICE_SETTINGS[setting as VoiceSettingName];
@@ -618,14 +584,10 @@ export async function run(
     AUTO_DETECT_STT_PROVIDERS.has(activeSttProviderId)
       ? ` Note: the configured STT provider (${activeSttProviderId}) auto-detects the spoken language natively and ignores this setting.`
       : "";
-  const pickerNote =
-    setting === "tts_voice_id" && activeTtsProviderId === "cadet"
-      ? ` ${MANAGED_VOICE_PICKER_HINT}`
-      : "";
   return {
     content: `${friendlyName} updated to ${JSON.stringify(
       validation.coerced,
-    )}.${broadcastNote}${autoDetectNote}${pickerNote}`,
+    )}.${broadcastNote}${autoDetectNote}`,
     isError: false,
   };
 }

package/src/config/schemas/__tests__/stt.test.ts

@@ -69,9 +69,9 @@ describe("SttServiceSchema", () => {
   test("language defaults to multilingual rather than staying absent", () => {
     // Every config carries a real language, so nothing downstream has to
     // infer one from an absent key. Omitting the param entirely is not a
-    // neutral state on Deepgram and the cloud relay: it decodes as
-    // English, which is what this default exists to stop.
-    const parsed = SttServiceSchema.parse({ provider: "cadet" });
+    // neutral state on Deepgram: it decodes as English, which is what this
+    // default exists to stop.
+    const parsed = SttServiceSchema.parse({ provider: "deepgram" });
     expect(parsed.language).toBe("multi");
   });
 
@@ -86,7 +86,8 @@ describe("SttServiceSchema", () => {
 
   test("language round-trips a code and the multi code-switching mode", () => {
     expect(
-      SttServiceSchema.parse({ provider: "cadet", language: "multi" }).language,
+      SttServiceSchema.parse({ provider: "deepgram", language: "multi" })
+        .language,
     ).toBe("multi");
     expect(
       SttServiceSchema.parse({ provider: "deepgram", language: "hi" }).language,
@@ -95,30 +96,25 @@ describe("SttServiceSchema", () => {
 
   test("language is trimmed and rejects blank strings", () => {
     expect(
-      SttServiceSchema.parse({ provider: "cadet", language: "  multi  " })
+      SttServiceSchema.parse({ provider: "deepgram", language: "  multi  " })
         .language,
     ).toBe("multi");
     expect(() =>
-      SttServiceSchema.parse({ provider: "cadet", language: "   " }),
+      SttServiceSchema.parse({ provider: "deepgram", language: "   " }),
     ).toThrow(/must not be empty/);
   });
 });
 
-describe("cloud provider", () => {
-  test("accepts cadet as an ordinary provider choice", () => {
-    const parsed = SttServiceSchema.parse({ provider: "cadet" });
-    expect(parsed.provider).toBe("cadet");
-  });
-
+describe("provider parsing", () => {
   // Migration 130 folds mode into provider; a stale key must not resurrect
   // the second axis or fail the parse.
   test("ignores a legacy mode key", () => {
     const parsed = SttServiceSchema.parse({
       mode: "managed",
-      provider: "cadet",
+      provider: "deepgram",
     });
     expect(parsed).toEqual({
-      provider: "cadet",
+      provider: "deepgram",
       language: "multi",
       providers: {},
       roles: {},

package/src/config/schemas/services.ts

@@ -71,12 +71,11 @@ const ImageGenerationServiceSchema = z.object({
 });
 
 /**
- * Web-search carries no `mode`: `provider` is the only axis. `"cadet"`
- * searches through the Cadet Cloud search proxy, billed to Cadet
- * credits; `"inference-provider-native"` prefers the inference model's own
- * hosted search, falling back to the user's keys and then the cloud
- * proxy; any other provider uses the user's own API key. A `mode` key sent
- * by an older client is stripped at parse.
+ * Web-search carries no `mode`: `provider` is the only axis.
+ * `"inference-provider-native"` prefers the inference model's own hosted
+ * search, falling back to the user's own keys; any other provider uses the
+ * user's own API key. A `mode` key sent by an older client is stripped at
+ * parse.
  */
 const WebSearchServiceSchema = z.object({
   provider: z