@mycadet/assistant 0.12.7 → 0.12.9

package/src/providers/__tests__/preflight-resolved-config.test.ts

@@ -24,13 +24,13 @@ mock.module("../provider-availability.js", () => ({
         : "absent",
 }));
 
-mock.module("../platform-proxy/context.js", () => ({
-  hasManagedProxyPrereqs: async () => platformLoggedIn,
-  resolveManagedProxyContext: async () => ({
+mock.module("../cloud-proxy/context.js", () => ({
+  hasCloudProxyPrereqs: async () => platformLoggedIn,
+  resolveCloudProxyContext: async () => ({
     enabled: platformLoggedIn,
     // Base URL configured: an unauthenticated result must come from the
     // credential probe, so CES outages stay distinguishable.
-    platformBaseUrl: "https://platform",
+    cloudBaseUrl: "https://platform",
     assistantApiKey: platformLoggedIn ? "key" : "",
   }),
 }));
@@ -74,11 +74,11 @@ beforeEach(() => {
   secureKeys = { "credential/anthropic/api_key": "sk-ant" };
   cesUnreachable = false;
   platformLoggedIn = false;
-  delete process.env.IS_PLATFORM;
+  delete process.env.IS_CLOUD;
 });
 
 afterEach(() => {
-  delete process.env.IS_PLATFORM;
+  delete process.env.IS_CLOUD;
 });
 
 describe("preflightResolvedConfig", () => {
@@ -140,7 +140,7 @@ describe("preflightResolvedConfig", () => {
     ).resolves.toBeUndefined();
   });
 
-  test("a cadet identity without a platform login throws platform_unauthenticated", async () => {
+  test("a cadet identity without a cloud login throws platform_unauthenticated", async () => {
     connectionsByName["cadet"] = {
       name: "cadet",
       provider: "cadet",
@@ -153,9 +153,9 @@ describe("preflightResolvedConfig", () => {
     expect(err?.reason).toBe("platform_unauthenticated");
   });
 
-  test("a user-owned row claiming the cadet name preflights the platform", async () => {
+  test("a user-owned row claiming the cadet name preflights the cloud", async () => {
     // Dispatch ignores that row, so its credential is irrelevant to the
-    // verdict: signed in passes, signed out is the platform's own failure.
+    // verdict: signed in passes, signed out is the cloud's own failure.
     connectionsByName["cadet"] = {
       name: "cadet",
       provider: "openai",
@@ -295,7 +295,7 @@ describe("preflightResolvedConfig", () => {
     expect(err?.reason).toBe("model_incompatible");
   });
 
-  test("the cadet managed connection serves managed-routable providers when logged in", async () => {
+  test("the cadet cloud connection serves managed-routable providers when logged in", async () => {
     connectionsByName = {
       cadet: {
         name: "cadet",
@@ -315,7 +315,7 @@ describe("preflightResolvedConfig", () => {
     expect(err?.reason).toBe("platform_unauthenticated");
   });
 
-  test("the cadet managed connection rejects non-managed-routable providers", async () => {
+  test("the cadet cloud connection rejects non-managed-routable providers", async () => {
     connectionsByName = {
       cadet: {
         name: "cadet",
@@ -330,7 +330,7 @@ describe("preflightResolvedConfig", () => {
     expect(err?.reason).toBe("provider_mismatch");
   });
 
-  test("platform-auth connections require a platform login", async () => {
+  test("cloud-auth connections require a cloud login", async () => {
     connectionsByName["anthropic-personal"] = {
       name: "anthropic-personal",
       provider: "anthropic",
@@ -363,7 +363,7 @@ describe("preflightResolvedConfig", () => {
   });
 });
 
-describe("preflightResolvedConfig platform-managed credential messaging", () => {
+describe("preflightResolvedConfig cloud credential messaging", () => {
   const platformManaged = () => {
     connectionsByName = {
       cadet: {
@@ -372,7 +372,7 @@ describe("preflightResolvedConfig platform-managed credential messaging", () =>
         auth: { type: "platform" },
       },
     };
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
   };
   const managedRoute = () => resolved({ provider_connection: "cadet" });
 
@@ -400,7 +400,7 @@ describe("preflightResolvedConfig platform-managed credential messaging", () =>
     expect(await preflightError(managedRoute())).toBeUndefined();
   });
 
-  test("non-platform install keeps the log-in-or-switch wording", async () => {
+  test("non-cloud install keeps the log-in-or-switch wording", async () => {
     connectionsByName = {
       cadet: {
         name: "cadet",
@@ -408,7 +408,7 @@ describe("preflightResolvedConfig platform-managed credential messaging", () =>
         auth: { type: "platform" },
       },
     };
-    // IS_PLATFORM left unset covers both local and self-hosted Docker installs.
+    // IS_CLOUD left unset covers both local and self-hosted Docker installs.
     const err = await preflightError(managedRoute());
     expect(err?.reason).toBe("platform_unauthenticated");
     expect(err?.message).toContain("log in or pick a different provider");

package/src/providers/__tests__/retry-callsite.test.ts

@@ -443,7 +443,7 @@ describe("RetryProvider — callSite resolution", () => {
     // The profile declares `provider: "cadet"` (the provider-agnostic managed
     // sentinel) and the real upstream comes from the model id, so the stub is
     // named for that resolved upstream rather than the sentinel, matching what
-    // `createAdapterFromConnection` builds for a managed route.
+    // `createAdapterFromConnection` builds for a cloud route.
     setLlmConfig({});
 
     const expected = CODE_DEFAULT_PROFILE_ENTRIES["latency-optimized"];

package/src/providers/__tests__/satellite-connection-routing.test.ts

@@ -94,7 +94,7 @@ mock.module("../inference/connections.js", () => ({
 
 // Connection names that should make `resolveProviderFromConnection` throw —
 // simulates a transient failure inside auth resolution (credential read,
-// managed-proxy context lookup) bubbling up from the inner registry call.
+// cloud-proxy context lookup) bubbling up from the inner registry call.
 const connectionsThatThrowOnResolve = new Set<string>();
 
 mock.module("../registry.js", () => ({
@@ -186,14 +186,14 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
 
     setLlmConfig({
       profiles: {
-        "managed-profile": {
+        "cloud-profile": {
           provider: "anthropic",
           provider_connection: "anthropic-managed",
           model: "claude-opus-4-7",
         },
       },
       callSites: {
-        replySuggestion: { profile: "managed-profile" },
+        replySuggestion: { profile: "cloud-profile" },
       },
     });
 
@@ -406,7 +406,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
 
   test("transient auth-resolution failure → falls back to default (graceful per-call degradation)", async () => {
     // Simulates a transient error inside `resolveProviderFromConnection`
-    // (e.g. a credential read fails, or managed-proxy context lookup
+    // (e.g. a credential read fails, or cloud-proxy context lookup
     // throws). The connection-resolution helper catches transient throws
     // and returns null. The wrapper then falls back to the default
     // Provider so a credential blip does not take inference offline.

package/src/providers/__tests__/search-provider-catalog.test.ts

@@ -37,7 +37,7 @@ describe("search-provider-catalog", () => {
     }
   });
 
-  test("managed providers omit BYOK-only fields", () => {
+  test("cloud providers omit BYOK-only fields", () => {
     const managed = SEARCH_PROVIDER_CATALOG.filter((p) => p.kind === "managed");
     for (const provider of managed) {
       expect(provider.envVar).toBeUndefined();
@@ -75,7 +75,7 @@ describe("search-provider-catalog", () => {
     expect(SEARCH_PROVIDER_FALLBACK_ORDER).toEqual(sorted);
   });
 
-  test("cadet is a managed provider outside the BYOK fallback chain", () => {
+  test("cadet is a cloud provider outside the BYOK fallback chain", () => {
     expect(getSearchProvider("cadet")?.kind).toBe("managed");
     expect(BYOK_SEARCH_PROVIDERS.map((p) => p.id)).not.toContain("cadet");
     expect(SEARCH_PROVIDER_FALLBACK_ORDER).not.toContain("cadet");

package/src/providers/__tests__/voice-error-copy.test.ts

@@ -50,10 +50,10 @@ describe("describeSttFailure", () => {
     });
   });
 
-  describe("managed speech (userFacing marker)", () => {
+  describe("cloud speech (userFacing marker)", () => {
     test("auth failure surfaces the reconnect remediation verbatim", () => {
       const message =
-        "Managed speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";
+        "Cloud speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";
       const copy = describeSttFailure(
         new SttError("auth", message, { userFacing: true }),
         "cadet",
@@ -77,7 +77,7 @@ describe("describeSttFailure", () => {
     });
 
     test("passthrough does not depend on the provider label", () => {
-      const message = "Managed speech relay error: upstream_error";
+      const message = "Cloud speech relay error: upstream_error";
       const copy = describeSttFailure(
         new SttError("provider-error", message, { userFacing: true }),
         undefined,

package/src/providers/anthropic/client.ts

@@ -153,7 +153,7 @@ export function deriveAnthropicReason(
   const status = error.status;
   const haystack = `${apiType ?? ""} ${error.message ?? ""}`;
 
-  // The managed proxy's daily-limit 402 shares the status with generic credit
+  // The cloud proxy's daily-limit 402 shares the status with generic credit
   // exhaustion; match its specific body code first so it isn't swallowed.
   if (FREE_TIER_DAILY_LIMIT_PATTERNS.some((re) => re.test(haystack))) {
     return "free_tier_daily_limit_reached";

package/src/providers/cadet/client.ts

@@ -11,7 +11,7 @@ export interface CadetProviderOptions {
 
 /**
  * OpenAI-compatible client for Cadet-hosted GPU inference.
- * Managed requests set `baseURL` to the platform `/v1/runtime-proxy/cadet`
+ * Managed requests set `baseURL` to the cloud `/v1/runtime-proxy/cadet`
  * path and authenticate with the assistant API key. These models have no
  * bring-your-own-key path.
  */

package/src/providers/cadet-model-routing.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  CLOUD_ROUTABLE_PROVIDERS,
   formatCadetModel,
-  getManagedUpstream,
-  MANAGED_ROUTABLE_PROVIDERS,
+  getCloudUpstream,
   parseCadetModel,
 } from "./cadet-model-routing.js";
 
@@ -26,7 +26,7 @@ describe("cadet-model-routing", () => {
     });
   });
 
-  test("format rejects a non-managed provider", () => {
+  test("format rejects a non-cloud provider", () => {
     expect(() => formatCadetModel("openrouter", "x")).toThrow();
     expect(() => formatCadetModel("fireworks", "")).toThrow();
   });
@@ -39,35 +39,35 @@ describe("cadet-model-routing", () => {
     expect(parseCadetModel("/foo")).toBeNull(); // empty provider
   });
 
-  test("getManagedUpstream resolves a bare catalog id to its owner", () => {
-    expect(getManagedUpstream("claude-fable-5")).toBe("anthropic");
-    expect(getManagedUpstream("qwen/qwen3-8b")).toBe("cadet");
+  test("getCloudUpstream resolves a bare catalog id to its owner", () => {
+    expect(getCloudUpstream("claude-fable-5")).toBe("anthropic");
+    expect(getCloudUpstream("qwen/qwen3-8b")).toBe("cadet");
   });
 
-  test("getManagedUpstream resolves a routing string by its prefix", () => {
+  test("getCloudUpstream resolves a routing string by its prefix", () => {
     expect(
-      getManagedUpstream("fireworks/accounts/fireworks/models/minimax-m3"),
+      getCloudUpstream("fireworks/accounts/fireworks/models/minimax-m3"),
     ).toBe("fireworks");
   });
 
-  test("getManagedUpstream returns null for non-managed owners", () => {
-    expect(getManagedUpstream("MiniMax-M3")).toBeNull(); // minimax, not managed
-    expect(getManagedUpstream("openrouter/whatever")).toBeNull();
+  test("getCloudUpstream returns null for non-managed owners", () => {
+    expect(getCloudUpstream("MiniMax-M3")).toBeNull(); // minimax, not managed
+    expect(getCloudUpstream("openrouter/whatever")).toBeNull();
   });
 
-  test("getManagedUpstream returns null for unknown models", () => {
-    expect(getManagedUpstream("not-a-real-model")).toBeNull();
-    expect(getManagedUpstream("")).toBeNull();
+  test("getCloudUpstream returns null for unknown models", () => {
+    expect(getCloudUpstream("not-a-real-model")).toBeNull();
+    expect(getCloudUpstream("")).toBeNull();
   });
 
-  test("getManagedUpstream rejects managed-prefixed strings whose model is not cataloged under that provider", () => {
-    expect(getManagedUpstream("anthropic/definitely-not-a-model")).toBeNull();
-    expect(getManagedUpstream("openai/accounts/foo/bar")).toBeNull();
+  test("getCloudUpstream rejects managed-prefixed strings whose model is not cataloged under that provider", () => {
+    expect(getCloudUpstream("anthropic/definitely-not-a-model")).toBeNull();
+    expect(getCloudUpstream("openai/accounts/foo/bar")).toBeNull();
   });
 
-  test("managed set matches the platform proxy table", () => {
+  test("managed set matches the cloud proxy table", () => {
     // Guards against drift if PLATFORM_PROVIDER_META changes.
-    expect([...MANAGED_ROUTABLE_PROVIDERS].sort()).toEqual([
+    expect([...CLOUD_ROUTABLE_PROVIDERS].sort()).toEqual([
       "anthropic",
       "cadet",
       "fireworks",

package/src/providers/cadet-model-routing.ts

@@ -1,5 +1,5 @@
 /**
- * Codec for Cadet-managed model routing strings.
+ * Codec for Cadet Cloud model routing strings.
  *
  * A single `cadet` provider connection is provider-agnostic: unlike the
  * per-provider `*-managed` connections it does not carry the upstream provider
@@ -14,26 +14,26 @@
  * codec — no I/O, no wiring — so it can be adopted incrementally.
  */
 
+import { PLATFORM_PROVIDER_META } from "./cloud-proxy/constants.js";
 import {
   getCatalogProviderForModel,
   isModelInCatalog,
 } from "./model-catalog.js";
-import { PLATFORM_PROVIDER_META } from "./platform-proxy/constants.js";
 
 /**
- * Provider ids that can front a Cadet-managed (platform-proxied) route.
+ * Provider ids that can front a Cadet Cloud (platform-proxied) route.
  * Only these are valid prefixes for a routing string; everything else
  * (openrouter, ollama, openai-compatible, or a raw native model id) is not a
  * Cadet-routed string and `parseCadetModel` returns null for it.
  */
-export const MANAGED_ROUTABLE_PROVIDERS: ReadonlySet<string> = new Set(
+export const CLOUD_ROUTABLE_PROVIDERS: ReadonlySet<string> = new Set(
   Object.values(PLATFORM_PROVIDER_META)
     .filter((m) => m.managed)
     .map((m) => m.name),
 );
 
 /**
- * Sentinel provider id for the single, provider-agnostic Cadet-managed
+ * Sentinel provider id for the single, provider-agnostic Cadet Cloud
  * connection. Unlike the per-provider `*-managed` connections, this one does
  * not name an upstream provider on its DB row — the upstream is determined
  * per-request from the resolving profile. The same id is the catalog owner
@@ -41,10 +41,10 @@ export const MANAGED_ROUTABLE_PROVIDERS: ReadonlySet<string> = new Set(
  * factory id (including `cadet` when that is the catalog owner) before
  * adapter lookup.
  */
-export const CADET_MANAGED_PROVIDER = "cadet";
+export const CADET_CLOUD_PROVIDER = "cadet";
 
 /**
- * Name of the single provider-agnostic Cadet-managed connection row. The
+ * Name of the single provider-agnostic Cadet Cloud connection row. The
  * connection carries platform auth and the `cadet` sentinel instead of a
  * real upstream; the upstream is chosen per-request from the resolving
  * profile's provider. Lives in this pure module (rather than
@@ -52,23 +52,23 @@ export const CADET_MANAGED_PROVIDER = "cadet";
  * default-profile catalog can reference it without importing the
  * DB-connected module graph.
  */
-export const CADET_MANAGED_CONNECTION_NAME = "cadet";
+export const CADET_CLOUD_CONNECTION_NAME = "cadet";
 
 /**
- * Whether a connection is the provider-agnostic Cadet-managed connection.
- * The provider column alone identifies the managed route: platform auth
+ * Whether a connection is the provider-agnostic Cadet Cloud connection.
+ * The provider column alone identifies the cloud route: platform auth
  * always accompanies it (auth derivation pairs them, the connection routes
  * reject writes that split them, and DB migration 361 reconciles stored
  * rows).
  * Structurally typed so this stays a pure module with no connection-schema
  * import.
  */
-export function isCadetManagedConnection(conn: { provider: string }): boolean {
-  return conn.provider === CADET_MANAGED_PROVIDER;
+export function isCadetCloudConnection(conn: { provider: string }): boolean {
+  return conn.provider === CADET_CLOUD_PROVIDER;
 }
 
 export interface CadetModelRoute {
-  /** Upstream provider id, e.g. "fireworks". Always a managed-routable id. */
+  /** Upstream provider id, e.g. "fireworks". Always a cloud-routable id. */
   provider: string;
   /** Native upstream model id, slashes intact, e.g. "accounts/fireworks/models/minimax-m3". */
   model: string;
@@ -79,10 +79,10 @@ export interface CadetModelRoute {
  * Throws on a non-routable provider — that is a caller bug, not user input.
  */
 export function formatCadetModel(provider: string, model: string): string {
-  if (!MANAGED_ROUTABLE_PROVIDERS.has(provider)) {
+  if (!CLOUD_ROUTABLE_PROVIDERS.has(provider)) {
     throw new Error(
-      `formatCadetModel: "${provider}" is not a Cadet-managed provider ` +
-        `(expected one of ${[...MANAGED_ROUTABLE_PROVIDERS].join(", ")})`,
+      `formatCadetModel: "${provider}" is not a Cadet Cloud provider ` +
+        `(expected one of ${[...CLOUD_ROUTABLE_PROVIDERS].join(", ")})`,
     );
   }
   if (!model) {
@@ -97,7 +97,7 @@ export function formatCadetModel(provider: string, model: string): string {
  * Splits on the FIRST slash only so native ids that themselves contain
  * slashes (Fireworks `accounts/fireworks/models/...`) round-trip losslessly.
  * Returns null when the string is not a Cadet-routed model — no slash, empty
- * model, or a prefix that is not a managed-routable provider.
+ * model, or a prefix that is not a cloud-routable provider.
  *
  * Note: `anthropic/…` is also OpenRouter's native id shape, so this codec
  * must only be applied in a Cadet-connection context. OpenRouter is
@@ -114,26 +114,26 @@ export function parseCadetModel(routingString: string): CadetModelRoute | null {
   if (!model) {
     return null;
   }
-  if (!MANAGED_ROUTABLE_PROVIDERS.has(provider)) {
+  if (!CLOUD_ROUTABLE_PROVIDERS.has(provider)) {
     return null;
   }
   return { provider, model };
 }
 
 /**
- * Resolve the managed upstream provider for a model referenced by a
+ * Resolve the cloud upstream provider for a model referenced by a
  * `provider: "cadet"` profile. Such a profile carries no upstream of its own,
  * so the model alone determines it: a `<provider>/<model>` routing string
  * names the upstream directly, and a bare id resolves to its catalog owner.
  * Returns null when the model has no managed-routable upstream (unknown id,
- * or owned by a non-managed provider like openrouter).
+ * or owned by a non-cloud provider like openrouter).
  *
  * A decoded routing string must also name a real catalog model under its
  * prefix: OpenRouter/Vercel native ids share the `<provider>/<model>` shape
  * (e.g. `anthropic/…`), so an unvalidated prefix match could route an
- * arbitrary non-managed id through the managed proxy.
+ * arbitrary non-managed id through the cloud proxy.
  */
-export function getManagedUpstream(model: string): string | null {
+export function getCloudUpstream(model: string): string | null {
   const route = parseCadetModel(model);
   if (route) {
     return isModelInCatalog(route.provider, route.model)
@@ -141,7 +141,7 @@ export function getManagedUpstream(model: string): string | null {
       : null;
   }
   const owner = getCatalogProviderForModel(model);
-  return owner !== undefined && MANAGED_ROUTABLE_PROVIDERS.has(owner)
+  return owner !== undefined && CLOUD_ROUTABLE_PROVIDERS.has(owner)
     ? owner
     : null;
 }

package/src/providers/call-site-routing.ts

@@ -41,7 +41,7 @@ import {
   ConnectionResolutionError,
   dispatchProviderResolvable,
   expectedVendorProvider,
-  isManagedConnectionRoute,
+  isCloudConnectionRoute,
   resolveEntryConnectionName,
   resolveEntryProviderKind,
   resolveRoutingIdentity,
@@ -64,7 +64,7 @@ interface SelectedProviderRoute {
   provider: Provider;
   connectionName?: string;
   profileName?: string;
-  isManagedRoute?: boolean;
+  isCloudRoute?: boolean;
 }
 
 export class CallSiteRoutingProvider implements Provider {
@@ -151,8 +151,8 @@ export class CallSiteRoutingProvider implements Provider {
             ...(selectedRoute.profileName
               ? { profileName: selectedRoute.profileName }
               : {}),
-            ...(selectedRoute.isManagedRoute !== undefined
-              ? { isManagedRoute: selectedRoute.isManagedRoute }
+            ...(selectedRoute.isCloudRoute !== undefined
+              ? { isCloudRoute: selectedRoute.isCloudRoute }
               : {}),
           });
         }
@@ -237,7 +237,7 @@ export class CallSiteRoutingProvider implements Provider {
    *   3. No `provider_connection` → auto-resolve a connection for the
    *      resolved provider and route through it. This runs even when the
    *      provider matches the default's name: the default transport may
-   *      ride the managed (platform-billed) connection while the profile's
+   *      ride the cloud (platform-billed) connection while the profile's
    *      intent is the user's own key, so a bare name match must not stand
    *      in for connection resolution.
    *   4. No connection exists for the provider and it matches the
@@ -299,7 +299,7 @@ export class CallSiteRoutingProvider implements Provider {
 
     // When no connection is set, auto-resolve one for the resolved provider —
     // including when the provider matches the default's name. The default
-    // transport may ride the managed (platform-billed) connection, so reusing
+    // transport may ride the cloud (platform-billed) connection, so reusing
     // it on a bare name match would silently bill managed credits for a
     // profile whose intent is the user's own key. Mirrors
     // `resolveConfiguredProvider`, which never takes a name shortcut; when no
@@ -338,9 +338,9 @@ export class CallSiteRoutingProvider implements Provider {
           connectionName:
             connectionProvider.routeAttribution?.connectionName ??
             connectionName,
-          isManagedRoute:
-            connectionProvider.routeAttribution?.isManagedRoute ??
-            isManagedConnectionRoute(connectionName),
+          isCloudRoute:
+            connectionProvider.routeAttribution?.isCloudRoute ??
+            isCloudConnectionRoute(connectionName),
         };
         // The connection whose credential the call authenticates with is only
         // known here, and diagnostics for a failed request are unactionable
@@ -358,7 +358,7 @@ export class CallSiteRoutingProvider implements Provider {
       }
       // Soft credential failure: the routed connection yielded no usable
       // adapter and dispatch is landing on the default transport, which may
-      // be the platform-billed route. Keep every such degradation
+      // be the cloud-billed route. Keep every such degradation
       // observable. The reason is "no adapter", not a proven credential miss:
       // adapter construction can also fail for dispatch bugs.
       log.warn(

package/src/providers/{platform-proxy → cloud-proxy}/constants.ts

@@ -1,31 +1,31 @@
 /**
- * Provider metadata for managed proxy routing.
+ * Provider metadata for cloud proxy routing.
  *
  * Each managed-capable provider maps to a deterministic proxy base path
- * used when routing LLM requests through the platform's managed proxy.
+ * used when routing LLM requests through the cloud's cloud proxy.
  * Providers marked as non-managed (e.g. ollama) are excluded.
  */
 
-export interface ManagedProviderMeta {
+export interface CloudProviderMeta {
   /** Provider identifier matching the registry name. */
   name: string;
-  /** Whether this provider supports managed proxy routing. */
+  /** Whether this provider supports cloud proxy routing. */
   managed: boolean;
-  /** Proxy path segment appended to the platform base URL (only for managed providers). */
+  /** Proxy path segment appended to the cloud base URL (only for cloud providers). */
   proxyPath?: string;
 }
 
 /**
  * Explicit provider metadata for all known providers.
- * Managed providers get a deterministic proxy path; non-managed providers
+ * Cloud providers get a deterministic proxy path; non-cloud providers
  * are marked accordingly and have no proxy path.
  *
- * This table describes managed proxy routing capability only. It does not
+ * This table describes cloud proxy routing capability only. It does not
  * control which providers auto-bootstrap into the text-model registry when
- * managed credentials are present; that policy lives in the registry/context
+ * cloud credentials are present; that policy lives in the registry/context
  * fallback allowlists.
  */
-export const PLATFORM_PROVIDER_META: Record<string, ManagedProviderMeta> = {
+export const PLATFORM_PROVIDER_META: Record<string, CloudProviderMeta> = {
   openai: {
     name: "openai",
     managed: true,
@@ -54,8 +54,8 @@ export const PLATFORM_PROVIDER_META: Record<string, ManagedProviderMeta> = {
   cadet: {
     name: "cadet",
     managed: true,
-    // Wire contract with the platform's runtime proxy — the route segment
-    // is renamed in coordination with the platform deploy, not here.
+    // Wire contract with the cloud's runtime proxy — the route segment
+    // is renamed in coordination with the cloud deploy, not here.
     proxyPath: "/v1/runtime-proxy/cadet",
   },
   typesafe: {