@mycadet/assistant 0.12.11 → 0.13.0

package/src/providers/speech-to-text/resolve.ts

@@ -13,7 +13,6 @@ import {
   batchBoundaryGapReason,
   getCredentialProvider,
   getProviderEntry,
-  isCloudSttProvider,
   resolveSttCatalogKey,
   supportsBoundary,
   supportsDiarization,
@@ -37,11 +36,6 @@ const log = getLogger("stt-resolver");
  */
 const MULTILINGUAL_DEFAULT_PROVIDERS: ReadonlySet<SttProviderId> = new Set([
   "deepgram",
-  "cadet",
-  // Cloud Flux resolves an absent language to `flux-general-en` relay-side,
-  // so unset is an English pin here too. With "multi" the relay selects
-  // `flux-general-multi` and lets Flux detect and code-switch.
-  "cadet-flux",
 ] as SttProviderId[]);
 
 /**
@@ -156,16 +150,6 @@ export async function resolveBatchTranscriber(
     throw new SttError("provider-error", reason, { userFacing: true });
   }
 
-  if (provider === "cadet") {
-    // Managed batch rides the cloud's speech proxy, which forwards the
-    // language to Deepgram server-side. A platform build predating that
-    // field ignores it rather than failing, so the daemon can send one
-    // before the cloud side deploys.
-    return (await sttProviderKeyResolves("cadet"))
-      ? createDaemonBatchTranscriber(null, "cadet", language)
-      : null;
-  }
-
   const apiKey = await getProviderKeyAsync(credentialProviderName);
   return createDaemonBatchTranscriber(
     apiKey,
@@ -515,18 +499,8 @@ export async function resolveStreamingTranscriber(
     (diarizePreference === "preferred" || diarizePreference === "required") &&
     providerSupportsDiarization;
 
-  // Both managed entries authenticate with the cloud connection, not a
-  // stored API key: there is no key to fetch, and readiness is whether the
-  // connection resolves.
-  const managed = isCloudSttProvider(provider);
-  const apiKey = managed
-    ? null
-    : await getProviderKeyAsync(credentialProviderName);
-  if (managed) {
-    if (!(await sttProviderKeyResolves("cadet"))) {
-      return null;
-    }
-  } else if (!apiKey) {
+  const apiKey = await getProviderKeyAsync(credentialProviderName);
+  if (!apiKey) {
     return null;
   }
 
@@ -656,82 +630,6 @@ async function createStreamingTranscriber(
         ...(options.diarize ? { diarize: true } : {}),
       });
     }
-    case "cadet": {
-      // Cloud speech dials the GATEWAY's speech relay (tunnel contact is
-      // gateway-only); the apiKey argument is unused. Diarization is
-      // unsupported (not in the relay's param allowlist) and silently
-      // ignored, matching Gemini/Whisper — as is utteranceEndMs (the relay
-      // allowlist has no utterance_end_ms; boundary finals ride on
-      // endpointing alone).
-      // The gateway is the credential authority, but the cloud
-      // connection (API key + assistant ID) is checkable locally — gate
-      // here so preflight reports "connect your account" instead of
-      // resolving a transcriber whose dial is doomed.
-      const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
-      if (!(await cadetCloudSpeechAvailable())) {
-        return null;
-      }
-      const { resolveSpeechRelayConnection } =
-        await import("./cadet-speech-relay-connection.js");
-      const connection = await resolveSpeechRelayConnection();
-      if (!connection) {
-        return null;
-      }
-      const { CadetManagedRealtimeTranscriber } =
-        await import("./cadet-cloud-realtime.js");
-      return new CadetManagedRealtimeTranscriber(connection, {
-        sampleRate: options.sampleRate,
-        // `language` IS in the relay's param allowlist, and the relay pins
-        // the STT model to nova-3 server-side, so "multi" code-switching
-        // needs nothing from the cloud, only this forward. Source:
-        // mycadet-platform: tunnel/internal/tunnel/deepgram.go
-        // (deepgramSTTParams allowlist; deepgramSTTModel pin).
-        ...(options.language ? { language: options.language } : {}),
-        ...(options.utteranceBoundaryFinals
-          ? { utteranceBoundaryFinals: true }
-          : {}),
-      });
-    }
-    case "cadet-flux": {
-      // Cloud Flux: same relay as `cadet`, but the STT v2 endpoint with
-      // `contract=flux` so the turn events arrive intact instead of being
-      // translated into the released v1 Deepgram dialect. Gated on the local
-      // cloud connection for the same reason as `cadet` above.
-      const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
-      if (!(await cadetCloudSpeechAvailable())) {
-        return null;
-      }
-      // The relay maps the language onto a Flux model and refuses the dial
-      // when there is none, so a language outside Flux's roster fails as a
-      // relay param error the caller cannot explain. Refuse here instead, on
-      // the same rule the BYOK twin above applies, so the reason is named
-      // where it can be read.
-      const { fluxModelForLanguage: managedFluxModelForLanguage } =
-        await import("./deepgram-flux-frames.js");
-      if (managedFluxModelForLanguage(options.language) === null) {
-        log.warn(
-          { providerId, language: options.language },
-          "Cloud Flux has no model for the configured language; refusing rather than transcribing it as another",
-        );
-        return null;
-      }
-      const { resolveSpeechRelayConnection } =
-        await import("./cadet-speech-relay-connection.js");
-      const connection = await resolveSpeechRelayConnection();
-      if (!connection) {
-        return null;
-      }
-      const { CadetManagedFluxRealtimeTranscriber } =
-        await import("./cadet-cloud-flux-realtime.js");
-      return new CadetManagedFluxRealtimeTranscriber(connection, {
-        sampleRate: options.sampleRate,
-        // The relay picks `flux-general-en` or `flux-general-multi` from
-        // this, so it is the only lever over the Flux model from here.
-        // `utteranceBoundaryFinals` is a nova-3 concept and the catalog
-        // keeps this provider off telephony, so it never arrives.
-        ...(options.language ? { language: options.language } : {}),
-      });
-    }
     case "deepgram-flux": {
       // Flux is streaming-only and dials Deepgram's /v2/listen conversational
       // endpoint. Turn-detection tuning comes from `liveVoice.flux`, which the
@@ -775,29 +673,14 @@ async function createStreamingTranscriber(
  * need a key-existence check don't import secure-keys directly.
  */
 /**
- * Human-readable reason for a credential gap, aware that connection-based
- * providers (cadet) are fixed by connecting the cloud account, not by
- * entering an API key.
+ * Human-readable reason for a credential gap.
  */
 export function sttCredentialGapReason(credentialProviderName: string): string {
-  // Called with either the catalog id ("cadet") or its credential-service
-  // key ("cadet", the persisted identity family) — both mean cloud speech.
-  if (
-    credentialProviderName === "cadet" ||
-    credentialProviderName === "cadet"
-  ) {
-    return "No Cadet Cloud connection for cloud speech — run 'assistant cloud connect'";
-  }
   return `No API key configured for credential provider "${credentialProviderName}"`;
 }
 
 export async function sttProviderKeyResolves(
   credentialProviderName: string,
 ): Promise<boolean> {
-  // cadet has no stored API key — the cloud connection is the credential.
-  if (credentialProviderName === "cadet") {
-    const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
-    return cadetCloudSpeechAvailable();
-  }
   return (await getProviderKeyAsync(credentialProviderName)) !== undefined;
 }

package/src/runtime/http-router-types.ts

@@ -45,9 +45,7 @@ export type RouteBodySchema = z.ZodType;
 
 /**
  * Description for a non-200 response variant. Used when an endpoint has
- * meaningful alternate response shapes that clients should handle (e.g.
- * 502 `fetch_failed` on POST /v1/migrations/import when the URL body path
- * can't reach the upstream bundle host).
+ * meaningful alternate response shapes that clients should handle.
  */
 export interface RouteAdditionalResponse {
   description: string;

package/src/runtime/http-server.ts

@@ -122,7 +122,7 @@ const log = getLogger("runtime-http");
 const DEFAULT_PORT = 7821;
 const DEFAULT_HOSTNAME = "127.0.0.1";
 
-/** Global hard cap on request body size (512 MB — accommodates large .vbundle backup imports). */
+/** Global hard cap on request body size (512 MB, accommodates app package uploads). */
 const MAX_REQUEST_BODY_BYTES = 512 * 1024 * 1024;
 
 function dbMigrationUnavailableForEndpoint(endpoint: string): Response | null {

package/src/runtime/routes/__tests__/tts-routes.test.ts

@@ -127,17 +127,13 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("tts-routes", () => {
-  test("exports route definitions for tts/providers, tts/managed-voices, tts/synthesize, and tts/synthesize-cli", () => {
-    expect(ROUTES).toHaveLength(4);
+  test("exports route definitions for tts/providers, tts/synthesize, and tts/synthesize-cli", () => {
+    expect(ROUTES).toHaveLength(3);
 
     const providers = getRoute("tts/providers");
     expect(providers.method).toBe("GET");
     expect(providers.policy?.requiredScopes).toContain("settings.read");
 
-    const managedVoices = getRoute("tts/managed-voices");
-    expect(managedVoices.method).toBe("GET");
-    expect(managedVoices.policy?.requiredScopes).toContain("settings.read");
-
     const synthesize = getRoute("tts/synthesize");
     expect(synthesize.method).toBe("POST");
     expect(synthesize.policy?.requiredScopes).toContain("chat.read");

package/src/runtime/routes/inbound-stages/transcribe-audio.test.ts

@@ -200,17 +200,17 @@ describe("tryTranscribeAudioAttachments", () => {
     expect(reason).toContain("Deepgram");
   });
 
-  test("managed auth failure surfaces its remediation, not the BYOK API-key rewrite", async () => {
+  test("a userFacing auth failure surfaces its remediation, not the BYOK API-key rewrite", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
     const managedMessage =
       "Cloud speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";
     mockTranscriber = {
-      providerId: "cadet",
+      providerId: "deepgram",
       boundaryId: "daemon-batch",
       transcribe: async () => {
-        // Managed adapters flag their SttError userFacing so the friendly
-        // copy layer passes the message through verbatim.
+        // Adapters flag their SttError userFacing so the friendly copy
+        // layer passes the message through verbatim.
         throw new SttError("auth", managedMessage, { userFacing: true });
       },
     };
@@ -220,18 +220,18 @@ describe("tryTranscribeAudioAttachments", () => {
     expect(result.status).toBe("error");
     const reason = (result as { reason: string }).reason;
     expect(reason).toBe(managedMessage);
-    // Managed users have no STT key — the BYOK rewrite must not appear.
+    // The BYOK rewrite must not appear over a userFacing message.
     expect(reason).not.toContain("API key");
     expect(reason).not.toContain("Settings → Voice");
   });
 
-  test("managed credits-exhausted failure is not hidden behind generic copy", async () => {
+  test("a credits-exhausted userFacing failure is not hidden behind generic copy", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
     const creditsMessage =
       "Cadet credits are exhausted — add funds to your Cadet account to continue using managed transcription.";
     mockTranscriber = {
-      providerId: "cadet",
+      providerId: "deepgram",
       boundaryId: "daemon-batch",
       transcribe: async () => {
         throw new SttError("provider-error", creditsMessage, {

package/src/runtime/routes/index.ts

@@ -27,7 +27,6 @@ import { ROUTES as AUDIT_ROUTES } from "./audit-routes.js";
 import { ROUTES as AUTH_ROUTES } from "./auth-routes.js";
 import { ROUTES as AVATAR_ROUTES } from "./avatar-routes.js";
 import { ROUTES as BACKGROUND_TOOL_ROUTES } from "./background-tool-routes.js";
-import { ROUTES as BACKGROUND_WAKE_ROUTES } from "./background-wake-routes.js";
 import { ROUTES as BOOKMARK_ROUTES } from "./bookmark-routes.js";
 import { ROUTES as BRAIN_GRAPH_ROUTES } from "./brain-graph-routes.js";
 import { ROUTES as BROWSER_ROUTES } from "./browser-routes.js";
@@ -114,7 +113,6 @@ import { ROUTES as LOG_EXPORT_ROUTES } from "./log-export-routes.js";
 import { ROUTES as MCP_AUTH_ROUTES } from "./mcp-auth-routes.js";
 import { ROUTES as MESSAGES_LEXICAL_ROUTES } from "./messages-lexical-routes.js";
 import { ROUTES as MIGRATION_ROLLBACK_ROUTES } from "./migration-rollback-routes.js";
-import { ROUTES as MIGRATION_ROUTES } from "./migration-routes.js";
 import { ROUTES as MONITORING_ROUTES } from "./monitoring-routes.js";
 import { ROUTES as NOTIFICATION_ROUTES } from "./notification-routes.js";
 import { ROUTES as OAUTH_APPS_ROUTES } from "./oauth-apps.js";
@@ -179,7 +177,6 @@ export const ROUTES: RouteDefinition[] = [
   ...AUDIT_ROUTES,
   ...AUTH_ROUTES,
   ...AVATAR_ROUTES,
-  ...BACKGROUND_WAKE_ROUTES,
   ...BACKGROUND_TOOL_ROUTES,
   ...BOOKMARK_ROUTES,
   ...CACHE_ROUTES,
@@ -267,7 +264,6 @@ export const ROUTES: RouteDefinition[] = [
   ...MEMORY_WORKER_ROUTES,
   ...MESSAGES_LEXICAL_ROUTES,
   ...MIGRATION_ROLLBACK_ROUTES,
-  ...MIGRATION_ROUTES,
   ...NOTIFICATION_ROUTES,
   ...OAUTH_APPS_ROUTES,
   ...OAUTH_LIFECYCLE_ROUTES,

package/src/runtime/routes/live-voice-routes.test.ts

@@ -1,11 +1,10 @@
 /**
  * Tests for the live-voice preflight and session-end routes.
  *
- * The handler must run cloud-speech defaulting first, then return the
- * live-voice credential readiness verdict verbatim:
+ * The preflight handler returns the live-voice credential readiness verdict
+ * verbatim:
  * - ready → { status: "ready" }
  * - not-ready → passes through the missing gaps + userMessage
- * - defaulting is invoked BEFORE readiness is resolved
  *
  * The session-end route is the out-of-band recovery path (LUM-3440): it
  * reports whether it actually reclaimed the daemon's single live-voice slot.
@@ -23,12 +22,6 @@ const calls: string[] = [];
 let readiness: LiveVoiceCredentialReadiness = { status: "ready" };
 let releaseResult: LiveVoiceSessionReleaseResult = { released: false };
 
-mock.module("../../config/cloud-speech-defaults.js", () => ({
-  maybeDefaultSpeechToCloud: async () => {
-    calls.push("default");
-  },
-}));
-
 mock.module("../../live-voice/live-voice-credential-preflight.js", () => ({
   resolveLiveVoiceCredentialReadiness: async () => {
     calls.push("resolve");
@@ -80,13 +73,13 @@ describe("live_voice_preflight_post", () => {
     expect(result).toEqual(readiness);
   });
 
-  test("runs cloud-speech defaulting before resolving readiness", async () => {
+  test("resolves readiness without touching persisted config", async () => {
     calls.length = 0;
     readiness = { status: "ready" };
 
     await preflightRoute.handler({});
 
-    expect(calls).toEqual(["default", "resolve"]);
+    expect(calls).toEqual(["resolve"]);
   });
 });
 

package/src/runtime/routes/live-voice-routes.ts

@@ -1,9 +1,9 @@
 /**
  * Transport-agnostic route definitions for live-voice preflight.
  *
- * POST /v1/live-voice/preflight — ensure cloud-speech defaulting has run,
- * then report whether the daemon can run both audio legs of a live voice
- * session. Lets the web client verify voice is configured BEFORE opening the
+ * POST /v1/live-voice/preflight — report whether the daemon can run both
+ * audio legs of a live voice session. Lets the web client verify voice is
+ * configured BEFORE opening the
  * voice-room WebSocket, instead of opening it and reacting to an error frame.
  *
  * POST /v1/live-voice/session/end releases whatever session holds the
@@ -22,12 +22,9 @@ import type { RouteDefinition } from "./types.js";
 // ---------------------------------------------------------------------------
 
 async function handleLiveVoicePreflight() {
-  const { maybeDefaultSpeechToCloud } =
-    await import("../../config/cloud-speech-defaults.js");
   const { resolveLiveVoiceCredentialReadiness } =
     await import("../../live-voice/live-voice-credential-preflight.js");
 
-  await maybeDefaultSpeechToCloud();
   return resolveLiveVoiceCredentialReadiness();
 }
 
@@ -51,17 +48,17 @@ export const ROUTES: RouteDefinition[] = [
     operationId: "live_voice_preflight_post",
     endpoint: "live-voice/preflight",
     method: "POST",
-    // Requires settings.write, not a read scope: the handler runs
-    // maybeDefaultSpeechToCloud(), which can persist config changes
-    // (switching services.stt/tts.provider to "cadet"). This matches the
-    // secret/settings config writers, which all require settings.write.
+    // Requires settings.write, not a read scope: preflight reports the
+    // assistant's speech credential state, which the caller may act on to
+    // rewrite speech config. This matches the secret/settings config
+    // writers, which all require settings.write.
     policy: {
       requiredScopes: ["settings.write"],
       allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
     summary: "Live voice preflight",
     description:
-      "Ensure cloud speech defaulting has run, then report whether live voice can start.",
+      "Report whether live voice can start with the current speech credentials.",
     tags: ["live-voice"],
     responseBody: z.object({
       status: z.enum(["ready", "not-ready"]),

package/src/runtime/routes/secret-routes.ts

@@ -16,7 +16,6 @@ import {
 } from "../../acp/acp-credentials.js";
 import { syncAvatarToCloud } from "../../avatar/sync-avatar.js";
 import { syncWorkspaceIdentityToPlatform } from "../../cloud/sync-identity.js";
-import { maybeDefaultSpeechToCloud } from "../../config/cloud-speech-defaults.js";
 import { getCloudAssistantId } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
 import { getCesClient } from "../../credential-execution/ces-runtime.js";
@@ -342,11 +341,6 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           await refreshProvidersForRotatedCredential(service, field);
         }
         if (field === "assistant_api_key") {
-          // Managed-speech availability needs the API key and the assistant
-          // ID. Fire on each write that completes a piece of that set; the
-          // hook no-ops until the connection is complete.
-          // Detached, must not block the response.
-          void maybeDefaultSpeechToCloud();
           // Same last-write-wins shape: the startup syncs no-op before live
           // registration, so re-enqueue them here. Both dedup and no-op until
           // the client and assistant id exist.

package/src/runtime/routes/tts-routes.ts

@@ -8,7 +8,6 @@
 import { z } from "zod";
 
 import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
-import { managedSpeechVoices } from "../../cloud/cloud-speech.js";
 import { getConfig } from "../../config/loader.js";
 import { listCatalogProvidersForDisplay } from "../../tts/provider-catalog.js";
 import {
@@ -132,17 +131,6 @@ function handleListTtsProviders() {
   return { providers: listCatalogProvidersForDisplay() };
 }
 
-async function handleListCloudVoices() {
-  const result = await managedSpeechVoices();
-  if (!result.ok) {
-    if (result.kind === "unavailable") {
-      throw new ServiceUnavailableError(result.message);
-    }
-    throw new BadGatewayError(result.message);
-  }
-  return result.value;
-}
-
 async function handleSynthesizeTts({ body }: RouteHandlerArgs) {
   if (!body?.text || typeof body.text !== "string") {
     throw new BadRequestError("text is required");
@@ -234,32 +222,6 @@ export const ROUTES: RouteDefinition[] = [
     }),
     handler: handleListTtsProviders,
   },
-  {
-    operationId: "tts_managed_voices",
-    endpoint: "tts/managed-voices",
-    method: "GET",
-    policy: {
-      requiredScopes: ["settings.read"],
-      allowedPrincipalTypes: ACTOR_PRINCIPALS,
-    },
-    summary: "List managed TTS voices",
-    description:
-      "Return the voices offered by Cadet Cloud TTS, fetched live from the cloud. Only currently-usable voices are returned; defaultModel is always one of them (null when none are offered).",
-    tags: ["tts"],
-    responseBody: z.object({
-      voices: z.array(
-        z.object({
-          model: z.string(),
-          label: z.string(),
-          description: z.string(),
-          sampleUrl: z.string(),
-          source: z.string(),
-        }),
-      ),
-      defaultModel: z.string().nullable(),
-    }),
-    handler: handleListCloudVoices,
-  },
   {
     operationId: "tts_synthesize",
     endpoint: "tts/synthesize",

package/src/schedule/__tests__/plugin-schedule-reconciler.test.ts

@@ -3,19 +3,13 @@
  *
  * Fixture plugin directories are written under the (per-test-process)
  * workspace plugins dir and converged against the real schedule store; the
- * only stubs are the notification emitter (recorded for assertions) and the
- * background-wake publisher (kept out for hermeticity, mirroring
- * schedule-store.test.ts).
+ * only stub is the notification emitter (recorded for assertions).
  */
 
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../../background-wake/publisher.js", () => ({
-  refreshBackgroundWakeIntent: () => {},
-}));
-
 const emittedSignals: Array<Record<string, unknown>> = [];
 
 /** When set, merged into the next emit results (e.g. a failure reason). */

package/src/schedule/__tests__/worker-mcp-readiness.test.ts

@@ -32,10 +32,6 @@ mock.module("../../daemon/process-message.js", () => ({
   processMessageInBackground: async () => {},
 }));
 
-mock.module("../../background-wake/publisher.js", () => ({
-  refreshBackgroundWakeIntent: () => {},
-}));
-
 mock.module("../../daemon/disk-pressure-background-gate.js", () => ({
   checkDiskPressureBackgroundGate: () => ({
     action: "allow",

package/src/schedule/schedule-store.ts

@@ -49,13 +49,6 @@ const logger = getLogger("schedule-store");
 
 function notifySchedulesChanged(): void {
   publishSchedulesChanged();
-  void import("../background-wake/publisher.js")
-    .then(({ refreshBackgroundWakeIntent }) =>
-      refreshBackgroundWakeIntent("schedule-changed"),
-    )
-    .catch((err) =>
-      logger.warn({ err }, "Failed to queue background wake refresh"),
-    );
 }
 
 export type ScheduleMode =

package/src/schedule/scheduler.ts

@@ -1,4 +1,3 @@
-import { refreshBackgroundWakeIntent } from "../background-wake/publisher.js";
 import { resolveSingleRouteProfileKey } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { findConversationOrSubagent } from "../daemon/conversation-registry.js";
@@ -556,10 +555,6 @@ export function startScheduler(): SchedulerHandle {
     },
   };
 
-  // Publish the initial background wake intent now that the scheduler is live
-  // and its schedules are visible to `computeNextBackgroundWakeIntent`.
-  refreshBackgroundWakeIntent("daemon-startup");
-
   return instance;
 }
 

package/src/schedule/worker.ts

@@ -144,7 +144,7 @@ async function main(): Promise<void> {
   // standalone process must do it itself so getCloudBaseUrl() resolves to
   // the persisted platform environment instead of the CADET_ENVIRONMENT
   // default — otherwise valid credentials are sent to the wrong platform and
-  // rejected for both inference and background-wake requests.
+  // rejected for inference requests.
   await ensureCloudIdentityIds();
 
   // This process is the sole runner of schedule execution and hosts real agent

package/src/stt/__tests__/daemon-batch-transcriber.test.ts

@@ -610,16 +610,8 @@ describe("normalizeSttError", () => {
   });
 });
 
-describe("cadet factory case", () => {
-  test("constructs the cloud transcriber with no API key", () => {
-    const transcriber = createDaemonBatchTranscriber(null, "cadet");
-    expect(transcriber?.providerId).toBe("cadet");
-    expect(transcriber?.boundaryId).toBe("daemon-batch");
-  });
-
-  test("still returns null for key-based providers without a key", () => {
-    expect(createDaemonBatchTranscriber(null, "deepgram")).toBeNull();
-  });
+test("still returns null for key-based providers without a key", () => {
+  expect(createDaemonBatchTranscriber(null, "deepgram")).toBeNull();
 });
 
 describe("deepgram-flux factory case", () => {

package/src/stt/daemon-batch-transcriber.ts

@@ -205,32 +205,6 @@ export function normalizeSttError(err: unknown): SttError {
   return new SttError("provider-error", message);
 }
 
-// ---------------------------------------------------------------------------
-// Cadet Cloud adapter — implements BatchTranscriber on top of the
-// platform's cloud speech endpoint. No API key: the cloud connection
-// is the credential.
-// ---------------------------------------------------------------------------
-
-class CadetManagedBatchTranscriber implements BatchTranscriber {
-  readonly providerId = "cadet" as const;
-  readonly boundaryId = "daemon-batch" as const;
-
-  constructor(private readonly language: string | undefined) {}
-
-  async transcribe(
-    request: SttTranscribeRequest,
-  ): Promise<SttTranscribeResult> {
-    const { cadetCloudTranscribe } =
-      await import("../providers/speech-to-text/cadet-cloud.js");
-    return cadetCloudTranscribe(
-      request.audio,
-      request.mimeType,
-      request.signal,
-      this.language,
-    );
-  }
-}
-
 /**
  * Create a `BatchTranscriber` for the daemon-batch boundary.
  *
@@ -241,10 +215,9 @@ class CadetManagedBatchTranscriber implements BatchTranscriber {
  * is unavailable.
  *
  * `language` is the spoken language, forwarded to providers whose batch API
- * accepts one: Deepgram (where `"multi"` also pins nova-3), xAI (where
+ * accepts one: Deepgram (where `"multi"` also pins nova-3) and xAI (where
  * `"multi"` is dropped because it is a Deepgram-specific value, not a
- * language code), and the Cadet Cloud path, whose cloud proxy passes
- * it to Deepgram server-side. Whisper and Gemini auto-detect natively and
+ * language code). Whisper and Gemini auto-detect natively and
  * take no language parameter, so it is silently ignored for them.
  *
  * Throws an {@link SttError} for a provider with no batch endpoint at all,
@@ -255,11 +228,6 @@ export function createDaemonBatchTranscriber(
   providerId: SttProviderId,
   language?: string,
 ): BatchTranscriber | null {
-  // Cloud speech authenticates via the cloud connection, not an API
-  // key. Callers pass canonical ids; the resolver maps legacy ones first.
-  if (providerId === "cadet") {
-    return new CadetManagedBatchTranscriber(language);
-  }
   if (!apiKey) {
     return null;
   }
@@ -274,11 +242,9 @@ export function createDaemonBatchTranscriber(
     case "xai":
       return new XAIBatchTranscriber(apiKey, language);
     case "deepgram-flux":
-    case "cadet-flux":
       // Same copy the resolver raises, so a direct factory caller and a
-      // config-driven one report the mismatch identically. Both Flux
-      // variants are streaming-only: the model has no batch endpoint, BYOK
-      // or managed.
+      // config-driven one report the mismatch identically. Flux is
+      // streaming-only: the model has no batch endpoint.
       throw new SttError("provider-error", batchBoundaryGapReason(providerId), {
         userFacing: true,
       });

package/src/stt/types.ts

@@ -52,15 +52,7 @@ export type SttProviderId =
    */
   | "deepgram-flux"
   | "google-gemini"
-  | "xai"
-  | "cadet"
-  /**
-   * Cloud Flux: the same conversational model as `deepgram-flux`, reached
-   * through the cloud's speech relay instead of a Deepgram key. Dials the
-   * relay's STT v2 endpoint asking for native Flux frames, so it keeps the
-   * turn events the relay's default v1-shaped translation drops.
-   */
-  | "cadet-flux";
+  | "xai";
 
 /**
  * Telephony-specific STT capability class.