@mycadet/assistant 0.12.7 → 0.12.9

package/src/{platform → cloud}/client.ts

@@ -1,20 +1,20 @@
 /**
  * Centralized platform API client.
  *
- * Owns managed proxy context resolution, prerequisite validation, and
+ * Owns cloud proxy context resolution, prerequisite validation, and
  * authenticated fetch for all platform API calls.
  */
 
-import type { PlatformCredentialVerificationStatus } from "@mycadet/service-contracts/platform-credential";
+import type { CloudCredentialVerificationStatus } from "@mycadet/service-contracts/cloud-credential";
 
-import { resolvePlatformAssistantId } from "../config/platform-identity.js";
-import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
+import { resolveCloudAssistantId } from "../config/cloud-identity.js";
+import { resolveCloudProxyContext } from "../providers/cloud-proxy/context.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
-import { arePlatformFeaturesEnabled } from "./feature-gate.js";
+import { areCloudFeaturesEnabled } from "./feature-gate.js";
 
-const log = getLogger("platform-client");
+const log = getLogger("cloud-client");
 
 let _missingPrereqsWarned = false;
 
@@ -36,16 +36,16 @@ export interface OwnerConsent {
   shareDiagnosticsAcceptedVersion: string;
 }
 
-interface PlatformClientConfig {
+interface CloudClientConfig {
   baseUrl: string;
   apiKey: string;
   assistantId: string;
 }
 
 /**
- * Resolve the platform client's prerequisites.
+ * Resolve the cloud client's prerequisites.
  *
- * First tries the in-memory managed proxy context (available when the daemon
+ * First tries the in-memory cloud proxy context (available when the daemon
  * has rehydrated env overrides). Falls back to reading cloud credentials
  * directly from the credential store so that standalone CLI invocations work
  * without the daemon having run its rehydration step.
@@ -53,24 +53,19 @@ interface PlatformClientConfig {
  * Returns `null` when auth prerequisites are missing (not logged in, no API
  * key). The assistant ID is resolved but not required.
  */
-async function resolvePlatformClientConfig(): Promise<PlatformClientConfig | null> {
-  if (!arePlatformFeaturesEnabled()) {
+async function resolveCloudClientConfig(): Promise<CloudClientConfig | null> {
+  if (!areCloudFeaturesEnabled()) {
     log.debug("platform features disabled -- returning null");
     return null;
   }
 
-  const ctx = await resolveManagedProxyContext();
+  const ctx = await resolveCloudProxyContext();
 
-  let baseUrl = ctx.enabled ? ctx.platformBaseUrl : "";
+  const baseUrl = ctx.enabled ? ctx.cloudBaseUrl : "";
   let apiKey = ctx.enabled ? ctx.assistantApiKey : "";
-  const assistantId = await resolvePlatformAssistantId();
+  const assistantId = await resolveCloudAssistantId();
 
   // Fall back to credential store for values not yet rehydrated (standalone CLI).
-  if (!baseUrl) {
-    baseUrl =
-      (await getSecureKeyAsync(credentialKey("cadet", "platform_base_url"))) ??
-      "";
-  }
   if (!apiKey) {
     apiKey =
       (await getSecureKeyAsync(credentialKey("cadet", "assistant_api_key"))) ??
@@ -140,7 +135,7 @@ function startOrJoinConfiguredProbe(): ConfiguredProbeFlight {
   }
   probeGeneration += 1;
   const generation = probeGeneration;
-  const promise = resolvePlatformClientConfig()
+  const promise = resolveCloudClientConfig()
     .then((config) => config !== null && config.assistantId.length > 0)
     .catch((err: unknown) => {
       log.debug(
@@ -169,8 +164,8 @@ function startOrJoinConfiguredProbe(): ConfiguredProbeFlight {
 }
 
 /**
- * Whether the platform client can actually dispatch: auth prerequisites plus
- * a nonempty platform assistant id (`PlatformPushAdapter.send()` fails fast
+ * Whether the cloud client can actually dispatch: auth prerequisites plus
+ * a nonempty platform assistant id (`CloudPushAdapter.send()` fails fast
  * without one). Constructs no client and makes no network requests.
  *
  * Bounded by {@link CONFIGURED_PROBE_DEADLINE_MS}: when config resolution is
@@ -180,7 +175,7 @@ function startOrJoinConfiguredProbe(): ConfiguredProbeFlight {
  * so a hung backend never pins the cache stale, and generation fencing keeps a
  * rotated-out flight's late settle from overwriting a newer result.
  */
-export async function isPlatformClientConfigured(): Promise<boolean> {
+export async function isCloudClientConfigured(): Promise<boolean> {
   const flight = startOrJoinConfiguredProbe();
 
   let deadlineTimer: ReturnType<typeof setTimeout> | undefined;
@@ -199,34 +194,34 @@ export async function isPlatformClientConfigured(): Promise<boolean> {
   return raced;
 }
 
-export class CadetPlatformClient {
-  private readonly platformBaseUrl: string;
+export class CadetCloudClient {
+  private readonly cloudBaseUrl: string;
   private readonly apiKey: string;
   private readonly assistantId: string;
 
   private constructor(
-    platformBaseUrl: string,
+    cloudBaseUrl: string,
     apiKey: string,
     assistantId: string,
   ) {
-    this.platformBaseUrl = platformBaseUrl.replace(/\/+$/, "");
+    this.cloudBaseUrl = cloudBaseUrl.replace(/\/+$/, "");
     this.apiKey = apiKey;
     this.assistantId = assistantId;
   }
 
   /**
-   * Create a platform client from {@link resolvePlatformClientConfig}.
+   * Create a cloud client from {@link resolveCloudClientConfig}.
    *
    * Returns `null` when auth prerequisites are missing (not logged in, no API
    * key). The assistant ID is resolved but not required -- callers that need
-   * it should check `platformAssistantId` themselves.
+   * it should check `cloudAssistantId` themselves.
    */
-  static async create(): Promise<CadetPlatformClient | null> {
-    const config = await resolvePlatformClientConfig();
+  static async create(): Promise<CadetCloudClient | null> {
+    const config = await resolveCloudClientConfig();
     if (!config) {
       return null;
     }
-    return new CadetPlatformClient(
+    return new CadetCloudClient(
       config.baseUrl,
       config.apiKey,
       config.assistantId,
@@ -234,13 +229,13 @@ export class CadetPlatformClient {
   }
 
   /**
-   * Authenticated fetch against the platform API.
+   * Authenticated fetch against the cloud API.
    *
-   * Prepends `platformBaseUrl` to `path` and injects the `Api-Key` auth header.
+   * Prepends `cloudBaseUrl` to `path` and injects the `Api-Key` auth header.
    * Callers handle response parsing and domain-specific error mapping.
    */
   async fetch(path: string, init?: RequestInit): Promise<Response> {
-    const url = `${this.platformBaseUrl}${path}`;
+    const url = `${this.cloudBaseUrl}${path}`;
     const headers = new Headers(init?.headers);
     headers.set("Authorization", `Api-Key ${this.apiKey}`);
 
@@ -248,7 +243,7 @@ export class CadetPlatformClient {
   }
 
   /**
-   * Fetch the platform owner's telemetry consent for this assistant.
+   * Fetch the cloud owner's telemetry consent for this assistant.
    *
    * The endpoint returns effective consent values (a never-chose null is
    * served as consented); an explicit `false` is the only disable.
@@ -306,10 +301,10 @@ export class CadetPlatformClient {
   }
 
   /**
-   * Ask the platform whether this client's assistant API key still
+   * Ask the cloud whether this client's assistant API key still
    * authenticates.
    *
-   * `"rejected"` is a settled negative: the platform answered, and the answer
+   * `"rejected"` is a settled negative: the cloud answered, and the answer
    * was that the credential is not accepted (401/403, which is how
    * `AssistantAPIKeyAuthentication` reports a revoked, expired, or unknown
    * key). Only that verdict may drive a rotation, because rotating on a
@@ -320,10 +315,10 @@ export class CadetPlatformClient {
    * The carrier is the owner-consent endpoint. Nothing here reads consent:
    * the request is a side-effect-free authenticated GET this client already
    * makes, and the only thing inspected is whether authentication succeeded.
-   * The platform exposes no dedicated credential-verification endpoint, so
+   * The cloud exposes no dedicated credential-verification endpoint, so
    * the carrier is named here rather than left implicit at call sites.
    */
-  async verifyCredential(): Promise<PlatformCredentialVerificationStatus> {
+  async verifyCredential(): Promise<CloudCredentialVerificationStatus> {
     if (!this.assistantId) {
       return "unknown";
     }
@@ -347,23 +342,20 @@ export class CadetPlatformClient {
       );
       return "unknown";
     } catch (err) {
-      log.debug(
-        { err },
-        "credential verification could not reach the platform",
-      );
+      log.debug({ err }, "credential verification could not reach the cloud");
       return "unknown";
     }
   }
 
   get baseUrl(): string {
-    return this.platformBaseUrl;
+    return this.cloudBaseUrl;
   }
 
   get assistantApiKey(): string {
     return this.apiKey;
   }
 
-  get platformAssistantId(): string {
+  get cloudAssistantId(): string {
     return this.assistantId;
   }
 }

package/src/{platform/platform-patch-queue.test.ts → cloud/cloud-patch-queue.test.ts}

@@ -11,19 +11,16 @@ import {
 
 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 { getLogger } from "../util/logger.js";
-import {
-  createPlatformPatchQueue,
-  type SyncedKey,
-} from "./platform-patch-queue.js";
+import { createCloudPatchQueue, type SyncedKey } from "./cloud-patch-queue.js";
 
 interface Patch {
   path: string;
@@ -38,7 +35,7 @@ let queues: Array<{ dispose: () => void }>;
 function makeClient(assistantId = "asst-1", baseUrl = "https://platform.a") {
   return {
     baseUrl,
-    platformAssistantId: assistantId,
+    cloudAssistantId: assistantId,
     fetch: async (path: string, init: RequestInit) => {
       patches.push({ path, body: JSON.parse(init.body as string) });
       return respond();
@@ -54,7 +51,7 @@ function makeQueue(
     retryDelaysMs?: number[];
   } = {},
 ) {
-  const queue = createPlatformPatchQueue<string | undefined>({
+  const queue = createCloudPatchQueue<string | undefined>({
     log: getLogger("test"),
     label: "value",
     buildPayload: (value) => {
@@ -87,7 +84,7 @@ async function elapse(ms: number): Promise<void> {
   await settle();
 }
 
-describe("createPlatformPatchQueue", () => {
+describe("createCloudPatchQueue", () => {
   beforeEach(() => {
     jest.useFakeTimers();
     setSystemTime(new Date(FROZEN_NOW));

package/src/{platform/platform-patch-queue.ts → cloud/cloud-patch-queue.ts}

@@ -1,10 +1,10 @@
 /**
- * Serialized, deduplicated PATCH queue for the platform Assistant record.
+ * Serialized, deduplicated PATCH queue for the cloud Assistant record.
  *
  * Each `enqueue` bumps a sequence number and chains onto the previous request,
  * so rapid changes collapse into one PATCH carrying the newest payload and a
  * stale in-flight response cannot overwrite a newer value. The dedup key is
- * scoped to the platform destination (base URL + assistant id), so
+ * scoped to the cloud destination (base URL + assistant id), so
  * re-registering elsewhere re-sends an unchanged payload. With `maxAgeMs`, a
  * key only dedups while its last success is younger than that, and an unref'd
  * timer re-enqueues the last input at expiry so an idle long-lived process
@@ -22,7 +22,7 @@
  */
 
 import type { getLogger } from "../util/logger.js";
-import { CadetPlatformClient } from "./client.js";
+import { CadetCloudClient } from "./client.js";
 
 type Logger = ReturnType<typeof getLogger>;
 
@@ -63,7 +63,7 @@ export interface SyncedKey {
   syncedAt: number;
 }
 
-export interface PlatformPatchQueueOptions<T> {
+export interface CloudPatchQueueOptions<T> {
   log: Logger;
   /** Names the synced thing in log lines, e.g. "avatar". */
   label: string;
@@ -83,15 +83,15 @@ export interface PlatformPatchQueueOptions<T> {
 
 const DEFAULT_RETRY_DELAYS_MS = [30_000, 120_000, 600_000];
 
-export interface PlatformPatchQueue<T> {
+export interface CloudPatchQueue<T> {
   enqueue: (input: T) => void;
   /** Cancels the expiry and retry timers; queued requests still run. */
   dispose: () => void;
 }
 
-export function createPlatformPatchQueue<T = void>(
-  options: PlatformPatchQueueOptions<T>,
-): PlatformPatchQueue<T> {
+export function createCloudPatchQueue<T = void>(
+  options: CloudPatchQueueOptions<T>,
+): CloudPatchQueue<T> {
   const {
     log,
     label,
@@ -136,8 +136,8 @@ export function createPlatformPatchQueue<T = void>(
       if (requestSeq !== seq) {
         return;
       }
-      const client = await CadetPlatformClient.create();
-      const assistantId = client?.platformAssistantId;
+      const client = await CadetCloudClient.create();
+      const assistantId = client?.cloudAssistantId;
       if (!client || !assistantId) {
         return;
       }
@@ -194,7 +194,7 @@ export function createPlatformPatchQueue<T = void>(
       ) {
         log.warn(
           { field: reduced.field, assistantId },
-          `Re-sending ${label} without the field the platform rejected`,
+          `Re-sending ${label} without the field the cloud rejected`,
         );
         sent = reduced;
         resp = await send(sent.body);

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

@@ -1,14 +1,14 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-interface MockPlatformClient {
-  platformAssistantId: string;
+interface MockCloudClient {
+  cloudAssistantId: string;
   fetch: ReturnType<typeof mock>;
 }
 
-let mockClient: MockPlatformClient | null = null;
+let mockClient: MockCloudClient | null = null;
 
 mock.module("./client.js", () => ({
-  CadetPlatformClient: {
+  CadetCloudClient: {
     create: async () => mockClient,
   },
 }));
@@ -17,14 +17,14 @@ import {
   managedSpeechSynthesize,
   managedSpeechTranscribe,
   managedSpeechVoices,
-} from "./managed-speech.js";
+} from "./cloud-speech.js";
 
 const AUDIO = Buffer.from([0x01, 0x02, 0x03, 0xff]);
 
 describe("managedSpeechTranscribe", () => {
   beforeEach(() => {
     mockClient = {
-      platformAssistantId: "asst-123",
+      cloudAssistantId: "asst-123",
       fetch: mock(
         async () =>
           new Response(
@@ -59,7 +59,7 @@ describe("managedSpeechTranscribe", () => {
       string,
       RequestInit,
     ];
-    expect(path).toBe("/v1/assistants/asst-123/managed-speech/stt/transcribe/");
+    expect(path).toBe("/v1/assistants/asst-123/cloud-speech/stt/transcribe/");
     expect(init.method).toBe("POST");
     const body = JSON.parse(init.body as string);
     expect(body).toEqual({
@@ -76,7 +76,7 @@ describe("managedSpeechTranscribe", () => {
   });
 
   test("sends the spoken language when one is given", async () => {
-    // The platform forwards this to Deepgram, which otherwise decodes the
+    // The cloud forwards this to Deepgram, which otherwise decodes the
     // audio as English rather than detecting its language.
     await managedSpeechTranscribe({
       audio: AUDIO,
@@ -89,7 +89,7 @@ describe("managedSpeechTranscribe", () => {
 
   test("omits language when not provided", async () => {
     // An absent field and an empty one are different requests upstream, and
-    // the empty one fails the platform serializer.
+    // the empty one fails the cloud serializer.
     await managedSpeechTranscribe({ audio: AUDIO, mimeType: "audio/wav" });
     const [, init] = mockClient!.fetch.mock.calls[0] as [string, RequestInit];
     expect(JSON.parse(init.body as string)).not.toHaveProperty("language");
@@ -105,7 +105,7 @@ describe("managedSpeechTranscribe", () => {
   });
 
   test("returns unavailable when the assistant ID is missing", async () => {
-    mockClient!.platformAssistantId = "";
+    mockClient!.cloudAssistantId = "";
     const result = await managedSpeechTranscribe({
       audio: AUDIO,
       mimeType: "audio/wav",
@@ -113,7 +113,7 @@ describe("managedSpeechTranscribe", () => {
     expect(result).toMatchObject({ ok: false, kind: "unavailable" });
   });
 
-  test("surfaces the platform error code on 402", async () => {
+  test("surfaces the cloud error code on 402", async () => {
     mockClient!.fetch = mock(
       async () =>
         new Response(
@@ -137,7 +137,7 @@ describe("managedSpeechTranscribe", () => {
     });
   });
 
-  test("treats a malformed 200 body as a platform error", async () => {
+  test("treats a malformed 200 body as a cloud error", async () => {
     mockClient!.fetch = mock(
       async () =>
         new Response(JSON.stringify({ unexpected: true }), {
@@ -169,7 +169,7 @@ describe("managedSpeechVoices", () => {
 
   beforeEach(() => {
     mockClient = {
-      platformAssistantId: "asst-123",
+      cloudAssistantId: "asst-123",
       fetch: mock(async () => Response.json(CATALOG)),
     };
   });
@@ -178,7 +178,7 @@ describe("managedSpeechVoices", () => {
     mockClient = null;
   });
 
-  test("fetches and parses the platform voice catalog", async () => {
+  test("fetches and parses the cloud voice catalog", async () => {
     const result = await managedSpeechVoices();
 
     expect(result.ok).toBe(true);
@@ -189,7 +189,7 @@ describe("managedSpeechVoices", () => {
       string,
       RequestInit,
     ];
-    expect(path).toBe("/v1/assistants/asst-123/managed-speech/tts/voices/");
+    expect(path).toBe("/v1/assistants/asst-123/cloud-speech/tts/voices/");
     expect(init.method).toBe("GET");
   });
 
@@ -209,7 +209,7 @@ describe("managedSpeechVoices", () => {
     }
   });
 
-  test("treats a malformed body as a platform error", async () => {
+  test("treats a malformed body as a cloud error", async () => {
     mockClient!.fetch = mock(async () => Response.json({ nope: true }));
     const result = await managedSpeechVoices();
     expect(result).toMatchObject({ ok: false, kind: "platform-error" });
@@ -236,7 +236,7 @@ describe("managedSpeechSynthesize", () => {
 
   beforeEach(() => {
     mockClient = {
-      platformAssistantId: "asst-123",
+      cloudAssistantId: "asst-123",
       fetch: mock(
         async () =>
           new Response(new Uint8Array(MP3_BYTES), {
@@ -266,7 +266,7 @@ describe("managedSpeechSynthesize", () => {
       string,
       RequestInit,
     ];
-    expect(path).toBe("/v1/assistants/asst-123/managed-speech/tts/synthesize/");
+    expect(path).toBe("/v1/assistants/asst-123/cloud-speech/tts/synthesize/");
     expect(JSON.parse(init.body as string)).toEqual({
       text: "hello",
       format: "pcm_16000",
@@ -302,7 +302,7 @@ describe("managedSpeechSynthesize", () => {
     expect(result.ok && result.value.contentType).toBe("audio/mpeg");
   });
 
-  test("treats empty audio as a platform error", async () => {
+  test("treats empty audio as a cloud error", async () => {
     mockClient!.fetch = mock(
       async () => new Response(new Uint8Array(0), { status: 200 }),
     );