@mycadet/assistant 0.12.7 → 0.12.8

package/src/providers/jev/ask.test.ts

@@ -42,7 +42,7 @@ describe("resolveTypesafeProvider", () => {
     );
   });
 
-  test("a managed Jev profile resolves although it is configured as cadet", async () => {
+  test("a cloud Jev profile resolves although it is configured as cadet", async () => {
     configured = {
       provider: stub("typesafe"),
       configuredProviderName: "cadet",

package/src/providers/jev/ask.ts

@@ -39,9 +39,9 @@ export interface TypesafeNoulResult {
 /**
  * The call site's provider when it resolves to TypeSafe, else null. Judged
  * on the dispatched adapter's name rather than the configured provider: a
- * managed profile is configured as `cadet` and only substitutes the
+ * cloud profile is configured as `cadet` and only substitutes the
  * TypeSafe upstream at dispatch, so the configured name alone would report
- * the managed Jev profile as unavailable.
+ * the cloud Jev profile as unavailable.
  */
 export async function resolveTypesafeProvider(
   callSite: LLMCallSite,

package/src/providers/model-catalog.ts

@@ -1,4 +1,4 @@
-import { PLATFORM_PROVIDER_META } from "./platform-proxy/constants.js";
+import { PLATFORM_PROVIDER_META } from "./cloud-proxy/constants.js";
 
 export type LongContextMode =
   | "native-model"
@@ -163,14 +163,14 @@ export interface ProviderCatalogEntry {
     linkLabel: string;
   };
   /**
-   * Whether this provider supports the `platform` auth type (Cadet-managed
-   * keys routed through the platform proxy). Derived from
+   * Whether this provider supports the `platform` auth type (Cadet Cloud
+   * keys routed through the cloud proxy). Derived from
    * `PLATFORM_PROVIDER_META` at catalog build time so the two stay in lock
    * step. Clients use this field to hide the "Platform (managed by Cadet)"
    * option from the auth-type dropdown for providers like Fireworks or
    * OpenRouter where managed keys are not available.
    */
-  supportsPlatformAuth?: boolean;
+  supportsCloudAuth?: boolean;
   /** When set, this provider is only visible when the named feature flag is enabled. */
   featureFlag?: string;
 }
@@ -2894,11 +2894,10 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
   {
     id: "cadet",
     displayName: "Cadet",
-    subtitle:
-      "Models served on Cadet GPU nodes through the managed connection.",
+    subtitle: "Models served on Cadet GPU nodes through the cloud connection.",
     setupMode: "api-key",
     setupHint:
-      "Uses the assistant API key through the Cadet managed connection. These models cannot use a bring-your-own key.",
+      "Uses the assistant API key through the Cadet Cloud connection. These models cannot use a bring-your-own key.",
     featureFlag: "cadet-hosted-inference",
     models: [
       {
@@ -2922,11 +2921,11 @@ export const PROVIDER_CATALOG: ProviderCatalogEntry[] =
   RAW_PROVIDER_CATALOG.map((entry) => ({
     ...entry,
     models: entry.models.map(catalogModel),
-    // Derive supportsPlatformAuth from PLATFORM_PROVIDER_META so the catalog
+    // Derive supportsCloudAuth from PLATFORM_PROVIDER_META so the catalog
     // and the proxy routing table can never drift. Adding a provider to
     // PLATFORM_PROVIDER_META with `managed: true` automatically opts it into
     // the Platform auth-type dropdown in the clients.
-    supportsPlatformAuth: PLATFORM_PROVIDER_META[entry.id]?.managed === true,
+    supportsCloudAuth: PLATFORM_PROVIDER_META[entry.id]?.managed === true,
   }));
 
 /**

package/src/providers/openai/__tests__/api-error-normalization.test.ts

@@ -107,9 +107,9 @@ describe("normalizeOpenAIAPIError", () => {
     // SDK collapsed the body; raw body still has the real detail.
     const n = normalizeOpenAIAPIError(
       apiError(400, { sdkBody: {} }),
-      JSON.stringify({ detail: "managed proxy rejected model" }),
+      JSON.stringify({ detail: "cloud proxy rejected model" }),
     );
-    expect(n.message).toBe("managed proxy rejected model");
+    expect(n.message).toBe("cloud proxy rejected model");
   });
 
   test("falls back to the SDK-parsed error when the captured JSON was truncated", () => {
@@ -474,7 +474,7 @@ describe("deriveReason", () => {
   });
 
   test("daily-limit body code → daily_limit_reached (before insufficient_credits)", () => {
-    // Both are 402s from the managed proxy; the specific daily-limit code must
+    // Both are 402s from the cloud proxy; the specific daily-limit code must
     // win over the generic status-402 → insufficient_credits mapping.
     expect(
       deriveReason(

package/src/providers/openai/api-error-normalization.ts

@@ -14,7 +14,7 @@ import {
 /**
  * Normalized view of an OpenAI-compatible `APIError`. The SDK reads
  * `error.message` and renders bodies it can't parse as "(no body)", so
- * Django `{"detail": "..."}` payloads from the managed runtime proxy and
+ * Django `{"detail": "..."}` payloads from the cloud runtime proxy and
  * OpenRouter's nested `error.metadata.raw` get dropped. We capture the raw
  * non-2xx body in a `fetch` wrapper and reconstruct the useful fields here.
  */
@@ -110,7 +110,7 @@ export function deriveReason(
     return "request_shape_unsupported";
   }
 
-  // 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/provider-availability.ts

@@ -2,7 +2,7 @@
  * Provider availability checks.
  *
  * Determines which LLM providers are usable by checking secure storage,
- * environment variable fallbacks, and managed proxy availability.
+ * environment variable fallbacks, and cloud proxy availability.
  */
 
 import { getConfig } from "../config/loader.js";
@@ -10,14 +10,14 @@ import {
   getProviderKeyAsync,
   getSecureKeyResultAsync,
 } from "../security/secure-keys.js";
+import { managedFallbackEnabledFor } from "./cloud-proxy/context.js";
 import { PROVIDER_CATALOG } from "./model-catalog.js";
-import { managedFallbackEnabledFor } from "./platform-proxy/context.js";
 import { getVisibleProviderCatalog } from "./provider-catalog-visibility.js";
 import { API_KEY_PROVIDERS } from "./provider-secret-catalog.js";
 
 /**
  * Check whether a single provider is usable — via a user-provided key
- * (secure storage or env var) or via the managed proxy fallback.
+ * (secure storage or env var) or via the cloud proxy fallback.
  * Ollama is always considered available because it does not require an API key.
  */
 export async function isProviderAvailable(provider: string): Promise<boolean> {
@@ -32,7 +32,7 @@ export async function isProviderAvailable(provider: string): Promise<boolean> {
 
 /**
  * Build the list of providers that are usable — via a user-provided key
- * (secure storage or env var) or via the managed proxy fallback.
+ * (secure storage or env var) or via the cloud proxy fallback.
  * Feature-flagged LLM providers that are currently disabled are excluded.
  * Ollama is always included because it does not require an API key.
  */

package/src/providers/provider-env-vars.ts

@@ -24,7 +24,7 @@ import { SEARCH_PROVIDER_CATALOG } from "./search-provider-catalog.js";
 /**
  * Search-provider env var names, derived from `SEARCH_PROVIDER_CATALOG`.
  * Adding a BYOK provider to the catalog automatically extends this map —
- * managed providers (no `envVar`) are filtered out.
+ * cloud providers (no `envVar`) are filtered out.
  */
 const SEARCH_PROVIDER_ENV_VAR_NAMES: Record<string, string> = Object.freeze(
   Object.fromEntries(

package/src/providers/provider-secret-catalog.ts

@@ -42,7 +42,7 @@ import { listCredentialProviderNames as listSttCredentialProviderNames } from ".
  * "keyless"` — the keyless mode is enforced elsewhere; this list is purely
  * about the set of bare-name credential-store keys accepted by
  * `assistant keys ...`. `cadet` is excluded: those models authenticate
- * with the assistant API key on the managed connection, not a user key.
+ * with the assistant API key on the cloud connection, not a user key.
  *
  * Search providers (`brave`, `perplexity`, `tavily`) have no catalog module
  * yet and remain statically declared below.

package/src/providers/registry.ts

@@ -9,6 +9,10 @@ import {
   isAnthropicDelegatingGateway,
   isAnthropicModel,
 } from "./anthropic-gateway-shared.js";
+import {
+  buildCloudBaseUrl,
+  resolveCloudProxyContext,
+} from "./cloud-proxy/context.js";
 import {
   buildProviderAdapter,
   createAdapterFromConnection,
@@ -24,10 +28,6 @@ import {
 import { resolveAuth } from "./inference/resolve-auth.js";
 import { isModelInCatalog, PROVIDER_CATALOG } from "./model-catalog.js";
 import { getProviderDefaultModel } from "./model-intents.js";
-import {
-  buildManagedBaseUrl,
-  resolveManagedProxyContext,
-} from "./platform-proxy/context.js";
 import { RetryProvider } from "./retry.js";
 import type { Provider } from "./types.js";
 import { UsageTrackingProvider } from "./usage-tracking.js";
@@ -35,7 +35,7 @@ import { UsageTrackingProvider } from "./usage-tracking.js";
 const log = getLogger("provider-registry");
 
 const providers = new Map<string, Provider>();
-const routingSources = new Map<string, "user-key" | "managed-proxy">();
+const routingSources = new Map<string, "user-key" | "cloud-proxy">();
 const NATIVE_WEB_SEARCH_PROVIDER_IDS = new Set(["anthropic", "openai"]);
 
 /**
@@ -71,7 +71,7 @@ function getConnectionProviderCacheKey(
   effectiveProvider: string,
 ): string {
   // `effectiveProvider` differs from `connection.provider` only for the
-  // provider-agnostic Cadet-managed connection, where one connection name
+  // provider-agnostic Cadet Cloud connection, where one connection name
   // serves multiple upstreams — include it so those entries don't collide.
   return `${connection.name}\u0000${effectiveProvider}\u0000${model}`;
 }
@@ -94,7 +94,7 @@ export function listProviders(): string[] {
 
 export function getProviderRoutingSource(
   name: string,
-): "user-key" | "managed-proxy" | undefined {
+): "user-key" | "cloud-proxy" | undefined {
   return routingSources.get(name);
 }
 
@@ -164,7 +164,7 @@ export function shouldUseNativeWebSearch(
 }
 
 /**
- * Resolve provider credentials. User key takes precedence; managed proxy is
+ * Resolve provider credentials. User key takes precedence; cloud proxy is
  * used as a fallback when platform prerequisites are available.
  *
  * The routing decision is now derived from credential availability rather than
@@ -173,19 +173,19 @@ export function shouldUseNativeWebSearch(
 async function resolveProviderCredentials(providerName: string): Promise<{
   apiKey: string;
   baseURL?: string;
-  source: "user-key" | "managed-proxy";
+  source: "user-key" | "cloud-proxy";
 } | null> {
   const userKey = await getProviderKeyAsync(providerName);
   if (userKey) {
     return { apiKey: userKey, source: "user-key" };
   }
-  const managedBaseUrl = await buildManagedBaseUrl(providerName);
-  if (managedBaseUrl) {
-    const ctx = await resolveManagedProxyContext();
+  const cloudBaseUrl = await buildCloudBaseUrl(providerName);
+  if (cloudBaseUrl) {
+    const ctx = await resolveCloudProxyContext();
     return {
       apiKey: ctx.assistantApiKey,
-      baseURL: managedBaseUrl,
-      source: "managed-proxy",
+      baseURL: cloudBaseUrl,
+      source: "cloud-proxy",
     };
   }
   return null;
@@ -215,14 +215,14 @@ export async function initializeProviders(
 
     const isKeyless = entry.setupMode === "keyless";
 
-    // Credential resolution: user key first, managed proxy second. Keyless
+    // Credential resolution: user key first, cloud proxy second. Keyless
     // providers (e.g. ollama) skip both — they only need to be configured as
     // the mainAgent provider, or have a key present (rare keyed-mode), to
     // boot. Boot order matches catalog order; routingSources tracks which
     // credential surface served each provider.
     let apiKey = "";
     let baseURL: string | undefined;
-    let source: "user-key" | "managed-proxy" = "user-key";
+    let source: "user-key" | "cloud-proxy" = "user-key";
     if (isKeyless) {
       const key = await getProviderKeyAsync(entry.id);
       const isConfiguredMainAgent = mainAgentProvider === entry.id;
@@ -267,12 +267,12 @@ export async function initializeProviders(
     registerProvider(
       entry.id,
       new RetryProvider(adapter, {
-        forwardUsageAttributionHeaders: source === "managed-proxy",
+        forwardUsageAttributionHeaders: source === "cloud-proxy",
         // A keyless provider booted without a key has no credential to blame,
         // so don't let its rejections render as "update your personal key".
         credentialSource:
-          source === "managed-proxy"
-            ? "cadet-managed"
+          source === "cloud-proxy"
+            ? "cadet-cloud"
             : isKeyless && !apiKey
               ? "no-auth"
               : "byok",
@@ -308,7 +308,7 @@ export async function resolveProviderFromConnection(
   config: ProvidersConfig,
   opts: { model?: string; providerOverride?: string } = {},
 ): Promise<Provider | null> {
-  // The provider-agnostic Cadet-managed connection carries only the `cadet`
+  // The provider-agnostic Cadet Cloud connection carries only the `cadet`
   // sentinel on its row, so callers pass the resolved profile's provider here.
   // For every other connection this is `undefined` and the effective provider
   // is the connection's own — no behavior change.

package/src/providers/retry.ts

@@ -442,20 +442,20 @@ function retryErrorType(error: unknown): string {
 }
 
 /**
- * The managed proxy's preflight guard rejects a model with no billing rate
+ * The cloud proxy's preflight guard rejects a model with no billing rate
  * card using a 400 whose body carries this phrase (django
  * `app/runtime_proxy/views.py`). It marks a model rename/retirement incident
  * (a route problem, not a request problem), so it is fallback-eligible even
  * though 400s are otherwise final.
  */
-// Matches the platform preflight's copy for an unsupported managed model.
+// Matches the cloud preflight's copy for an unsupported managed model.
 const MANAGED_PROXY_UNSUPPORTED_MODEL_PATTERN =
   /is not yet supported on the Cadet hosted service/;
 
 /**
  * Whether the failure indicts one model rather than the upstream serving it: a
  * provider-classified `model_not_found`, a 404 with no definitive
- * classification, or the managed proxy's preflight 400 for a renamed/retired
+ * classification, or the cloud proxy's preflight 400 for a renamed/retired
  * model. As in `isRetryableError`, a provider-stamped semantic reason takes
  * precedence over the status fallback: a 404 whose classifier assigned a
  * definitive non-model reason (Anthropic, for example, stamps `bad_request` on
@@ -509,16 +509,16 @@ function isFallbackEligibleError(
   if (!(error instanceof ProviderError)) {
     return false;
   }
-  // (b) Invalid managed credential (the invalid-key incident). Applies only
-  // to `cadet-managed` routes, where the platform owns the credential and a
-  // broken key is a platform incident. A BYOK or OAuth-subscription route
+  // (b) Invalid cloud credential (the invalid-key incident). Applies only
+  // to `cadet-cloud` routes, where the cloud owns the credential and a
+  // broken key is a cloud incident. A BYOK or OAuth-subscription route
   // with a broken personal credential must surface the auth error so the
   // user can fix it, not silently reroute to a differently billed backup.
   // Only reached after `sendMessage`'s credential-refresh path has already
-  // been attempted for managed routes: same status/reason gate as
-  // `shouldRefreshManagedCredential`.
+  // been attempted for cloud routes: same status/reason gate as
+  // `shouldRefreshCloudCredential`.
   if (
-    opts.credentialSource === "cadet-managed" &&
+    opts.credentialSource === "cadet-cloud" &&
     (error.statusCode === 401 || error.statusCode === 403) &&
     (error.reason === undefined ||
       error.reason === "unknown" ||
@@ -690,7 +690,7 @@ function normalizeSendMessageOptions(
   }
 
   if (providerName === "fireworks") {
-    // Covers BYOK Fireworks and the Cadet-managed Fireworks upstream, which
+    // Covers BYOK Fireworks and the Cadet Cloud Fireworks upstream, which
     // both dispatch through `FireworksProvider`. Keyless calls send no header.
     const sessionKey = [config.selectionSeed, config.conversationId].find(
       (value): value is string =>
@@ -1242,10 +1242,10 @@ export class RetryProvider implements Provider {
        * `fallbackProfile`, mirroring how `refreshCredentialProvider` keeps
        * this wrapper ignorant of credential storage.
        * `forwardUsageAttributionHeaders` must describe the BACKUP route, not
-       * the primary: managed-proxy routes pass true, BYOK and other
+       * the primary: cloud-proxy routes pass true, BYOK and other
        * third-party routes pass false. The fallback send normalizes with the
        * returned policy so `X-Cadet-*` billing metadata never leaks to a
-       * third party and is never omitted from the managed proxy. One hop max:
+       * third party and is never omitted from the cloud proxy. One hop max:
        * the returned adapter must be RAW, so the backup can never escalate
        * again whatever happens to it. Whether the backup send gets a retry
        * budget depends on which entry point escalated; see
@@ -1278,9 +1278,9 @@ export class RetryProvider implements Provider {
     }
   }
 
-  private shouldRefreshManagedCredential(error: unknown): boolean {
+  private shouldRefreshCloudCredential(error: unknown): boolean {
     return (
-      this.options.credentialSource === "cadet-managed" &&
+      this.options.credentialSource === "cadet-cloud" &&
       this.options.refreshCredentialProvider !== undefined &&
       error instanceof ProviderError &&
       (error.statusCode === 401 || error.statusCode === 403) &&
@@ -1291,13 +1291,13 @@ export class RetryProvider implements Provider {
   }
 
   /**
-   * Reload the managed credential after an auth rejection and swap the inner
+   * Reload the cloud credential after an auth rejection and swap the inner
    * provider for one built around it, so a key rotated out of band is picked
    * up without a restart. Returns true when a refreshed adapter took over and
    * the request is worth attempting again. Never throws: a failed reload
    * leaves the original error to surface.
    */
-  private async refreshManagedCredential(): Promise<boolean> {
+  private async refreshCloudCredential(): Promise<boolean> {
     try {
       const refreshed = await this.options.refreshCredentialProvider?.();
       if (refreshed) {
@@ -1318,7 +1318,7 @@ export class RetryProvider implements Provider {
           connectionName: this.options.connectionName,
           refreshError,
         },
-        "Failed to reload managed assistant credentials",
+        "Failed to reload cloud assistant credentials",
       );
     }
     return false;
@@ -1424,7 +1424,7 @@ export class RetryProvider implements Provider {
         );
         // One probe, one attempt: no retry loop. Two one-shot repairs are the
         // exception, both because the probe would otherwise misread its own
-        // failure as the route still being down. A managed credential that
+        // failure as the route still being down. A cloud credential that
         // expired during the outage is refreshed, or the route could never come
         // back. Malformed tool-argument JSON gets the same corrective note the
         // retry loop appends, because that failure is conditioned on the
@@ -1463,10 +1463,10 @@ export class RetryProvider implements Provider {
             }
             if (
               !credentialRefreshAttempted &&
-              this.shouldRefreshManagedCredential(error)
+              this.shouldRefreshCloudCredential(error)
             ) {
               credentialRefreshAttempted = true;
-              if (await this.refreshManagedCredential()) {
+              if (await this.refreshCloudCredential()) {
                 continue;
               }
             }
@@ -1594,10 +1594,10 @@ export class RetryProvider implements Provider {
       } catch (error) {
         if (
           !credentialRefreshAttempted &&
-          this.shouldRefreshManagedCredential(error)
+          this.shouldRefreshCloudCredential(error)
         ) {
           credentialRefreshAttempted = true;
-          if (await this.refreshManagedCredential()) {
+          if (await this.refreshCloudCredential()) {
             continue;
           }
         }
@@ -1719,7 +1719,7 @@ export class RetryProvider implements Provider {
    * routes: degraded mode loses native search rather than the whole turn.
    *
    * Gated on `config.nativeWebSearchSentinel`, never on the name alone: with a
-   * search backend like Brave or the platform search proxy configured, a tool
+   * search backend like Brave or the cloud search proxy configured, a tool
    * of the same name is app-executed and works on every route, so filtering it
    * would take away a capability the backup can still serve.
    *
@@ -1778,7 +1778,7 @@ export class RetryProvider implements Provider {
    * `normalizeSendMessageOptions` has already consumed the `callSite` and
    * stamped the backup route's `usageAttributionHeaders`; running it again over
    * that now callSite-less config would delete the headers and have no way to
-   * rebuild them, leaving degraded traffic unattributed on the platform's
+   * rebuild them, leaving degraded traffic unattributed on the cloud's
    * billing events. This is the same reason the route callback hands back a raw
    * adapter instead of a wrapped one.
    */
@@ -1947,9 +1947,9 @@ export class RetryProvider implements Provider {
     // restamps the usage-attribution headers from the backup resolution, so
     // platform usage events attribute degraded traffic to the backup
     // profile. Whether those headers are forwarded at all follows the
-    // FALLBACK route's policy, not the primary's: a managed primary falling
+    // FALLBACK route's policy, not the primary's: a cloud primary falling
     // back to a third-party adapter must not leak billing metadata, and a
-    // non-managed primary falling back to the managed proxy must include it.
+    // non-managed primary falling back to the cloud proxy must include it.
     const fallbackConfig: Record<string, unknown> = { ...options?.config };
     delete fallbackConfig.max_tokens;
     delete fallbackConfig.effort;

package/src/providers/routing-identity.ts

@@ -11,9 +11,9 @@
 
 import { ConfigError } from "../util/errors.js";
 import {
-  CADET_MANAGED_CONNECTION_NAME,
-  CADET_MANAGED_PROVIDER,
-  getManagedUpstream,
+  CADET_CLOUD_CONNECTION_NAME,
+  CADET_CLOUD_PROVIDER,
+  getCloudUpstream,
 } from "./cadet-model-routing.js";
 import { CHATGPT_SUBSCRIPTION_CONNECTION_NAME } from "./inference/auth.js";
 import { isCodexSubscriptionModel } from "./openai/codex-models.js";
@@ -53,11 +53,11 @@ export class ConnectionResolutionError extends ConfigError {
 
 /**
  * Translate a routing-identity provider into its dispatch target. "cadet"
- * derives the managed upstream from the model and routes through the
+ * derives the cloud upstream from the model and routes through the
  * canonical cadet connection; "chatgpt" routes through the
  * chatgpt-subscription connection with an openai upstream. Returns null for
  * real providers. Throws `unroutable_managed_model` when a cadet model has
- * no managed upstream, and `model_incompatible` when a chatgpt model is
+ * no cloud upstream, and `model_incompatible` when a chatgpt model is
  * outside the Codex subscription set — loud and explainable, never a soft
  * fall-through to the (possibly platform-billed) default transport.
  */
@@ -65,18 +65,18 @@ export function resolveRoutingIdentity(
   provider: string | undefined,
   model: string | undefined,
 ): { connectionName: string; expectedProvider: string } | null {
-  if (provider === CADET_MANAGED_PROVIDER) {
-    const upstream = model ? getManagedUpstream(model) : null;
+  if (provider === CADET_CLOUD_PROVIDER) {
+    const upstream = model ? getCloudUpstream(model) : null;
     if (!upstream) {
       throw new ConnectionResolutionError(
-        CADET_MANAGED_CONNECTION_NAME,
+        CADET_CLOUD_CONNECTION_NAME,
         "unroutable_managed_model",
-        `provider "cadet" cannot route model "${model ?? "<unset>"}" — no managed upstream serves it. Pick a model from the Cadet catalog or set a concrete provider.`,
+        `provider "cadet" cannot route model "${model ?? "<unset>"}" — no cloud upstream serves it. Pick a model from the Cadet catalog or set a concrete provider.`,
         { model },
       );
     }
     return {
-      connectionName: CADET_MANAGED_CONNECTION_NAME,
+      connectionName: CADET_CLOUD_CONNECTION_NAME,
       expectedProvider: upstream,
     };
   }

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

@@ -51,7 +51,7 @@ export interface SearchProviderCatalogEntry {
    * `inference-provider-native`, the daemon uses the inference API's native
    * hosted web-search tool only when the selected inference provider/model
    * supports it; otherwise the app-executed `web_search` tool runs, falling
-   * back to the platform search proxy only when no user search key is
+   * back to the cloud search proxy only when no user search key is
    * configured.
    *
    * `byok` providers require a user-supplied API key.
@@ -87,7 +87,7 @@ export interface SearchProviderCatalogEntry {
 }
 
 export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
-  // cadet leads: it is the managed option, selected like any other provider.
+  // cadet leads: it is the cloud option, selected like any other provider.
   // Legacy configs carrying the pre-rebrand id `cadet` normalize on parse.
   {
     id: "cadet",

package/src/providers/speech-to-text/__tests__/{cadet-managed-realtime.test.ts → cadet-cloud-realtime.test.ts}

@@ -8,8 +8,8 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { SttError, type SttStreamServerEvent } from "../../../stt/types.js";
-import { CadetManagedFluxRealtimeTranscriber } from "../cadet-managed-flux-realtime.js";
-import { CadetManagedRealtimeTranscriber } from "../cadet-managed-realtime.js";
+import { CadetManagedFluxRealtimeTranscriber } from "../cadet-cloud-flux-realtime.js";
+import { CadetManagedRealtimeTranscriber } from "../cadet-cloud-realtime.js";
 import type { SpeechRelayConnection } from "../cadet-speech-relay-connection.js";
 
 type WsListener = (...args: unknown[]) => void;
@@ -100,7 +100,7 @@ const CONNECTION: SpeechRelayConnection = {
 
 const tick = () => new Promise<void>((r) => setTimeout(r, 0));
 
-describe("Cadet managed realtime transcribers", () => {
+describe("Cadet Cloud realtime transcribers", () => {
   let sockets: MockWebSocket[];
   let originalWebSocket: unknown;
   let originalFetch: unknown;