@mycadet/assistant 0.12.7 → 0.12.8

package/src/{platform/managed-speech.ts → cloud/cloud-speech.ts}

@@ -1,14 +1,14 @@
 /**
- * Client for the platform's managed speech endpoints: Cadet-held Deepgram
+ * Client for the cloud's cloud speech endpoints: Cadet-held Deepgram
  * key, billed to the org's credits. The daemon sends complete audio (STT) or
- * text (TTS) and the platform does the provider call — no speech credentials
+ * text (TTS) and the cloud does the provider call — no speech credentials
  * ever live on this machine.
  *
  * Contract (mirrors `mycadet-platform` — do not change unilaterally):
- * - `POST /v1/assistants/{id}/managed-speech/stt/transcribe/`
+ * - `POST /v1/assistants/{id}/cloud-speech/stt/transcribe/`
  *   `{audioBase64, mimeType, source?}` → 200 `{text, providerId, model,
  *   durationSeconds}`.
- * - `POST /v1/assistants/{id}/managed-speech/tts/synthesize/`
+ * - `POST /v1/assistants/{id}/cloud-speech/tts/synthesize/`
  *   `{text, format?}` → 200 binary audio, `Content-Type` from upstream.
  * - Errors: `{code, detail}`; notable codes: `insufficient_balance` (402),
  *   `missing_price` (400), `provider_configuration_error` (500).
@@ -19,9 +19,9 @@
 
 import { z } from "zod";
 
-import { CadetPlatformClient } from "./client.js";
+import { CadetCloudClient } from "./client.js";
 
-export type ManagedSpeechResult<T> =
+export type CloudSpeechResult<T> =
   | { ok: true; value: T }
   | {
       ok: false;
@@ -40,43 +40,43 @@ export type ManagedSpeechResult<T> =
       message: string;
     };
 
-export interface ManagedSpeechTranscription {
+export interface CloudSpeechTranscription {
   text: string;
   durationSeconds: number;
 }
 
-const ManagedSpeechTranscriptionSchema = z.object({
+const CloudSpeechTranscriptionSchema = z.object({
   text: z.string(),
   durationSeconds: z.number(),
 });
 
-export interface ManagedSpeechSynthesis {
+export interface CloudSpeechSynthesis {
   audio: Buffer;
   contentType: string;
 }
 
-export type ManagedSpeechTtsFormat = "mp3" | "wav_8000" | "pcm_16000";
+export type CloudSpeechTtsFormat = "mp3" | "wav_8000" | "pcm_16000";
 
 async function resolveClient(): Promise<
-  { client: CadetPlatformClient } | { error: ManagedSpeechResult<never> }
+  { client: CadetCloudClient } | { error: CloudSpeechResult<never> }
 > {
-  const client = await CadetPlatformClient.create();
+  const client = await CadetCloudClient.create();
   if (!client) {
     return {
       error: {
         ok: false,
         kind: "unavailable",
-        message: "Managed speech is unavailable: no Cadet Cloud connection.",
+        message: "Cloud speech is unavailable: no Cadet Cloud connection.",
       },
     };
   }
-  if (!client.platformAssistantId) {
+  if (!client.cloudAssistantId) {
     return {
       error: {
         ok: false,
         kind: "unavailable",
         message:
-          "Managed speech is unavailable: platform assistant ID is missing.",
+          "Cloud speech is unavailable: platform assistant ID is missing.",
       },
     };
   }
@@ -84,7 +84,7 @@ async function resolveClient(): Promise<
 }
 
 /**
- * Whether managed speech can be used at all: a cloud connection whose
+ * Whether cloud speech can be used at all: a cloud connection whose
  * assistant identity is fully provisioned. A stored API key alone is not
  * enough — synthesis/transcription would fail before any request is made.
  */
@@ -98,14 +98,14 @@ export async function managedSpeechTranscribe(input: {
   source?: string;
   /**
    * Spoken language to decode: a BCP-47 code, or `"multi"` for nova-3
-   * code-switching. Omitted means the platform sends none, which Deepgram
+   * code-switching. Omitted means the cloud sends none, which Deepgram
    * decodes as English rather than detecting the language. Older platform
    * builds that predate the field ignore it, so sending one is safe before
-   * the platform side deploys.
+   * the cloud side deploys.
    */
   language?: string;
   signal?: AbortSignal;
-}): Promise<ManagedSpeechResult<ManagedSpeechTranscription>> {
+}): Promise<CloudSpeechResult<CloudSpeechTranscription>> {
   const resolved = await resolveClient();
   if ("error" in resolved) {
     return resolved.error;
@@ -113,7 +113,7 @@ export async function managedSpeechTranscribe(input: {
   const { client } = resolved;
 
   const response = await client.fetch(
-    `/v1/assistants/${encodeURIComponent(client.platformAssistantId)}/managed-speech/stt/transcribe/`,
+    `/v1/assistants/${encodeURIComponent(client.cloudAssistantId)}/cloud-speech/stt/transcribe/`,
     {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -131,7 +131,7 @@ export async function managedSpeechTranscribe(input: {
     return await platformError(response, "transcription");
   }
 
-  const parsed = ManagedSpeechTranscriptionSchema.safeParse(
+  const parsed = CloudSpeechTranscriptionSchema.safeParse(
     await response.json().catch(() => null),
   );
   if (!parsed.success) {
@@ -139,7 +139,7 @@ export async function managedSpeechTranscribe(input: {
       ok: false,
       kind: "platform-error",
       status: response.status,
-      message: "Managed speech transcription returned a malformed response.",
+      message: "Cloud speech transcription returned a malformed response.",
     };
   }
   return {
@@ -153,11 +153,11 @@ export async function managedSpeechTranscribe(input: {
 
 export async function managedSpeechSynthesize(input: {
   text: string;
-  format: ManagedSpeechTtsFormat;
+  format: CloudSpeechTtsFormat;
   /** Voice model (e.g. "aura-2-thalia-en"); omitted = platform default. */
   model?: string;
   signal?: AbortSignal;
-}): Promise<ManagedSpeechResult<ManagedSpeechSynthesis>> {
+}): Promise<CloudSpeechResult<CloudSpeechSynthesis>> {
   const resolved = await resolveClient();
   if ("error" in resolved) {
     return resolved.error;
@@ -165,7 +165,7 @@ export async function managedSpeechSynthesize(input: {
   const { client } = resolved;
 
   const response = await client.fetch(
-    `/v1/assistants/${encodeURIComponent(client.platformAssistantId)}/managed-speech/tts/synthesize/`,
+    `/v1/assistants/${encodeURIComponent(client.cloudAssistantId)}/cloud-speech/tts/synthesize/`,
     {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -188,7 +188,7 @@ export async function managedSpeechSynthesize(input: {
       ok: false,
       kind: "platform-error",
       status: response.status,
-      message: "Managed speech synthesis returned empty audio.",
+      message: "Cloud speech synthesis returned empty audio.",
     };
   }
   return {
@@ -200,7 +200,7 @@ export async function managedSpeechSynthesize(input: {
   };
 }
 
-export interface ManagedSpeechVoice {
+export interface CloudSpeechVoice {
   model: string;
   label: string;
   description: string;
@@ -209,32 +209,32 @@ export interface ManagedSpeechVoice {
   source: string;
 }
 
-export interface ManagedSpeechVoiceCatalog {
+export interface CloudSpeechVoiceCatalog {
   /** Offered voices in display order; only currently-usable voices. */
-  voices: ManagedSpeechVoice[];
+  voices: CloudSpeechVoice[];
   /** Always one of `voices`; null when no voices are offered. */
   defaultModel: string | null;
 }
 
-const ManagedSpeechVoiceSchema = z.object({
+const CloudSpeechVoiceSchema = z.object({
   model: z.string(),
   label: z.string(),
   description: z.string(),
   sampleUrl: z.string(),
   source: z.string(),
 });
-const ManagedSpeechVoiceCatalogSchema = z.object({
-  voices: z.array(ManagedSpeechVoiceSchema.nullable().catch(null)),
+const CloudSpeechVoiceCatalogSchema = z.object({
+  voices: z.array(CloudSpeechVoiceSchema.nullable().catch(null)),
   defaultModel: z.string().nullable().optional().catch(null),
 });
-const ManagedSpeechErrorSchema = z.object({
+const CloudSpeechErrorSchema = z.object({
   code: z.string().optional().catch(undefined),
   detail: z.string().optional().catch(undefined),
 });
 
 export async function managedSpeechVoices(input?: {
   signal?: AbortSignal;
-}): Promise<ManagedSpeechResult<ManagedSpeechVoiceCatalog>> {
+}): Promise<CloudSpeechResult<CloudSpeechVoiceCatalog>> {
   const resolved = await resolveClient();
   if ("error" in resolved) {
     return resolved.error;
@@ -242,7 +242,7 @@ export async function managedSpeechVoices(input?: {
   const { client } = resolved;
 
   const response = await client.fetch(
-    `/v1/assistants/${encodeURIComponent(client.platformAssistantId)}/managed-speech/tts/voices/`,
+    `/v1/assistants/${encodeURIComponent(client.cloudAssistantId)}/cloud-speech/tts/voices/`,
     { method: "GET", signal: input?.signal },
   );
 
@@ -250,7 +250,7 @@ export async function managedSpeechVoices(input?: {
     return await platformError(response, "voice listing");
   }
 
-  const parsed = ManagedSpeechVoiceCatalogSchema.safeParse(
+  const parsed = CloudSpeechVoiceCatalogSchema.safeParse(
     await response.json().catch(() => null),
   );
   if (!parsed.success) {
@@ -258,14 +258,14 @@ export async function managedSpeechVoices(input?: {
       ok: false,
       kind: "platform-error",
       status: response.status,
-      message: "Managed speech voice listing returned a malformed response.",
+      message: "Cloud speech voice listing returned a malformed response.",
     };
   }
   return {
     ok: true,
     value: {
       voices: parsed.data.voices.filter(
-        (voice): voice is ManagedSpeechVoice => voice !== null,
+        (voice): voice is CloudSpeechVoice => voice !== null,
       ),
       defaultModel: parsed.data.defaultModel ?? null,
     },
@@ -275,11 +275,11 @@ export async function managedSpeechVoices(input?: {
 async function platformError(
   response: Response,
   operation: string,
-): Promise<ManagedSpeechResult<never>> {
+): Promise<CloudSpeechResult<never>> {
   let code: string | undefined;
   let detail: string | undefined;
   try {
-    const parsed = ManagedSpeechErrorSchema.safeParse(await response.json());
+    const parsed = CloudSpeechErrorSchema.safeParse(await response.json());
     if (parsed.success) {
       code = parsed.data.code;
       detail = parsed.data.detail;
@@ -295,6 +295,6 @@ async function platformError(
     detail,
     message:
       detail ??
-      `Managed speech ${operation} failed (platform returned ${response.status}).`,
+      `Cloud speech ${operation} failed (platform returned ${response.status}).`,
   };
 }

package/src/{platform → cloud}/consent-cache.test.ts

@@ -8,7 +8,7 @@ import type { OwnerConsent } from "./client.js";
 // ---------------------------------------------------------------------------
 
 let mockClient: {
-  platformAssistantId: string;
+  cloudAssistantId: string;
   getOwnerConsent: () => Promise<OwnerConsent | null>;
 } | null = null;
 let createCallCount = 0;
@@ -18,7 +18,7 @@ let createCallCount = 0;
 // ---------------------------------------------------------------------------
 
 mock.module("./client.js", () => ({
-  CadetPlatformClient: {
+  CadetCloudClient: {
     create: async () => {
       createCallCount += 1;
       return mockClient;
@@ -57,7 +57,7 @@ function makeConsent(overrides: Partial<OwnerConsent> = {}): OwnerConsent {
 
 function makeClient(consent: OwnerConsent | null, assistantId = "asst_1") {
   return {
-    platformAssistantId: assistantId,
+    cloudAssistantId: assistantId,
     getOwnerConsent: async () => consent,
   };
 }
@@ -94,11 +94,11 @@ describe("consent-cache", () => {
     // flush will ever drain the outbox, so record-time gates must stay
     // closed (confirmed false) instead of accumulating rows forever.
     __setCachedShareAnalyticsForTest(true);
-    process.env.CADET_DISABLE_PLATFORM = "1";
+    process.env.CADET_DISABLE_CLOUD = "1";
     try {
       await refreshConsentCache();
     } finally {
-      delete process.env.CADET_DISABLE_PLATFORM;
+      delete process.env.CADET_DISABLE_CLOUD;
     }
     expect(getRawShareAnalytics()).toBe(false);
     expect(getCachedShareDiagnostics()).toBe(false);

package/src/{platform → cloud}/consent-cache.ts

@@ -1,5 +1,5 @@
 /**
- * In-memory cache of the platform owner's telemetry consent.
+ * In-memory cache of the cloud owner's telemetry consent.
  *
  * Three values are cached, all refreshed from the same owner-consent fetch:
  *  - `share_analytics`: gates usage telemetry collection.
@@ -31,8 +31,8 @@
 
 import { getConfigReadOnly } from "../config/loader.js";
 import { getLogger } from "../util/logger.js";
-import { CadetPlatformClient } from "./client.js";
-import { arePlatformFeaturesEnabled } from "./feature-gate.js";
+import { CadetCloudClient } from "./client.js";
+import { areCloudFeaturesEnabled } from "./feature-gate.js";
 
 const log = getLogger("consent-cache");
 
@@ -47,7 +47,7 @@ let cachedShareDiagnosticsVersion = ""; // "" fails the trace disclosure gate
 // Fail-closed marker for a workspace that locally opted out of usage data
 // before telemetry moved to platform `share_analytics` consent (migration 106).
 // While set, telemetry stays off regardless of platform consent. Cleared by a
-// future cross-repo reconciliation once the platform exposes an explicit
+// future cross-repo reconciliation once the cloud exposes an explicit
 // re-consent signal; not auto-cleared here. Read live from config (an
 // in-memory cached read, safe on the hot path): a boot-time default would
 // leave the record-time gates open between daemon start and the first
@@ -95,7 +95,7 @@ export function getCachedShareDiagnosticsVersion(): string {
 }
 
 /**
- * Refresh the cached consent from the platform.
+ * Refresh the cached consent from the cloud.
  *
  * No platform session / features disabled (`create()` is null) → `"unknown"`.
  * No resolvable assistant identity (no owner whose consent we can attest to) →
@@ -110,21 +110,21 @@ export async function refreshConsentCache(): Promise<void> {
   // cold-cache transient: telemetry can never ship, so confirmed-off keeps the
   // record-time gates closed and the outbox from accumulating rows that no
   // flush will ever drain.
-  if (!arePlatformFeaturesEnabled()) {
+  if (!areCloudFeaturesEnabled()) {
     setCachedShareAnalytics(false);
     setCachedShareDiagnostics(false);
     setCachedShareDiagnosticsVersion("");
     return;
   }
 
-  const client = await CadetPlatformClient.create();
+  const client = await CadetCloudClient.create();
   if (!client) {
     resetConsentToUnknown();
     return;
   }
 
   // No resolvable owner identity → unknown (don't ride a stale opt-in).
-  if (!client.platformAssistantId) {
+  if (!client.cloudAssistantId) {
     resetConsentToUnknown();
     return;
   }

package/src/cloud/feature-gate.ts

@@ -0,0 +1,8 @@
+import { getDisableCloud, getIsCloud } from "../config/env-registry.js";
+
+export function areCloudFeaturesEnabled(): boolean {
+  if (getIsCloud()) {
+    return true;
+  }
+  return !getDisableCloud();
+}

package/src/{platform → cloud}/sync-identity.test.ts

@@ -2,12 +2,12 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let mockClient: {
   baseUrl: string;
-  platformAssistantId: string;
+  cloudAssistantId: string;
   fetch: (path: string, init: RequestInit) => Promise<Response>;
 } | null;
 
 mock.module("./client.js", () => ({
-  CadetPlatformClient: { create: async () => mockClient },
+  CadetCloudClient: { create: async () => mockClient },
 }));
 
 import { syncIdentityNameToPlatform } from "./sync-identity.js";
@@ -22,7 +22,7 @@ let patches: Patch[];
 function makeClient(assistantId = "asst-1") {
   return {
     baseUrl: "https://platform.a",
-    platformAssistantId: assistantId,
+    cloudAssistantId: assistantId,
     fetch: async (path: string, init: RequestInit) => {
       patches.push({ path, body: JSON.parse(init.body as string) });
       return new Response("{}", { status: 200 });
@@ -37,7 +37,7 @@ async function settle(): Promise<void> {
 }
 
 // The module owns one queue, so names are unique per test to avoid dedup
-// across tests. Queue semantics are covered by platform-patch-queue.test.ts.
+// across tests. Queue semantics are covered by cloud-patch-queue.test.ts.
 describe("syncIdentityNameToPlatform", () => {
   beforeEach(() => {
     patches = [];

package/src/{platform → cloud}/sync-identity.ts

@@ -1,9 +1,9 @@
 /**
- * Sync assistant identity fields to the platform Assistant record.
+ * Sync assistant identity fields to the cloud Assistant record.
  *
  * When IDENTITY.md changes on disk the daemon broadcasts an
  * `identity_changed` event to connected clients. This module hooks into that
- * same change signal and PATCHes the platform `Assistant` record through the
+ * same change signal and PATCHes the cloud `Assistant` record through the
  * shared platform PATCH queue so the name stays in sync: rapid changes
  * collapse to the newest name, and an unchanged name is not re-sent to the
  * same platform destination.
@@ -14,11 +14,11 @@ import { existsSync, readFileSync } from "node:fs";
 import { parseIdentityFields } from "../daemon/handlers/identity.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
-import { createPlatformPatchQueue } from "./platform-patch-queue.js";
+import { createCloudPatchQueue } from "./cloud-patch-queue.js";
 
 const log = getLogger("sync-identity");
 
-const queue = createPlatformPatchQueue<string>({
+const queue = createCloudPatchQueue<string>({
   log,
   label: "assistant name",
   buildPayload: (name) => ({
@@ -28,7 +28,7 @@ const queue = createPlatformPatchQueue<string>({
 });
 
 /**
- * Push the current assistant name to the platform `Assistant` record.
+ * Push the current assistant name to the cloud `Assistant` record.
  * Empty names are ignored.
  */
 export function syncIdentityNameToPlatform(name: string): void {
@@ -39,7 +39,7 @@ export function syncIdentityNameToPlatform(name: string): void {
 
 /**
  * Read the workspace IDENTITY.md and best-effort sync the assistant name to
- * the platform record. Called once at daemon startup; later edits are picked
+ * the cloud record. Called once at daemon startup; later edits are picked
  * up by the config watcher's IDENTITY.md change reaction.
  */
 export function syncWorkspaceIdentityToPlatform(): void {