@mycadet/assistant 0.12.7 → 0.12.8

package/src/background-wake/background-wake-routes.test.ts

@@ -13,7 +13,7 @@ import type { BackgroundWakeIntent } from "./next-wake.js";
 // the heartbeat mock exposes that too.
 type BackgroundWakeRuntime = {
   scheduler: Pick<SchedulerHandle, "runOnce" | "runDueWorkOnce">;
-  heartbeat: Pick<HeartbeatService, "nextRunAt" | "runManagedWakeIfDue">;
+  heartbeat: Pick<HeartbeatService, "nextRunAt" | "runCloudWakeIfDue">;
 };
 
 let mockScheduler: BackgroundWakeRuntime["scheduler"] | null = null;
@@ -214,7 +214,7 @@ describe("background wake runtime routes", () => {
       actualNextDueAt: dueAt,
       reason: "mixed",
     });
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -226,7 +226,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: dueAt,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 2),
@@ -240,11 +240,11 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).toHaveBeenCalledTimes(1);
-    expect(heartbeatRunManaged).toHaveBeenCalledWith(
+    expect(heartbeatRunCloud).toHaveBeenCalledTimes(1);
+    expect(heartbeatRunCloud).toHaveBeenCalledWith(
       expect.objectContaining({ scheduledFor: NOW }),
     );
-    expect(firstCallArg(heartbeatRunManaged)).not.toHaveProperty("assumeDue");
+    expect(firstCallArg(heartbeatRunCloud)).not.toHaveProperty("assumeDue");
     expect(schedulerRunDue).toHaveBeenCalledTimes(1);
     expect(response).toEqual(acceptedResponse({ reason: "mixed" }));
     expect(lastCompletionPayload()).toEqual({
@@ -255,7 +255,7 @@ describe("background wake runtime routes", () => {
   });
 
   test("drain-due skips heartbeat when it is not due and reports no scheduler work", async () => {
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -264,7 +264,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: Date.now() + 5 * 60_000,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 0),
@@ -276,7 +276,7 @@ describe("background wake runtime routes", () => {
     const response = await handler({ body: drainBodyFixture() });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).not.toHaveBeenCalled();
+    expect(heartbeatRunCloud).not.toHaveBeenCalled();
     expect(schedulerRunDue).toHaveBeenCalledTimes(1);
     expect(response).toEqual(acceptedResponse());
     expect(lastCompletionPayload()).toMatchObject({
@@ -297,7 +297,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: null,
-        runManagedWakeIfDue: mock(async () => ({
+        runCloudWakeIfDue: mock(async () => ({
           due: false,
           completed: 0,
           skipped: 0,
@@ -328,7 +328,7 @@ describe("background wake runtime routes", () => {
       actualNextDueAt: dueAt,
       reason: "heartbeat",
     });
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -340,7 +340,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: dueAt,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 1),
@@ -354,12 +354,12 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).toHaveBeenCalledWith(
+    expect(heartbeatRunCloud).toHaveBeenCalledWith(
       expect.objectContaining({
         scheduledFor: NOW,
       }),
     );
-    expect(firstCallArg(heartbeatRunManaged)).not.toHaveProperty("assumeDue");
+    expect(firstCallArg(heartbeatRunCloud)).not.toHaveProperty("assumeDue");
     expect(schedulerRunDue).toHaveBeenCalledTimes(1);
     expect(response).toEqual(acceptedResponse({ reason: "heartbeat" }));
     expect(lastCompletionPayload()).toMatchObject({
@@ -370,7 +370,7 @@ describe("background wake runtime routes", () => {
   });
 
   test("drain-due does not rerun heartbeat for stale heartbeat drain requests", async () => {
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -379,7 +379,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: Date.now() + 30 * 60_000,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 0),
@@ -393,7 +393,7 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).not.toHaveBeenCalled();
+    expect(heartbeatRunCloud).not.toHaveBeenCalled();
     expect(schedulerRunDue).not.toHaveBeenCalled();
     expect(response).toEqual(acceptedResponse({ reason: "heartbeat" }));
     expect(lastCompletionPayload()).toMatchObject({
@@ -409,7 +409,7 @@ describe("background wake runtime routes", () => {
       actualNextDueAt: dueAt,
       reason: "heartbeat",
     });
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -417,7 +417,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: dueAt,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 0),
@@ -431,10 +431,10 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).toHaveBeenCalledWith(
+    expect(heartbeatRunCloud).toHaveBeenCalledWith(
       expect.objectContaining({ scheduledFor: NOW }),
     );
-    expect(firstCallArg(heartbeatRunManaged)).not.toHaveProperty("assumeDue");
+    expect(firstCallArg(heartbeatRunCloud)).not.toHaveProperty("assumeDue");
     expect(response).toEqual(acceptedResponse({ reason: "refresh" }));
   });
 
@@ -451,7 +451,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: Date.now() + 60_000,
-        runManagedWakeIfDue: mock(async () => ({
+        runCloudWakeIfDue: mock(async () => ({
           due: false,
           completed: 0,
           skipped: 0,
@@ -490,7 +490,7 @@ describe("background wake runtime routes", () => {
       actualNextDueAt: scheduleDueAt,
       reason: "schedule",
     });
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -502,7 +502,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: heartbeatDueAt,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 1),
@@ -516,7 +516,7 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).toHaveBeenCalledWith(
+    expect(heartbeatRunCloud).toHaveBeenCalledWith(
       expect.objectContaining({ scheduledFor: NOW }),
     );
     expect(schedulerRunDue).toHaveBeenCalledTimes(1);
@@ -529,7 +529,7 @@ describe("background wake runtime routes", () => {
   });
 
   test("drain-due does no work for refresh-only wakes with no due intent", async () => {
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -540,7 +540,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: Date.now() + 60_000,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 1),
@@ -554,7 +554,7 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).not.toHaveBeenCalled();
+    expect(heartbeatRunCloud).not.toHaveBeenCalled();
     expect(schedulerRunDue).not.toHaveBeenCalled();
     expect(response).toEqual(acceptedResponse({ reason: "refresh" }));
     expect(lastCompletionPayload()).toMatchObject({
@@ -570,7 +570,7 @@ describe("background wake runtime routes", () => {
       actualNextDueAt: dueAt,
       reason: "mixed",
     });
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -581,7 +581,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: dueAt,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 0),
@@ -598,7 +598,7 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).not.toHaveBeenCalled();
+    expect(heartbeatRunCloud).not.toHaveBeenCalled();
     expect(schedulerRunDue).toHaveBeenCalledWith(
       expect.objectContaining({ minStartBudgetMs: 5_000 }),
     );
@@ -619,7 +619,7 @@ describe("background wake runtime routes", () => {
       actualNextDueAt: dueAt,
       reason: "mixed",
     });
-    const heartbeatRunManaged = mock(async () => ({
+    const heartbeatRunCloud = mock(async () => ({
       due: true,
       completed: 1,
       skipped: 0,
@@ -630,7 +630,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: dueAt,
-        runManagedWakeIfDue: heartbeatRunManaged,
+        runCloudWakeIfDue: heartbeatRunCloud,
       },
       scheduler: {
         runOnce: mock(async () => 1),
@@ -647,7 +647,7 @@ describe("background wake runtime routes", () => {
     });
     await flushBackgroundWakeDrainsForTest();
 
-    expect(heartbeatRunManaged).not.toHaveBeenCalled();
+    expect(heartbeatRunCloud).not.toHaveBeenCalled();
     expect(schedulerRunDue).not.toHaveBeenCalled();
     expect(response).toMatchObject({
       accepted: true,
@@ -669,7 +669,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: Date.now() + 60_000,
-        runManagedWakeIfDue: mock(async () => ({
+        runCloudWakeIfDue: mock(async () => ({
           due: false,
           completed: 0,
           skipped: 0,
@@ -735,7 +735,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: Date.now() + 60_000,
-        runManagedWakeIfDue: mock(async () => ({
+        runCloudWakeIfDue: mock(async () => ({
           due: false,
           completed: 0,
           skipped: 0,
@@ -766,7 +766,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: null,
-        runManagedWakeIfDue: mock(async () => ({
+        runCloudWakeIfDue: mock(async () => ({
           due: false,
           completed: 0,
           skipped: 0,
@@ -802,7 +802,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: null,
-        runManagedWakeIfDue: mock(async () => ({
+        runCloudWakeIfDue: mock(async () => ({
           due: false,
           completed: 0,
           skipped: 0,
@@ -831,7 +831,7 @@ describe("background wake runtime routes", () => {
     setBackgroundWakeRuntime({
       heartbeat: {
         nextRunAt: null,
-        runManagedWakeIfDue: mock(async () => ({
+        runCloudWakeIfDue: mock(async () => ({
           due: false,
           completed: 0,
           skipped: 0,

package/src/background-wake/{platform-client.test.ts → cloud-client.test.ts}

@@ -2,12 +2,12 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { BackgroundWakeIntent } from "./next-wake.js";
 
-let mockPlatformAssistantId: string;
+let mockCloudAssistantId: string;
 let mockClientFetch: ReturnType<typeof mock>;
 let mockCreateClient: ReturnType<typeof mock>;
 
-mock.module("../platform/client.js", () => ({
-  CadetPlatformClient: {
+mock.module("../cloud/client.js", () => ({
+  CadetCloudClient: {
     create: () => mockCreateClient(),
   },
 }));
@@ -17,16 +17,16 @@ const {
   completeBackgroundWakeLease,
   publishBackgroundWakeIntent,
   renewBackgroundWakeLease,
-} = await import("./platform-client.js");
+} = await import("./cloud-client.js");
 
 const NOW = 1_800_000_000_000;
 
 describe("background wake platform client", () => {
   beforeEach(() => {
-    mockPlatformAssistantId = "asst-123";
+    mockCloudAssistantId = "asst-123";
     mockClientFetch = mock(async () => new Response('{"status":"stored"}'));
     mockCreateClient = mock(async () => ({
-      platformAssistantId: mockPlatformAssistantId,
+      cloudAssistantId: mockCloudAssistantId,
       fetch: mockClientFetch,
     }));
   });
@@ -108,7 +108,7 @@ describe("background wake platform client", () => {
   test("clears wake intent with the last computed snapshot when available", async () => {
     mockClientFetch = mock(async () => new Response('{"status":"cleared"}'));
     mockCreateClient = mock(async () => ({
-      platformAssistantId: mockPlatformAssistantId,
+      cloudAssistantId: mockCloudAssistantId,
       fetch: mockClientFetch,
     }));
 
@@ -227,7 +227,7 @@ describe("background wake platform client", () => {
     expect(mockClientFetch).not.toHaveBeenCalled();
 
     mockCreateClient = mock(async () => ({
-      platformAssistantId: "",
+      cloudAssistantId: "",
       fetch: mockClientFetch,
     }));
 
@@ -243,7 +243,7 @@ describe("background wake platform client", () => {
   test("treats Django disabled no-op responses as success", async () => {
     mockClientFetch = mock(async () => new Response('{"status":"disabled"}'));
     mockCreateClient = mock(async () => ({
-      platformAssistantId: mockPlatformAssistantId,
+      cloudAssistantId: mockCloudAssistantId,
       fetch: mockClientFetch,
     }));
 
@@ -257,7 +257,7 @@ describe("background wake platform client", () => {
 
   test("attaches an abort-timeout signal to every platform request", async () => {
     // Guards the publisher's single-in-flight serialization: a wake request
-    // that hangs (half-open socket during a platform reconnect) would wedge the
+    // that hangs (half-open socket during a cloud reconnect) would wedge the
     // in-flight promise and silence every future refresh. Each request must
     // carry a timeout so it rejects instead of hanging forever.
     await publishBackgroundWakeIntent(intentFixture());
@@ -280,7 +280,7 @@ describe("background wake platform client", () => {
       async () => new Response("bad gateway", { status: 502 }),
     );
     mockCreateClient = mock(async () => ({
-      platformAssistantId: mockPlatformAssistantId,
+      cloudAssistantId: mockCloudAssistantId,
       fetch: mockClientFetch,
     }));
 

package/src/background-wake/{platform-client.ts → cloud-client.ts}

@@ -1,4 +1,4 @@
-import { CadetPlatformClient } from "../platform/client.js";
+import { CadetCloudClient } from "../cloud/client.js";
 import type { BackgroundWakeIntent } from "./next-wake.js";
 
 /**
@@ -7,7 +7,7 @@ import type { BackgroundWakeIntent } from "./next-wake.js";
  * Every call here is a lightweight control-plane request (publish/clear the
  * wake intent, renew/complete a lease), so it must settle quickly. The bound
  * exists because the publisher serializes refreshes behind a single in-flight
- * promise: a request that hangs (half-open socket during a platform reconnect)
+ * promise: a request that hangs (half-open socket during a cloud reconnect)
  * would wedge that promise and silence every future refresh. The timeout
  * guarantees each request rejects instead of hanging, so the publisher always
  * makes forward progress.
@@ -34,15 +34,15 @@ type BackgroundWakeIntentSnapshot = Pick<
 export async function publishBackgroundWakeIntent(
   intent: BackgroundWakeIntent,
 ): Promise<BackgroundWakeIntentClientResult> {
-  const client = await CadetPlatformClient.create();
+  const client = await CadetCloudClient.create();
   if (!client) {
     return { status: "skipped", reason: "missing_platform_client" };
   }
-  if (!client.platformAssistantId) {
+  if (!client.cloudAssistantId) {
     return { status: "skipped", reason: "missing_platform_assistant_id" };
   }
 
-  const response = await client.fetch(intentPath(client.platformAssistantId), {
+  const response = await client.fetch(intentPath(client.cloudAssistantId), {
     method: "PUT",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
@@ -63,11 +63,11 @@ export async function publishBackgroundWakeIntent(
 export async function clearBackgroundWakeIntent(
   intentSnapshot: BackgroundWakeIntentSnapshot = null,
 ): Promise<BackgroundWakeIntentClientResult> {
-  const client = await CadetPlatformClient.create();
+  const client = await CadetCloudClient.create();
   if (!client) {
     return { status: "skipped", reason: "missing_platform_client" };
   }
-  if (!client.platformAssistantId) {
+  if (!client.cloudAssistantId) {
     return { status: "skipped", reason: "missing_platform_assistant_id" };
   }
 
@@ -77,7 +77,7 @@ export async function clearBackgroundWakeIntent(
     body.computed_at = toIsoString(intentSnapshot.computedAt);
   }
 
-  const response = await client.fetch(intentPath(client.platformAssistantId), {
+  const response = await client.fetch(intentPath(client.cloudAssistantId), {
     method: "DELETE",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(body),
@@ -91,16 +91,16 @@ export async function clearBackgroundWakeIntent(
 export async function renewBackgroundWakeLease(
   leaseId: string,
 ): Promise<BackgroundWakeLeaseClientResult> {
-  const client = await CadetPlatformClient.create();
+  const client = await CadetCloudClient.create();
   if (!client) {
     return { status: "skipped", reason: "missing_platform_client" };
   }
-  if (!client.platformAssistantId) {
+  if (!client.cloudAssistantId) {
     return { status: "skipped", reason: "missing_platform_assistant_id" };
   }
 
   const response = await client.fetch(
-    leasePath(client.platformAssistantId, leaseId, "renew"),
+    leasePath(client.cloudAssistantId, leaseId, "renew"),
     {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -119,11 +119,11 @@ export async function completeBackgroundWakeLease(args: {
   error?: string;
   nextIntent?: BackgroundWakeIntent | null;
 }): Promise<BackgroundWakeLeaseClientResult> {
-  const client = await CadetPlatformClient.create();
+  const client = await CadetCloudClient.create();
   if (!client) {
     return { status: "skipped", reason: "missing_platform_client" };
   }
-  if (!client.platformAssistantId) {
+  if (!client.cloudAssistantId) {
     return { status: "skipped", reason: "missing_platform_assistant_id" };
   }
 
@@ -147,7 +147,7 @@ export async function completeBackgroundWakeLease(args: {
   }
 
   const response = await client.fetch(
-    leasePath(client.platformAssistantId, args.leaseId, "complete"),
+    leasePath(client.cloudAssistantId, args.leaseId, "complete"),
     {
       method: "POST",
       headers: { "Content-Type": "application/json" },

package/src/background-wake/publisher.ts

@@ -1,12 +1,12 @@
 import { getLogger } from "../util/logger.js";
+import {
+  clearBackgroundWakeIntent,
+  publishBackgroundWakeIntent,
+} from "./cloud-client.js";
 import {
   type BackgroundWakeIntent,
   computeNextBackgroundWakeIntent,
 } from "./next-wake.js";
-import {
-  clearBackgroundWakeIntent,
-  publishBackgroundWakeIntent,
-} from "./platform-client.js";
 
 const log = getLogger("background-wake-publisher");
 const REFRESH_DEBOUNCE_MS = 250;

package/src/background-wake/wake-intent-hooks.test.ts

@@ -1,8 +1,8 @@
 import { readFileSync } from "node:fs";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { BackgroundWakeIntentClientResult } from "./cloud-client.js";
 import type { BackgroundWakeIntent } from "./next-wake.js";
-import type { BackgroundWakeIntentClientResult } from "./platform-client.js";
 
 const mockPublishBackgroundWakeIntent = mock(
   async (): Promise<BackgroundWakeIntentClientResult> => ({
@@ -20,7 +20,7 @@ mock.module("./next-wake.js", () => ({
   computeNextBackgroundWakeIntent: () => computedIntent,
 }));
 
-mock.module("./platform-client.js", () => ({
+mock.module("./cloud-client.js", () => ({
   publishBackgroundWakeIntent: mockPublishBackgroundWakeIntent,
   clearBackgroundWakeIntent: mockClearBackgroundWakeIntent,
 }));
@@ -206,7 +206,7 @@ describe("background wake intent publisher hooks", () => {
 
     expect(lifecycleSource).not.toContain("clearBackgroundWakeIntent");
     expect(shutdownSource).not.toContain("clearBackgroundWakeIntent");
-    expect(shutdownSource).not.toContain("background-wake/platform-client");
+    expect(shutdownSource).not.toContain("background-wake/cloud-client");
   });
 });
 

package/src/calls/__tests__/call-controller.test.ts

@@ -51,10 +51,10 @@ function seedDefaultResolvableKeys(): void {
   }
 }
 
-// Managed-speech defaulting reaches the platform client and the credential
+// Managed-speech defaulting reaches the cloud client and the credential
 // store. The controller tests drive the bridge mock on a microtask budget, so
 // the configured providers stand as the effective ones here.
-mock.module("../../config/managed-speech-defaults.js", () => ({
+mock.module("../../config/cloud-speech-defaults.js", () => ({
   resolveEffectiveSpeechProviders: async (config?: {
     services: { stt: { provider: string }; tts: { provider: string } };
   }) => {

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

@@ -546,7 +546,7 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
 
     // `turn-events-store` projects `$.client` onto `TurnTelemetryEvent.client`,
     // so this bag is what makes a voice turn countable per client and joinable
-    // to its session's funnel rows. The platform goes in `os`, the same key
+    // to its session's funnel rows. The cloud goes in `os`, the same key
     // the HTTP send path fills, so voice turns sit in the column existing turn
     // analytics already read.
     expect(fake.lastPersistOpts()?.metadata).toEqual({

package/src/calls/call-domain.ts

@@ -9,7 +9,7 @@ import { revokeScopedApprovalGrantsForContext } from "../approvals/scoped-approv
 import { loadConfig } from "../config/loader.js";
 import { VALID_CALLER_IDENTITY_MODES } from "../config/schema.js";
 import type { AssistantConfig } from "../config/types.js";
-import { resolveCallbackUrl } from "../inbound/platform-callback-registration.js";
+import { resolveCallbackUrl } from "../inbound/cloud-callback-registration.js";
 import {
   getTwilioStatusCallbackUrl,
   getTwilioVoiceWebhookUrl,

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

@@ -7,8 +7,8 @@
  * native-vs-synthesized strategy decision stay in one implementation.
  */
 
+import { resolveEffectiveSpeechProviders } from "../config/cloud-speech-defaults.js";
 import { loadConfig } from "../config/loader.js";
-import { resolveEffectiveSpeechProviders } from "../config/managed-speech-defaults.js";
 import {
   getCatalogProvider,
   getTtsProvider,
@@ -74,9 +74,9 @@ export interface ResolveCallTtsOptions {
 /**
  * Resolve the active TTS provider via the global provider abstraction.
  *
- * The provider is the effective one after managed-speech defaulting
+ * 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 managed speech
+ * 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.
@@ -185,9 +185,9 @@ export async function resolveCallTtsProvider(
 }
 
 /**
- * The TTS provider the call actually uses after managed-speech defaulting.
- * A failure inside the managed lookup (platform client, credential store)
- * keeps the configured provider: a managed-speech hiccup must not demote a
+ * 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.
  */

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

@@ -111,7 +111,7 @@ function sttGapClause(
       // Connection-based providers are fixed by connecting the account,
       // not by entering an API key.
       if (capability.credentialProvider === "cadet") {
-        return `a Cadet Cloud connection for managed speech (run 'assistant cloud connect')`;
+        return `a Cadet Cloud connection for cloud speech (run 'assistant cloud connect')`;
       }
       return `an API key for the speech-to-text provider "${providerId}"`;
     }
@@ -140,14 +140,14 @@ function ttsGap(
         clause: `an API key for the text-to-speech provider "${providerId}" (no fallback provider has usable credentials)`,
       };
     }
-    case "missing-platform-connection": {
+    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 managed speech (run 'assistant cloud connect'; no fallback provider has usable credentials)`,
+        clause: `a Cadet Cloud connection for cloud speech (run 'assistant cloud connect'; no fallback provider has usable credentials)`,
       };
     }
     case "missing-fish-audio-reference-id": {

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

@@ -38,7 +38,7 @@ export type TelephonyTtsNotPlayableReason =
   | "unsupported-format"
   | "missing-credentials"
   | "missing-fish-audio-reference-id"
-  | "missing-platform-connection";
+  | "missing-cloud-connection";
 
 /**
  * Result of resolving whether a TTS provider is playable over the
@@ -113,18 +113,17 @@ export async function evaluateTelephonyTtsPlayability(
     }
   }
 
-  // The cadet secret alone doesn't prove usability: managed speech also
-  // needs the platform assistant identity, or synthesis fails before any
+  // 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("../platform/managed-speech.js");
+    const { managedSpeechAvailable } = await import("../cloud/cloud-speech.js");
     if (!(await managedSpeechAvailable())) {
       return {
         status: "not-playable",
         providerId: entry.id,
-        reason: "missing-platform-connection",
+        reason: "missing-cloud-connection",
       };
     }
   }