@mycadet/assistant 0.12.7 → 0.12.8

package/src/providers/speech-to-text/__tests__/{cadet-managed.test.ts → cadet-cloud.test.ts}

@@ -4,41 +4,41 @@ import { SttError } from "../../../stt/types.js";
 import { describeSttFailure } from "../../voice-error-copy.js";
 
 let mockTranscribeResult: unknown;
-let mockClient: { platformAssistantId: string } | null = null;
+let mockClient: { cloudAssistantId: string } | null = null;
 
-mock.module("../../../platform/managed-speech.js", () => ({
+mock.module("../../../cloud/cloud-speech.js", () => ({
   managedSpeechTranscribe: async () => mockTranscribeResult,
 }));
 
-mock.module("../../../platform/client.js", () => ({
-  CadetPlatformClient: {
+mock.module("../../../cloud/client.js", () => ({
+  CadetCloudClient: {
     create: async () => mockClient,
   },
 }));
 
 import {
-  cadetManagedSpeechAvailable,
-  cadetManagedTranscribe,
-  sttErrorFromManagedSpeech,
-} from "../cadet-managed.js";
+  cadetCloudSpeechAvailable,
+  cadetCloudTranscribe,
+  sttErrorFromCloudSpeech,
+} from "../cadet-cloud.js";
 
-describe("cadetManagedSpeechAvailable", () => {
+describe("cadetCloudSpeechAvailable", () => {
   test("true with a connected platform client", async () => {
-    mockClient = { platformAssistantId: "asst-1" };
-    expect(await cadetManagedSpeechAvailable()).toBe(true);
+    mockClient = { cloudAssistantId: "asst-1" };
+    expect(await cadetCloudSpeechAvailable()).toBe(true);
   });
 
   test("false without a client or without an assistant ID", async () => {
     mockClient = null;
-    expect(await cadetManagedSpeechAvailable()).toBe(false);
-    mockClient = { platformAssistantId: "" };
-    expect(await cadetManagedSpeechAvailable()).toBe(false);
+    expect(await cadetCloudSpeechAvailable()).toBe(false);
+    mockClient = { cloudAssistantId: "" };
+    expect(await cadetCloudSpeechAvailable()).toBe(false);
   });
 });
 
-describe("cadetManagedTranscribe", () => {
+describe("cadetCloudTranscribe", () => {
   beforeEach(() => {
-    mockClient = { platformAssistantId: "asst-1" };
+    mockClient = { cloudAssistantId: "asst-1" };
   });
 
   test("returns the transcription text", async () => {
@@ -46,9 +46,9 @@ describe("cadetManagedTranscribe", () => {
       ok: true,
       value: { text: "hello", durationSeconds: 2 },
     };
-    expect(await cadetManagedTranscribe(Buffer.from([1]), "audio/wav")).toEqual(
-      { text: "hello" },
-    );
+    expect(await cadetCloudTranscribe(Buffer.from([1]), "audio/wav")).toEqual({
+      text: "hello",
+    });
   });
 
   test("throws a normalized SttError on failure", async () => {
@@ -59,12 +59,12 @@ describe("cadetManagedTranscribe", () => {
       message: "slow down",
     };
     await expect(
-      cadetManagedTranscribe(Buffer.from([1]), "audio/wav"),
+      cadetCloudTranscribe(Buffer.from([1]), "audio/wav"),
     ).rejects.toMatchObject({ name: "SttError", category: "rate-limit" });
   });
 });
 
-describe("sttErrorFromManagedSpeech", () => {
+describe("sttErrorFromCloudSpeech", () => {
   const cases: Array<{
     name: string;
     failure: Record<string, unknown>;
@@ -137,14 +137,14 @@ describe("sttErrorFromManagedSpeech", () => {
     // non-user-facing so describeSttFailure emits friendly category copy
     // instead of leaking a raw HTTP status — except a bare auth status, whose
     // friendly copy would be the wrong BYOK "check your API key" guidance, so it
-    // gets a sanitized platform-connection message surfaced verbatim.
+    // gets a sanitized cloud-connection message surfaced verbatim.
     {
       name: "401 without detail → auth, user-facing sanitized reconnect copy",
       failure: {
         ok: false,
         kind: "platform-error",
         status: 401,
-        message: "Managed speech transcription failed (platform returned 401).",
+        message: "Cloud speech transcription failed (platform returned 401).",
       },
       category: "auth",
       userFacing: true,
@@ -157,7 +157,7 @@ describe("sttErrorFromManagedSpeech", () => {
         ok: false,
         kind: "platform-error",
         status: 403,
-        message: "Managed speech transcription failed (platform returned 403).",
+        message: "Cloud speech transcription failed (platform returned 403).",
       },
       category: "auth",
       userFacing: true,
@@ -170,7 +170,7 @@ describe("sttErrorFromManagedSpeech", () => {
         ok: false,
         kind: "platform-error",
         status: 429,
-        message: "Managed speech transcription failed (platform returned 429).",
+        message: "Cloud speech transcription failed (platform returned 429).",
       },
       category: "rate-limit",
       userFacing: false,
@@ -181,7 +181,7 @@ describe("sttErrorFromManagedSpeech", () => {
         ok: false,
         kind: "platform-error",
         status: 413,
-        message: "Managed speech transcription failed (platform returned 413).",
+        message: "Cloud speech transcription failed (platform returned 413).",
       },
       category: "invalid-audio",
       userFacing: false,
@@ -192,7 +192,7 @@ describe("sttErrorFromManagedSpeech", () => {
         ok: false,
         kind: "platform-error",
         status: 502,
-        message: "Managed speech transcription failed (platform returned 502).",
+        message: "Cloud speech transcription failed (platform returned 502).",
       },
       category: "provider-error",
       userFacing: false,
@@ -208,8 +208,8 @@ describe("sttErrorFromManagedSpeech", () => {
     messageExcludes,
   } of cases) {
     test(name, () => {
-      const err = sttErrorFromManagedSpeech(
-        failure as Parameters<typeof sttErrorFromManagedSpeech>[0],
+      const err = sttErrorFromCloudSpeech(
+        failure as Parameters<typeof sttErrorFromCloudSpeech>[0],
       );
       expect(err).toBeInstanceOf(SttError);
       expect(err.category).toBe(category as SttError["category"]);
@@ -228,8 +228,8 @@ describe("sttErrorFromManagedSpeech", () => {
 });
 
 describe("describeSttFailure over managed STT failures", () => {
-  test("surfaces a platform-supplied detail verbatim", () => {
-    const err = sttErrorFromManagedSpeech({
+  test("surfaces a cloud-supplied detail verbatim", () => {
+    const err = sttErrorFromCloudSpeech({
       ok: false,
       kind: "platform-error",
       status: 429,
@@ -242,11 +242,11 @@ describe("describeSttFailure over managed STT failures", () => {
   });
 
   test("replaces a bare HTTP-status fallback with friendly category copy", () => {
-    const err = sttErrorFromManagedSpeech({
+    const err = sttErrorFromCloudSpeech({
       ok: false,
       kind: "platform-error",
       status: 429,
-      message: "Managed speech transcription failed (platform returned 429).",
+      message: "Cloud speech transcription failed (platform returned 429).",
     });
     const copy = describeSttFailure(err, "cadet");
     expect(copy).not.toContain("platform returned 429");
@@ -254,11 +254,11 @@ describe("describeSttFailure over managed STT failures", () => {
   });
 
   test("bare auth failure gets sanitized reconnect copy, not the BYOK rewrite", () => {
-    const err = sttErrorFromManagedSpeech({
+    const err = sttErrorFromCloudSpeech({
       ok: false,
       kind: "platform-error",
       status: 401,
-      message: "Managed speech transcription failed (platform returned 401).",
+      message: "Cloud speech transcription failed (platform returned 401).",
     });
     const copy = describeSttFailure(err, "cadet");
     // Managed STT holds no local key: the "check your API key in Settings →

package/src/providers/speech-to-text/__tests__/deepgram-flux-realtime.test.ts

@@ -731,7 +731,7 @@ describe("DeepgramFluxRealtimeTranscriber", () => {
     });
 
     test("hands frames the Flux parser makes nothing of to the wrapper", async () => {
-      // This is how tunnel_error reaches the managed wrapper: it rides the
+      // This is how tunnel_error reaches the cloud wrapper: it rides the
       // same socket but is not a Flux frame.
       const unhandled: Record<string, unknown>[] = [];
       await startSession({

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

@@ -58,32 +58,32 @@ function seedProviderKeys(record: Record<string, string>): void {
   }
 }
 
-// -- Cadet managed availability mock --------------------------------------
+// -- Cadet Cloud availability mock --------------------------------------
 
 let mockCadetAvailable = false;
 
 /**
- * Arguments the managed batch adapter was called with. The managed path has
+ * Arguments the cloud batch adapter was called with. The cloud path has
  * no constructor to spy on (the cloud connection is the credential), so
  * the language it forwards is observable only at the transcribe call.
  */
-const cadetManagedTranscribeCalls: Array<{
+const cadetCloudTranscribeCalls: Array<{
   mimeType: string;
   language: string | undefined;
 }> = [];
 
-mock.module("../cadet-managed.js", () => ({
-  cadetManagedSpeechAvailable: async () => mockCadetAvailable,
-  cadetManagedTranscribe: async (
+mock.module("../cadet-cloud.js", () => ({
+  cadetCloudSpeechAvailable: async () => mockCadetAvailable,
+  cadetCloudTranscribe: async (
     _audio: Buffer,
     mimeType: string,
     _signal?: AbortSignal,
     language?: string,
   ) => {
-    cadetManagedTranscribeCalls.push({ mimeType, language });
+    cadetCloudTranscribeCalls.push({ mimeType, language });
     return { text: "" };
   },
-  sttErrorFromManagedSpeech: (failure: unknown) => new Error(String(failure)),
+  sttErrorFromCloudSpeech: (failure: unknown) => new Error(String(failure)),
 }));
 
 const cadetStreamCtorCalls: Array<{ connection: unknown; options: unknown }> =
@@ -98,7 +98,7 @@ mock.module("../cadet-speech-relay-connection.js", () => ({
   resolveSpeechRelayConnection: async () => mockTunnelConnection,
 }));
 
-mock.module("../cadet-managed-realtime.js", () => ({
+mock.module("../cadet-cloud-realtime.js", () => ({
   CadetManagedRealtimeTranscriber: class {
     readonly providerId = "cadet";
     readonly boundaryId = "daemon-streaming";
@@ -108,13 +108,13 @@ mock.module("../cadet-managed-realtime.js", () => ({
   },
 }));
 
-/** Constructor calls for the managed Flux transcriber (`cadet-flux`). */
+/** Constructor calls for the cloud Flux transcriber (`cadet-flux`). */
 const cadetFluxStreamCtorCalls: Array<{
   connection: unknown;
   options: unknown;
 }> = [];
 
-mock.module("../cadet-managed-flux-realtime.js", () => ({
+mock.module("../cadet-cloud-flux-realtime.js", () => ({
   CadetManagedFluxRealtimeTranscriber: class {
     readonly providerId = "cadet-flux";
     readonly boundaryId = "daemon-streaming";
@@ -1136,7 +1136,7 @@ describe("cadet-flux managed resolution", () => {
     cadetFluxStreamCtorCalls.length = 0;
   });
 
-  test("streaming resolver constructs the managed Flux adapter over the same relay connection", async () => {
+  test("streaming resolver constructs the cloud Flux adapter over the same relay connection", async () => {
     mockCadetAvailable = true;
     applyConfig({ provider: "cadet-flux", language: "es" });
 
@@ -1258,7 +1258,7 @@ describe("cadet managed resolution", () => {
     expect(cadetStreamCtorCalls).toEqual([
       {
         connection: mockTunnelConnection,
-        // No language is configured here, so the managed default rides along
+        // No language is configured here, so the cloud default rides along
         // with the connection plumbing this test is about.
         options: { sampleRate: 24000, language: "multi" },
       },
@@ -1314,7 +1314,7 @@ describe("resolveStreamingTranscriber language plumbing", () => {
   });
 
   test("managed sessions forward services.stt.language to the relay adapter", async () => {
-    // The managed path is why this plumbing exists: tunnel allowlists
+    // The cloud path is why this plumbing exists: tunnel allowlists
     // `language` and pins nova-3, so "multi" reaches Deepgram's
     // code-switching mode without any platform-side change.
     mockCadetAvailable = true;
@@ -1410,7 +1410,7 @@ describe("resolveStreamingTranscriber language plumbing", () => {
     });
   });
 
-  test("no configured language falls to multilingual on the managed relay", async () => {
+  test("no configured language falls to multilingual on the cloud relay", async () => {
     // The relay dials Deepgram server-side, so it inherits the same English
     // default and needs the same fill-in.
     mockCadetAvailable = true;
@@ -1521,10 +1521,10 @@ describe("resolveStreamingTranscriber language plumbing", () => {
     });
   });
 
-  test("managed batch forwards the configured language to the platform", async () => {
-    // The platform proxy passes it to Deepgram server-side, so a managed
+  test("managed batch forwards the configured language to the cloud", async () => {
+    // The cloud proxy passes it to Deepgram server-side, so a cloud
     // voice note decodes in the same language the live session does.
-    cadetManagedTranscribeCalls.length = 0;
+    cadetCloudTranscribeCalls.length = 0;
     mockCadetAvailable = true;
     applyConfig({ provider: "cadet", language: "ta" });
 
@@ -1534,14 +1534,14 @@ describe("resolveStreamingTranscriber language plumbing", () => {
       mimeType: "audio/ogg",
     });
 
-    expect(cadetManagedTranscribeCalls).toHaveLength(1);
-    expect(cadetManagedTranscribeCalls[0]?.language).toBe("ta");
+    expect(cadetCloudTranscribeCalls).toHaveLength(1);
+    expect(cadetCloudTranscribeCalls[0]?.language).toBe("ta");
   });
 
   test("managed batch falls to multilingual when no language is configured", async () => {
-    // The gap this closes: managed voice notes used to decode as English no
+    // The gap this closes: cloud voice notes used to decode as English no
     // matter what the user had chosen, because nothing was forwarded.
-    cadetManagedTranscribeCalls.length = 0;
+    cadetCloudTranscribeCalls.length = 0;
     mockCadetAvailable = true;
     applyConfig({ provider: "cadet" });
 
@@ -1551,8 +1551,8 @@ describe("resolveStreamingTranscriber language plumbing", () => {
       mimeType: "audio/ogg",
     });
 
-    expect(cadetManagedTranscribeCalls).toHaveLength(1);
-    expect(cadetManagedTranscribeCalls[0]?.language).toBe("multi");
+    expect(cadetCloudTranscribeCalls).toHaveLength(1);
+    expect(cadetCloudTranscribeCalls[0]?.language).toBe("multi");
   });
 
   test("batch resolution falls to multilingual when no language is configured", async () => {
@@ -1611,7 +1611,7 @@ describe("streaming capability matches the streaming factory", () => {
     xai: "xai",
     // cadet's credential is the cloud connection, mocked below.
     cadet: "cadet",
-    // Managed Flux rides the same platform connection.
+    // Cloud Flux rides the same platform connection.
     "cadet-flux": "cadet",
   };
 
@@ -1625,7 +1625,7 @@ describe("streaming capability matches the streaming factory", () => {
   function seedCredentialsFor(id: SttProviderId): void {
     const credential = STREAMING_CREDENTIAL[id];
     expect(credential).toBeDefined();
-    // Both managed entries authenticate with the platform connection rather
+    // Both managed entries authenticate with the cloud connection rather
     // than a stored API key, and both dial through the same relay.
     const managed = id === "cadet" || id === "cadet-flux";
     mockCadetAvailable = managed;
@@ -1832,7 +1832,7 @@ describe("sttCredentialGapReason", () => {
 
 describe("effectiveSttLanguage", () => {
   test("fills the unset case only where unset would mean English", () => {
-    // Deepgram and the managed relay decode language-less audio as English,
+    // Deepgram and the cloud relay decode language-less audio as English,
     // so leaving them unset is a silent pin rather than a neutral state.
     expect(effectiveSttLanguage("deepgram", undefined)).toBe("multi");
     expect(effectiveSttLanguage("cadet", undefined)).toBe("multi");

package/src/providers/speech-to-text/{cadet-managed-flux-realtime.ts → cadet-cloud-flux-realtime.ts}

@@ -1,5 +1,5 @@
 /**
- * Managed Flux STT through the gateway's speech relay
+ * Cloud Flux STT through the gateway's speech relay
  * (gateway -> tunnel -> Deepgram Flux; tunnel contact is gateway-only).
  *
  * Composes {@link DeepgramFluxRealtimeTranscriber} against the relay's
@@ -39,7 +39,7 @@ import {
 } from "./cadet-speech-relay-connection.js";
 import { DeepgramFluxRealtimeTranscriber } from "./deepgram-flux-realtime.js";
 
-const log = getLogger("cadet-managed-flux-realtime");
+const log = getLogger("cadet-cloud-flux-realtime");
 
 /** Managed STT v2: tunnel resolves this to Deepgram's Flux `/v2/listen`. */
 const STT_STREAM_PATH = "/v2/speech/stt/stream";
@@ -246,9 +246,7 @@ export class CadetManagedFluxRealtimeTranscriber implements StreamingTranscriber
    * error and ends the stream.
    */
   private beginRedial(): void {
-    log.info(
-      "Managed Flux relay session hit tunnel's duration cap, re-dialing",
-    );
+    log.info("Cloud Flux relay session hit tunnel's duration cap, re-dialing");
     this.inner = null;
     this.turnIndexOffset = this.latestTurnIndex + 1;
     void (async () => {
@@ -259,7 +257,7 @@ export class CadetManagedFluxRealtimeTranscriber implements StreamingTranscriber
           return;
         }
         this.inner = inner;
-        log.info("Managed Flux relay re-dial complete; session continues");
+        log.info("Cloud Flux relay re-dial complete; session continues");
       } catch (err) {
         if (this.stopping) {
           return;
@@ -276,7 +274,7 @@ export class CadetManagedFluxRealtimeTranscriber implements StreamingTranscriber
           this.emit({
             type: "error",
             category: "provider-error",
-            message: `Managed Flux relay re-dial failed after the session cap: ${
+            message: `Cloud Flux relay re-dial failed after the session cap: ${
               err instanceof Error ? err.message : String(err)
             }`,
           });
@@ -300,7 +298,7 @@ export class CadetManagedFluxRealtimeTranscriber implements StreamingTranscriber
     } catch (err) {
       log.warn(
         { error: err },
-        "Listener error in Cadet managed Flux realtime adapter",
+        "Listener error in Cadet Cloud Flux realtime adapter",
       );
     }
   }

package/src/providers/speech-to-text/{cadet-managed-realtime.ts → cadet-cloud-realtime.ts}

@@ -34,7 +34,7 @@ import {
 } from "./cadet-speech-relay-connection.js";
 import { DeepgramRealtimeTranscriber } from "./deepgram-realtime.js";
 
-const log = getLogger("cadet-managed-realtime");
+const log = getLogger("cadet-cloud-realtime");
 
 const STT_STREAM_PATH = "/v1/speech/stt/stream";
 
@@ -280,7 +280,7 @@ export class CadetManagedRealtimeTranscriber implements StreamingTranscriber {
           this.emit({
             type: "error",
             category: "provider-error",
-            message: `Managed speech relay re-dial failed after the session cap: ${
+            message: `Cloud speech relay re-dial failed after the session cap: ${
               err instanceof Error ? err.message : String(err)
             }`,
           });
@@ -304,7 +304,7 @@ export class CadetManagedRealtimeTranscriber implements StreamingTranscriber {
     } catch (err) {
       log.warn(
         { error: err },
-        "Listener error in Cadet managed realtime adapter",
+        "Listener error in Cadet Cloud realtime adapter",
       );
     }
   }

package/src/providers/speech-to-text/{cadet-managed.ts → cadet-cloud.ts}

@@ -1,52 +1,50 @@
 /**
- * Cadet-managed batch STT: transcription through the platform's managed
+ * Cadet Cloud batch STT: transcription through the cloud's managed
  * speech endpoint (Cadet-held Deepgram key, billed to Cadet credits). No
- * provider API key exists on this machine — availability is the platform
+ * provider API key exists on this machine — availability is the cloud
  * connection itself.
  */
 
 import {
+  type CloudSpeechResult,
   managedSpeechAvailable,
-  type ManagedSpeechResult,
   managedSpeechTranscribe,
-} from "../../platform/managed-speech.js";
+} from "../../cloud/cloud-speech.js";
 import {
   SttError,
   type SttErrorCategory,
   type SttTranscribeResult,
 } from "../../stt/types.js";
 
-type ManagedSpeechFailure = Extract<ManagedSpeechResult<never>, { ok: false }>;
+type CloudSpeechFailure = Extract<CloudSpeechResult<never>, { ok: false }>;
 
 /**
- * Whether managed speech can be used at all: a cloud connection with a
+ * Whether cloud speech can be used at all: a cloud connection with a
  * platform assistant ID. The credential-store lookup used for API-key
  * providers does not apply to `cadet`.
  */
-export async function cadetManagedSpeechAvailable(): Promise<boolean> {
+export async function cadetCloudSpeechAvailable(): Promise<boolean> {
   return managedSpeechAvailable();
 }
 
 /**
- * Map a managed-speech failure onto the normalized STT error categories.
+ * Map a cloud-speech failure onto the normalized STT error categories.
  *
  * `insufficient_balance` gets a user-actionable message — the fix is topping
  * up Cadet credits, not editing provider config.
  *
- * Managed speech has no provider API key on this machine, so the BYOK "check
+ * Cloud speech has no provider API key on this machine, so the BYOK "check
  * your API key" rewrite never applies. A failure is flagged `userFacing` —
  * surfaced verbatim by `describeSttFailure` — when it carries actionable
- * remediation: a platform reconnect (`unavailable`), a credit top-up
- * (`insufficient_balance`), or the platform's own `detail` message. A failure
+ * remediation: a cloud reconnect (`unavailable`), a credit top-up
+ * (`insufficient_balance`), or the cloud's own `detail` message. A failure
  * that fell back to a bare HTTP status (no `detail`) is left non-user-facing so
  * `describeSttFailure` emits friendly category copy instead of leaking the raw
  * status — except a bare auth status (401/403), which would be rewritten to the
  * wrong BYOK "check your API key" guidance, so it gets its own sanitized
- * platform-connection message.
+ * cloud-connection message.
  */
-export function sttErrorFromManagedSpeech(
-  failure: ManagedSpeechFailure,
-): SttError {
+export function sttErrorFromCloudSpeech(failure: CloudSpeechFailure): SttError {
   const hasDetail = failure.detail !== undefined;
   const userFacing =
     failure.kind === "unavailable" ||
@@ -70,12 +68,12 @@ export function sttErrorFromManagedSpeech(
       // A bare auth failure must stay user-facing so describeSttFailure skips
       // its BYOK "check your API key" rewrite — managed STT has no local key.
       // `managed()` would be non-user-facing here (see `userFacing` above), so
-      // construct the sanitized platform-connection message directly.
+      // construct the sanitized cloud-connection message directly.
       return hasDetail
         ? managed("auth", failure.message)
         : new SttError(
             "auth",
-            "Cadet couldn't authenticate with the platform while transcribing — reconnect your Cadet account, then retry.",
+            "Cadet couldn't authenticate with the cloud while transcribing — reconnect your Cadet account, then retry.",
             { userFacing: true },
           );
     case 429:
@@ -88,10 +86,10 @@ export function sttErrorFromManagedSpeech(
 }
 
 /**
- * Transcribe a complete audio buffer via the platform. Throws {@link SttError}
+ * Transcribe a complete audio buffer via the cloud. Throws {@link SttError}
  * on failure (already normalized — `normalizeSttError` passes it through).
  */
-export async function cadetManagedTranscribe(
+export async function cadetCloudTranscribe(
   audio: Buffer,
   mimeType: string,
   signal?: AbortSignal,
@@ -104,7 +102,7 @@ export async function cadetManagedTranscribe(
     language,
   });
   if (!result.ok) {
-    throw sttErrorFromManagedSpeech(result);
+    throw sttErrorFromCloudSpeech(result);
   }
   return { text: result.value.text };
 }

package/src/providers/speech-to-text/cadet-speech-relay-connection.ts

@@ -1,5 +1,5 @@
 /**
- * Shared plumbing for dialing the GATEWAY's managed speech relay
+ * Shared plumbing for dialing the GATEWAY's cloud speech relay
  * (`/v1/speech/{stt,tts}/stream`): connection resolution, and mapping the
  * relay's error contract onto SttError categories.
  *
@@ -71,7 +71,7 @@ export async function resolveSpeechRelayConnection(): Promise<SpeechRelayConnect
   } catch (err) {
     log.warn(
       { error: err instanceof Error ? err.message : String(err) },
-      "Managed speech relay unavailable: cannot mint a gateway service token",
+      "Cloud speech relay unavailable: cannot mint a gateway service token",
     );
     return null;
   }
@@ -110,30 +110,30 @@ export function mapTunnelError(error: TunnelErrorInfo): {
       return {
         category: "auth",
         message:
-          "Managed speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.",
+          "Cloud speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.",
       };
     case "invalid_token":
       return {
         category: "auth",
         message:
-          "The assistant's managed-speech session was rejected by its gateway — the services may be out of sync; restart the assistant.",
+          "The assistant's cloud-speech session was rejected by its gateway — the services may be out of sync; restart the assistant.",
       };
     case "insufficient_balance":
       return {
         category: "provider-error",
         message:
-          "Managed speech is paused: your Cadet organization is out of credits. Top up credits to continue.",
+          "Cloud speech is paused: your Cadet organization is out of credits. Top up credits to continue.",
       };
     case "provider_unreachable":
     case "upstream_error":
       return {
         category: "provider-error",
-        message: `Managed speech relay could not reach the speech provider (${error.code}).`,
+        message: `Cloud speech relay could not reach the speech provider (${error.code}).`,
       };
     default:
       return {
         category: "provider-error",
-        message: `Managed speech relay error: ${error.code}${
+        message: `Cloud speech relay error: ${error.code}${
           error.detail ? ` — ${error.detail}` : ""
         }`,
       };

package/src/providers/speech-to-text/deepgram-flux-frames.ts

@@ -307,7 +307,7 @@ const EOT_TIMEOUT_MS_RANGE = { min: 500, max: 60_000 } as const;
 export interface FluxQueryParamOptions {
   /**
    * Flux model to run, e.g. `"flux-general-en"`. Required when dialing
-   * Deepgram directly. Omitted on the managed relay, which derives the model
+   * Deepgram directly. Omitted on the cloud relay, which derives the model
    * from the spoken language and prices it before dialing, and rejects a
    * client-sent one.
    */
@@ -392,9 +392,9 @@ const FLUX_CODE_SWITCHING = "multi";
 /**
  * The model and optional hint a spoken language selects.
  *
- * Deliberately the same mapping the managed relay applies server-side, so a
+ * Deliberately the same mapping the cloud relay applies server-side, so a
  * language means the same thing whether Flux is reached with your own key or
- * through the platform. Without it a BYOK session pins the English model and
+ * through the cloud. Without it a BYOK session pins the English model and
  * returns English-sounding nonsense for every other language, which is
  * invisible from the transcript alone.
  *

package/src/providers/speech-to-text/deepgram-flux-realtime.ts

@@ -117,7 +117,7 @@ export interface DeepgramFluxRealtimeOptions {
   /** Inactivity timeout in milliseconds. Default: 30_000. */
   inactivityTimeoutMs?: number;
   /**
-   * WebSocket origin to dial. Defaults to Deepgram's own. The managed relay
+   * WebSocket origin to dial. Defaults to Deepgram's own. The cloud relay
    * points this at the gateway, which forwards to tunnel.
    */
   baseUrl?: string;
@@ -130,7 +130,7 @@ export interface DeepgramFluxRealtimeOptions {
    */
   queryAuth?: boolean;
   /**
-   * Omit `model` from the query. The managed relay derives the Flux model
+   * Omit `model` from the query. The cloud relay derives the Flux model
    * from the spoken language and prices it before dialing, so it rejects a
    * client-selected one.
    */
@@ -144,7 +144,7 @@ export interface DeepgramFluxRealtimeOptions {
   /**
    * Spoken language, forwarded to the relay so it can select the Flux model
    * and language hint. Deepgram's own endpoint takes no `language`, so this
-   * is only sent when set, which is the managed path.
+   * is only sent when set, which is the cloud path.
    */
   language?: string;
   /**
@@ -737,7 +737,7 @@ export class DeepgramFluxRealtimeTranscriber implements StreamingTranscriber {
    */
   private buildWebSocketUrl(): string {
     // Dialing Deepgram directly means choosing the model here. The relay
-    // derives it from the language instead, which is why the managed path
+    // derives it from the language instead, which is why the cloud path
     // sends neither.
     const selection = this.omitModelParam
       ? null