@mycadet/assistant 0.12.7 → 0.12.8

package/src/oauth/{platform-connection.ts → cloud-connection.ts}

@@ -1,4 +1,4 @@
-import type { CadetPlatformClient } from "../platform/client.js";
+import type { CadetCloudClient } from "../cloud/client.js";
 import { BackendError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { getHttpRetryDelay, isRetryableStatus, sleep } from "../util/retry.js";
@@ -36,7 +36,7 @@ export class ProviderUnreachableError extends BackendError {
 
 export class InsufficientBalanceError extends BackendError {
   constructor(
-    message = "Your Cadet account balance is too low to use this managed OAuth connection. " +
+    message = "Your Cadet account balance is too low to use this cloud OAuth connection. " +
       "You can add funds or switch to using your own OAuth app.",
   ) {
     super(message);
@@ -45,9 +45,9 @@ export class InsufficientBalanceError extends BackendError {
 }
 
 /**
- * Request options the platform proxy cannot honor. It parses the response
+ * Request options the cloud proxy cannot honor. It parses the response
  * body, rebuilds the query string from the parsed record, and follows provider
- * redirects server-side, so a managed connection answers with re-serialized
+ * redirects server-side, so a cloud connection answers with re-serialized
  * JSON, a regrouped query, and the redirect target's response. A caller that
  * needs the provider's exact bytes, its exact query string, or a verbatim 3xx
  * needs a BYO connection.
@@ -71,7 +71,7 @@ const MANAGED_PROXY_REQUEST_HEADERS = new Set([
 ]);
 
 /** Node fetch defaults can be dropped; other unsupported headers need caller handling. */
-export function prepareManagedProxyHeaders(headers: Record<string, string>): {
+export function prepareCloudProxyHeaders(headers: Record<string, string>): {
   headers: Record<string, string>;
   unsupportedHeaders: string[];
 } {
@@ -91,12 +91,12 @@ export function prepareManagedProxyHeaders(headers: Record<string, string>): {
   return { headers: forwarded, unsupportedHeaders: unsupportedHeaders.sort() };
 }
 
-export interface PlatformOAuthConnectionOptions {
+export interface CloudOAuthConnectionOptions {
   id: string;
   provider: string;
   externalId: string;
   accountInfo: string | null;
-  client: CadetPlatformClient;
+  client: CadetCloudClient;
   /** Platform-side connection ID used in the proxy URL path. */
   connectionId: string;
   /** Provider API base URL (e.g. "https://gmail.googleapis.com/gmail/v1/users/me").
@@ -104,20 +104,20 @@ export interface PlatformOAuthConnectionOptions {
   baseUrl?: string;
 }
 
-export class PlatformOAuthConnection implements OAuthConnection {
+export class CloudOAuthConnection implements OAuthConnection {
   readonly id: string;
   readonly provider: string;
   readonly externalId: string;
   readonly accountInfo: string | null;
 
-  private readonly client: CadetPlatformClient;
+  private readonly client: CadetCloudClient;
   private readonly connectionId: string;
   private readonly baseUrl: string | undefined;
 
-  constructor(options: PlatformOAuthConnectionOptions) {
+  constructor(options: CloudOAuthConnectionOptions) {
     if (!options.connectionId) {
       throw new BackendError(
-        `Platform-managed connection for "${options.provider}" cannot be created: missing connection ID. ` +
+        `Cloud connection for "${options.provider}" cannot be created: missing connection ID. ` +
           `Log in to Cadet Cloud or switch to using your own OAuth app.`,
       );
     }
@@ -132,7 +132,7 @@ export class PlatformOAuthConnection implements OAuthConnection {
   }
 
   async request(req: OAuthConnectionRequest): Promise<OAuthConnectionResponse> {
-    const proxyPath = `/v1/assistants/${this.client.platformAssistantId}/external-provider-proxy/${this.connectionId}/`;
+    const proxyPath = `/v1/assistants/${this.client.cloudAssistantId}/external-provider-proxy/${this.connectionId}/`;
 
     // The envelope carries the caller's headers and body side by side. A
     // string body is placed in the envelope as a string, so the proxy forwards
@@ -164,7 +164,7 @@ export class PlatformOAuthConnection implements OAuthConnection {
     }
 
     // A retry replays the whole request upstream, and a 502 arrives only after
-    // the platform already called the provider, so a caller forwarding a write
+    // the cloud already called the provider, so a caller forwarding a write
     // it cannot repeat gets a single attempt.
     const retriesAllowed = req.singleAttempt === true ? 0 : MAX_RETRIES;
 
@@ -192,8 +192,8 @@ export class PlatformOAuthConnection implements OAuthConnection {
         attempt < retriesAllowed
       ) {
         log.warn(
-          { status: response.status, attempt, provider: "platform-proxy" },
-          `Retryable status ${response.status} from platform proxy (attempt ${attempt + 1}/${retriesAllowed + 1})`,
+          { status: response.status, attempt, provider: "cloud-proxy" },
+          `Retryable status ${response.status} from cloud proxy (attempt ${attempt + 1}/${retriesAllowed + 1})`,
         );
         await sleep(getHttpRetryDelay(response, attempt));
         continue;
@@ -219,7 +219,7 @@ export class PlatformOAuthConnection implements OAuthConnection {
         body_encoding?: string | null;
       };
 
-      return decodePlatformProxyEnvelope(json);
+      return decodeCloudProxyEnvelope(json);
     }
 
     throw new BackendError("Platform proxy request failed after retries");
@@ -227,12 +227,12 @@ export class PlatformOAuthConnection implements OAuthConnection {
 
   async withToken<T>(_fn: (token: string) => Promise<T>): Promise<T> {
     throw new BackendError(
-      "Raw token access is not supported for platform-managed connections. Use connection.request() instead.",
+      "Raw token access is not supported for cloud connections. Use connection.request() instead.",
     );
   }
 }
 
-function decodePlatformProxyEnvelope(json: {
+function decodeCloudProxyEnvelope(json: {
   status: number;
   headers: Record<string, string>;
   body: unknown;
@@ -240,7 +240,7 @@ function decodePlatformProxyEnvelope(json: {
 }): OAuthConnectionResponse {
   // A status outside the range `Response` accepts cannot be emitted, and
   // clamping it would attribute a status to the provider that it never sent,
-  // so an unusable envelope fails as a platform fault instead.
+  // so an unusable envelope fails as a cloud fault instead.
   const { status } = json;
   if (
     !Number.isInteger(status) ||

package/src/oauth/connection-resolver.test.ts

@@ -10,7 +10,7 @@ let mockConnections:
   | Array<Record<string, unknown> & { clientId?: string; accountInfo?: string }>
   | undefined;
 let mockAccessToken: string | undefined;
-let mockPlatformClient: Record<string, unknown> | null = null;
+let mockCloudClient: Record<string, unknown> | null = null;
 let syncManualTokenCalls: string[] = [];
 
 // ---------------------------------------------------------------------------
@@ -60,9 +60,9 @@ mock.module("./manual-token-connection.js", () => ({
   },
 }));
 
-mock.module("../platform/client.js", () => ({
-  CadetPlatformClient: {
-    create: async () => mockPlatformClient,
+mock.module("../cloud/client.js", () => ({
+  CadetCloudClient: {
+    create: async () => mockCloudClient,
   },
 }));
 
@@ -72,15 +72,15 @@ mock.module("../platform/client.js", () => ({
 
 import { setConfig } from "../__tests__/helpers/set-config.js";
 import { BYOOAuthConnection } from "./byo-connection.js";
+import { CloudOAuthConnection } from "./cloud-connection.js";
 import {
+  cloudProxyBaseUrl,
   formatNoConnectionError,
-  platformProxyBaseUrl,
   resolveEffectiveBaseUrl,
   resolveOAuthConnection,
   resolveOAuthConnectionWithMeta,
   resolveTokenHeader,
 } from "./connection-resolver.js";
-import { PlatformOAuthConnection } from "./platform-connection.js";
 
 /** Seed `services.<key>.mode` entries into the workspace config for real. */
 function seedServiceModes(modes: Record<string, "managed" | "your-own">): void {
@@ -100,7 +100,7 @@ function makeMockClient() {
   return {
     baseUrl: "https://platform.example.com",
     assistantApiKey: "sk-test-key",
-    platformAssistantId: "asst-123",
+    cloudAssistantId: "asst-123",
     fetch: mock(async () => {
       return new Response(
         JSON.stringify({
@@ -117,7 +117,7 @@ function setupDefaults(): void {
     provider: "google",
     baseUrl: "https://gmail.googleapis.com/gmail/v1/users/me",
     authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
-    managedServiceConfigKey: null,
+    cloudServiceConfigKey: null,
   };
   mockConnection = {
     id: "conn-1",
@@ -131,7 +131,7 @@ function setupDefaults(): void {
   mockAccessToken = "tok-valid";
   seedServiceModes({ "google-oauth": "managed" });
   mockConnections = undefined;
-  mockPlatformClient = makeMockClient();
+  mockCloudClient = makeMockClient();
   syncManualTokenCalls = [];
 }
 
@@ -144,37 +144,37 @@ describe("resolveOAuthConnection", () => {
     setupDefaults();
   });
 
-  test("returns BYOOAuthConnection when provider has no managedServiceConfigKey", async () => {
+  test("returns BYOOAuthConnection when provider has no cloudServiceConfigKey", async () => {
     const result = await resolveOAuthConnection("google");
     expect(result).toBeInstanceOf(BYOOAuthConnection);
     expect(result.id).toBe("conn-1");
     expect(result.provider).toBe("google");
   });
 
-  test("returns PlatformOAuthConnection when managed mode is active", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
+  test("returns CloudOAuthConnection when managed mode is active", async () => {
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
 
     const result = await resolveOAuthConnection("google");
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
     expect(result.id).toBe("google");
     expect(result.provider).toBe("google");
     expect(result.accountInfo).toBeNull();
   });
 
-  test("passes account through to PlatformOAuthConnection", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
+  test("passes account through to CloudOAuthConnection", async () => {
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
 
     const result = await resolveOAuthConnection("google", {
       account: "user@example.com",
     });
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
     expect(result.accountInfo).toBe("user@example.com");
   });
 
   test("managed path falls back to displayed account label when account_identifier does not match", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
     const fetchPaths: string[] = [];
-    mockPlatformClient = {
+    mockCloudClient = {
       ...makeMockClient(),
       fetch: mock(async (path: string) => {
         fetchPaths.push(path);
@@ -199,7 +199,7 @@ describe("resolveOAuthConnection", () => {
       account: "alice@example.com",
     });
 
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
     expect(result.accountInfo).toBe("alice@example.com");
     expect(fetchPaths).toEqual([
       "/v1/assistants/asst-123/oauth/connections/?provider=google&status=ACTIVE&account_identifier=alice%40example.com",
@@ -207,19 +207,19 @@ describe("resolveOAuthConnection", () => {
     ]);
   });
 
-  test("returns PlatformOAuthConnection when GitHub is in managed mode", async () => {
+  test("returns CloudOAuthConnection when GitHub is in managed mode", async () => {
     mockProvider!.provider = "github";
-    mockProvider!.managedServiceConfigKey = "github-oauth";
+    mockProvider!.cloudServiceConfigKey = "github-oauth";
     seedServiceModes({ "google-oauth": "managed", "github-oauth": "managed" });
 
     const result = await resolveOAuthConnection("github");
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
     expect(result.id).toBe("github");
     expect(result.provider).toBe("github");
   });
 
   test("returns BYOOAuthConnection when service config mode is your-own", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
     seedServiceModes({ "google-oauth": "your-own" });
 
     const result = await resolveOAuthConnection("google");
@@ -228,21 +228,21 @@ describe("resolveOAuthConnection", () => {
   });
 
   test("managed path does not require a local connection row", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
     mockConnection = undefined;
     mockAccessToken = undefined;
 
     const result = await resolveOAuthConnection("google");
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
   });
 
   test("managed path ignores clientId option", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
 
     const result = await resolveOAuthConnection("google", {
       clientId: "some-client-id",
     });
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
   });
 
   test("BYO path narrows by clientId when provided", async () => {
@@ -266,7 +266,7 @@ describe("resolveOAuthConnection", () => {
       provider: "telegram",
       baseUrl: "https://api.telegram.org",
       authorizeUrl: "urn:manual-token",
-      managedServiceConfigKey: null,
+      cloudServiceConfigKey: null,
     };
     mockConnection = {
       id: "conn-telegram",
@@ -310,11 +310,11 @@ describe("resolveOAuthConnection scope-awareness", () => {
 
   beforeEach(() => {
     setupDefaults();
-    mockProvider!.managedServiceConfigKey = "google-oauth";
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
   });
 
   test("managed: rejects a Calendar-only connection when Gmail scope is required", async () => {
-    mockPlatformClient = clientReturning([
+    mockCloudClient = clientReturning([
       { id: "cal-only", account_label: null, scopes_granted: CALENDAR_ONLY },
     ]);
 
@@ -324,18 +324,18 @@ describe("resolveOAuthConnection scope-awareness", () => {
   });
 
   test("managed: resolves when a connection carries the required Gmail scope", async () => {
-    mockPlatformClient = clientReturning([
+    mockCloudClient = clientReturning([
       { id: "full", account_label: null, scopes_granted: FULL_BUNDLE },
     ]);
 
     const result = await resolveOAuthConnection("google", {
       requiredScopes: [GMAIL_SCOPE],
     });
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
   });
 
   test("managed: treats full Gmail access as covering Gmail read access", async () => {
-    mockPlatformClient = clientReturning([
+    mockCloudClient = clientReturning([
       {
         id: "full-gmail-access",
         account_label: null,
@@ -346,19 +346,17 @@ describe("resolveOAuthConnection scope-awareness", () => {
     const result = await resolveOAuthConnection("google", {
       requiredScopes: [GMAIL_SCOPE],
     });
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
   });
 
   test("managed: unknown scope data never blocks (back-compat)", async () => {
     // Older connections report no scopes_granted — must not be rejected.
-    mockPlatformClient = clientReturning([
-      { id: "legacy", account_label: null },
-    ]);
+    mockCloudClient = clientReturning([{ id: "legacy", account_label: null }]);
 
     const result = await resolveOAuthConnection("google", {
       requiredScopes: [GMAIL_SCOPE],
     });
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
   });
 
   test("managed: prefers a scope-satisfying connection over a narrow one", async () => {
@@ -366,24 +364,24 @@ describe("resolveOAuthConnection scope-awareness", () => {
       { id: "cal-only", account_label: null, scopes_granted: CALENDAR_ONLY },
       { id: "full", account_label: null, scopes_granted: FULL_BUNDLE },
     ]);
-    mockPlatformClient = fullClient;
+    mockCloudClient = fullClient;
 
     const result = await resolveOAuthConnection("google", {
       requiredScopes: [GMAIL_SCOPE],
     });
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
-    // PlatformOAuthConnection is keyed by provider, so assert resolution
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
+    // CloudOAuthConnection is keyed by provider, so assert resolution
     // succeeded (it would have thrown if only the narrow connection matched).
     expect(result.provider).toBe("google");
   });
 
   test("managed: no requiredScopes preserves prior behavior", async () => {
-    mockPlatformClient = clientReturning([
+    mockCloudClient = clientReturning([
       { id: "cal-only", account_label: null, scopes_granted: CALENDAR_ONLY },
     ]);
 
     const result = await resolveOAuthConnection("google");
-    expect(result).toBeInstanceOf(PlatformOAuthConnection);
+    expect(result).toBeInstanceOf(CloudOAuthConnection);
   });
 
   test("BYO: rejects when granted scopes are known and missing the requirement", async () => {
@@ -459,8 +457,8 @@ describe("resolveOAuthConnectionWithMeta multi-account visibility", () => {
   });
 
   test("managed: multiple connections + no account surfaces ambiguity and the selected label", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
-    mockPlatformClient = clientReturning([
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
+    mockCloudClient = clientReturning([
       { id: "conn-personal", account_label: "user@example.com" },
       { id: "conn-work", account_label: "work@example.com" },
     ]);
@@ -475,8 +473,8 @@ describe("resolveOAuthConnectionWithMeta multi-account visibility", () => {
   });
 
   test("managed: account passed disambiguates and clears the warning", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
-    mockPlatformClient = clientReturning([
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
+    mockCloudClient = clientReturning([
       { id: "conn-work", account_label: "work@example.com" },
     ]);
 
@@ -488,8 +486,8 @@ describe("resolveOAuthConnectionWithMeta multi-account visibility", () => {
   });
 
   test("managed: single connection is never ambiguous", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
-    mockPlatformClient = clientReturning([
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
+    mockCloudClient = clientReturning([
       { id: "conn-only", account_label: "user@example.com" },
     ]);
 
@@ -632,8 +630,8 @@ describe("no-match error lists available accounts", () => {
   });
 
   test("managed: names the provider's active accounts when the requested account misses", async () => {
-    mockProvider!.managedServiceConfigKey = "google-oauth";
-    mockPlatformClient = clientReturning([
+    mockProvider!.cloudServiceConfigKey = "google-oauth";
+    mockCloudClient = clientReturning([
       { id: "conn-personal", account_label: "user@example.com" },
       { id: "conn-work", account_label: "other@example.org" },
     ]);
@@ -758,29 +756,29 @@ describe("resolveEffectiveBaseUrl", () => {
   });
 });
 
-describe("platformProxyBaseUrl", () => {
+describe("cloudProxyBaseUrl", () => {
   test("forwards a concrete seed base URL", () => {
-    expect(platformProxyBaseUrl("https://api.figma.com")).toBe(
+    expect(cloudProxyBaseUrl("https://api.figma.com")).toBe(
       "https://api.figma.com",
     );
   });
 
-  test("withholds a templated base URL so the platform fills it", () => {
+  test("withholds a templated base URL so the cloud fills it", () => {
     // Shopify's host and QuickBooks' realm are pinned to the connection on
-    // the platform. Forwarding the unfilled template would fail the proxy's
-    // allowlist check and shadow the platform's own default.
-    expect(platformProxyBaseUrl("https://{tenant_host}")).toBeUndefined();
+    // the cloud. Forwarding the unfilled template would fail the proxy's
+    // allowlist check and shadow the cloud's own default.
+    expect(cloudProxyBaseUrl("https://{tenant_host}")).toBeUndefined();
     expect(
-      platformProxyBaseUrl(
+      cloudProxyBaseUrl(
         "https://quickbooks.api.intuit.com/v3/company/{realm_id}",
       ),
     ).toBeUndefined();
   });
 
   test("treats a missing base URL as no override", () => {
-    expect(platformProxyBaseUrl(undefined)).toBeUndefined();
-    expect(platformProxyBaseUrl(null)).toBeUndefined();
-    expect(platformProxyBaseUrl("")).toBeUndefined();
+    expect(cloudProxyBaseUrl(undefined)).toBeUndefined();
+    expect(cloudProxyBaseUrl(null)).toBeUndefined();
+    expect(cloudProxyBaseUrl("")).toBeUndefined();
   });
 });
 

package/src/oauth/connection-resolver.ts

@@ -1,17 +1,17 @@
+import { CadetCloudClient } from "../cloud/client.js";
 import { getConfig } from "../config/loader.js";
 import {
   getServiceMode,
   type Services,
   ServicesSchema,
 } from "../config/schemas/services.js";
-import { CadetPlatformClient } from "../platform/client.js";
 import { getLogger } from "../util/logger.js";
 import { BYOOAuthConnection, type BYOTokenHeader } from "./byo-connection.js";
+import { CloudOAuthConnection } from "./cloud-connection.js";
 import type { OAuthConnection } from "./connection.js";
 import { getConnectionAccessTokenResult } from "./credential-token-resolver.js";
 import { syncManualTokenConnection } from "./manual-token-connection.js";
 import { getActiveConnections, getProvider } from "./oauth-store.js";
-import { PlatformOAuthConnection } from "./platform-connection.js";
 import { scopeDifference } from "./scope-utils.js";
 
 const log = getLogger("connection-resolver");
@@ -68,7 +68,7 @@ export interface OAuthConnectionResolution {
  *   Maps to the `provider_key` primary key in the `oauth_providers` table.
  * @param options.clientId - Optional OAuth app client ID. When multiple BYO
  *   apps exist for the same provider, narrows the connection lookup to the
- *   app matching this client ID. Ignored for managed providers.
+ *   app matching this client ID. Ignored for cloud providers.
  * @param options.account - Optional account identifier to disambiguate
  *   multi-account connections.
  */
@@ -87,8 +87,8 @@ export async function resolveOAuthConnection(
  * Resolve an OAuthConnection along with the account that served it and whether
  * the selection was ambiguous.
  *
- * Managed providers (where the service config `mode` is `"managed"`) are
- * routed through the platform proxy with no local state required.
+ * Cloud providers (where the service config `mode` is `"managed"`) are
+ * routed through the cloud proxy with no local state required.
  *
  * BYO providers resolve from the local SQLite oauth-store and require an
  * active connection row and a stored access token.
@@ -99,18 +99,18 @@ export async function resolveOAuthConnectionWithMeta(
 ): Promise<OAuthConnectionResolution> {
   const { clientId, account, requiredScopes } = options ?? {};
   const providerRow = getProvider(provider);
-  const managedKey = providerRow?.managedServiceConfigKey;
+  const managedKey = providerRow?.cloudServiceConfigKey;
 
   if (managedKey && managedKey in ServicesSchema.shape) {
     const services: Services = getConfig().services;
     if (getServiceMode(services, managedKey as keyof Services) === "managed") {
-      const client = await CadetPlatformClient.create();
-      if (!client || !client.platformAssistantId) {
+      const client = await CadetCloudClient.create();
+      if (!client || !client.cloudAssistantId) {
         const detail = !client
           ? "missing platform prerequisites"
           : "missing assistant ID";
         throw new Error(
-          `Platform-managed connection for "${provider}" cannot be created: ${detail}. ` +
+          `Cloud connection for "${provider}" cannot be created: ${detail}. ` +
             `Log in to Cadet Cloud or switch to using your own OAuth app.`,
         );
       }
@@ -122,7 +122,7 @@ export async function resolveOAuthConnectionWithMeta(
         requiredScopes,
       });
 
-      const connection = new PlatformOAuthConnection({
+      const connection = new CloudOAuthConnection({
         id: provider,
         provider,
         externalId: provider,
@@ -130,9 +130,9 @@ export async function resolveOAuthConnectionWithMeta(
         client,
         connectionId: resolution.id,
         // A templated base URL (`https://{tenant_host}`, `.../{realm_id}`) is
-        // filled in by the platform from what it pinned to the connection;
+        // filled in by the cloud from what it pinned to the connection;
         // sent as-is it would fail the proxy's allowlist and shadow that.
-        baseUrl: platformProxyBaseUrl(providerRow?.baseUrl),
+        baseUrl: cloudProxyBaseUrl(providerRow?.baseUrl),
       });
       return {
         connection,
@@ -321,15 +321,15 @@ function hostMatchesPattern(host: string, pattern: string): boolean {
 }
 
 /**
- * The base URL a managed connection sends to the platform proxy, or
+ * The base URL a cloud connection sends to the cloud proxy, or
  * `undefined` to let the proxy use the provider's configured default.
  *
- * Per-tenant and per-realm providers seed a template the platform fills from
+ * Per-tenant and per-realm providers seed a template the cloud fills from
  * the connection (`{tenant_host}`, `{realm_id}`). Forwarding the unfilled
  * template would fail the proxy's allowlist check, so those fall through to
- * the platform's own default.
+ * the cloud's own default.
  */
-export function platformProxyBaseUrl(
+export function cloudProxyBaseUrl(
   seedBaseUrl: string | null | undefined,
 ): string | undefined {
   if (!seedBaseUrl || /\{[a-z_]+\}/.test(seedBaseUrl)) {
@@ -403,7 +403,7 @@ function parseConnectionMetadata(
 // ---------------------------------------------------------------------------
 
 interface ResolvePlatformConnectionIdOptions {
-  client: CadetPlatformClient;
+  client: CadetCloudClient;
   provider: string;
   account?: string;
   requiredScopes?: string[];
@@ -412,7 +412,7 @@ interface ResolvePlatformConnectionIdOptions {
 interface PlatformConnectionEntry {
   id: string;
   account_label?: string | null;
-  /** Scopes the platform actually granted this connection. May be absent for
+  /** Scopes the cloud actually granted this connection. May be absent for
    *  older connections or providers that don't report scopes. */
   scopes_granted?: string[] | null;
   /** Provider-supplied values the connection is scoped by (QuickBooks'
@@ -437,11 +437,11 @@ function platformConnectionLabel(entry: PlatformConnectionEntry): string {
 }
 
 /**
- * Fetch active cloud connections for a managed provider by calling the
+ * Fetch active cloud connections for a cloud provider by calling the
  * List Connections endpoint.
  */
 async function fetchPlatformConnections(options: {
-  client: CadetPlatformClient;
+  client: CadetCloudClient;
   provider: string;
   accountIdentifier?: string;
 }): Promise<PlatformConnectionEntry[]> {
@@ -453,7 +453,7 @@ async function fetchPlatformConnections(options: {
     params.set("account_identifier", accountIdentifier);
   }
 
-  const path = `/v1/assistants/${client.platformAssistantId}/oauth/connections/?${params.toString()}`;
+  const path = `/v1/assistants/${client.cloudAssistantId}/oauth/connections/?${params.toString()}`;
   const response = await client.fetch(path);
 
   if (!response.ok) {
@@ -475,7 +475,7 @@ async function fetchPlatformConnections(options: {
 }
 
 /**
- * Fetch the platform-side connection ID for a managed provider by calling
+ * Fetch the cloud-side connection ID for a cloud provider by calling
  * the List Connections endpoint.
  */
 async function resolvePlatformConnectionId(

package/src/oauth/connection.ts

@@ -8,7 +8,7 @@ export interface OAuthConnectionRequest {
    * where rebuilding {@link OAuthConnectionRequest.query} would reorder
    * interleaved repeated keys, rewrite `%20` as `+`, and give a valueless flag
    * an `=`. An empty one falls through to `query`. Honored by BYO connections;
-   * a managed connection sends `query` to the platform proxy, which rebuilds
+   * a cloud connection sends `query` to the cloud proxy, which rebuilds
    * it.
    */
   rawQuery?: string;