@mycadet/assistant 0.12.7 → 0.12.8

package/src/persistence/embeddings/embedding-backend.ts

@@ -4,8 +4,8 @@ import { getOllamaBaseUrlEnv } from "../../config/env.js";
 import { resolveCallSiteConfig } from "../../config/llm-resolver.js";
 import { isMemoryEnabled } from "../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { PLATFORM_PROVIDER_META } from "../../providers/platform-proxy/constants.js";
-import { resolveManagedProxyContext } from "../../providers/platform-proxy/context.js";
+import { PLATFORM_PROVIDER_META } from "../../providers/cloud-proxy/constants.js";
+import { resolveCloudProxyContext } from "../../providers/cloud-proxy/context.js";
 import { getProviderKeyAsync } from "../../security/secure-keys.js";
 import { getLogger } from "../../util/logger.js";
 import {
@@ -522,19 +522,19 @@ function getCustomEmbeddingBackend(
 }
 
 /**
- * Build (or reuse) the managed-proxy Gemini backend, or return undefined
- * when the managed proxy prerequisites (platform URL + assistant API key)
+ * Build (or reuse) the cloud-proxy Gemini backend, or return undefined
+ * when the cloud proxy prerequisites (platform URL + assistant API key)
  * are not satisfied.
  */
 async function tryGetManagedGeminiBackend(
   config: AssistantConfig,
 ): Promise<EmbeddingBackend | undefined> {
-  const proxyCtx = await resolveManagedProxyContext();
+  const proxyCtx = await resolveCloudProxyContext();
   const meta = PLATFORM_PROVIDER_META["gemini"];
   if (!proxyCtx.enabled || !meta?.managed || !meta.proxyPath) {
     return undefined;
   }
-  const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
+  const cloudBaseUrl = `${proxyCtx.cloudBaseUrl}${meta.proxyPath}`;
   return getCachedOrCreate(
     "gemini",
     config.memory.embeddings.geminiModel,
@@ -545,7 +545,7 @@ async function tryGetManagedGeminiBackend(
         {
           taskType: config.memory.embeddings.geminiTaskType,
           dimensions: config.memory.embeddings.geminiDimensions ?? 3072,
-          managedBaseUrl,
+          cloudBaseUrl,
         },
       ),
     [...geminiCacheExtras(config), "managed"],
@@ -607,8 +607,8 @@ export async function selectEmbeddingBackend(
     };
   }
 
-  // When managed proxy prerequisites are satisfied, insert managed-proxy Gemini
-  // at the front of the auto chain so platform assistants use Cadet-managed
+  // When cloud proxy prerequisites are satisfied, insert cloud-proxy Gemini
+  // at the front of the auto chain so platform assistants use Cadet Cloud
   // Gemini embeddings.
   if (requested === "auto" || requested === "gemini") {
     const managed = await tryGetManagedGeminiBackend(config);
@@ -817,7 +817,7 @@ export async function isEmbeddingDimensionAvailable(
   }
 
   // Probe the exact backend chain `embedWithBackend` would try (primary +
-  // auto-mode fallbacks + the managed→direct Gemini fallback) via the shared
+  // auto-mode fallbacks + the cloud→direct Gemini fallback) via the shared
   // assembler, so this preflight can never be more pessimistic than the real
   // embed path. Dense recall stays available if ANY backend in the chain
   // produces the committed dimension. `resolveBackendDimension` memoizes per
@@ -898,7 +898,7 @@ export class EmbeddingBackendUnavailableError extends Error {
  * Assemble the ordered backend chain {@link embedWithBackend} will try for a
  * given primary selection: the primary, then (in `auto` mode, non-Gemini
  * primary) the configured fallbacks, then a direct-key Gemini fallback when the
- * primary is managed-proxy Gemini. This is the single source of truth for the
+ * primary is cloud-proxy Gemini. This is the single source of truth for the
  * fallback chain, shared with the dimension-availability preflight
  * ({@link isEmbeddingDimensionAvailable}) so the preflight cannot diverge from
  * what the real embed path attempts.
@@ -916,7 +916,7 @@ async function assembleEmbeddingBackends(
       ? await selectFallbackBackends(config, primary.provider)
       : [];
 
-  // A managed-proxy Gemini primary can fail at the proxy (e.g. a stale or
+  // A cloud-proxy Gemini primary can fail at the proxy (e.g. a stale or
   // revoked cloud credential) while a valid direct Gemini key sits in the
   // credential store. The provider chain above never includes Gemini when
   // Gemini IS the primary, so without this the direct key would never be tried.
@@ -1133,7 +1133,7 @@ async function selectFallbackBackends(
         if (geminiKey) {
           backends.push(getDirectGeminiBackend(config, geminiKey));
         } else {
-          // Try managed proxy Gemini as fallback when no direct key exists.
+          // Try cloud proxy Gemini as fallback when no direct key exists.
           const managed = await tryGetManagedGeminiBackend(config);
           if (managed) {
             backends.push(managed);

package/src/persistence/embeddings/embedding-gemini.test.ts

@@ -295,14 +295,13 @@ describe("GeminiEmbeddingBackend", () => {
     });
   });
 
-  describe("managed proxy transport", () => {
-    test("routes through managed proxy base URL when managedBaseUrl is set", async () => {
+  describe("cloud proxy transport", () => {
+    test("routes through cloud proxy base URL when cloudBaseUrl is set", async () => {
       const backend = new GeminiEmbeddingBackend(
         "ast-managed-key",
         "gemini-embedding-2",
         {
-          managedBaseUrl:
-            "https://platform.example.com/v1/runtime-proxy/gemini",
+          cloudBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
         },
       );
       await backend.embed(["hello"]);
@@ -335,8 +334,7 @@ describe("GeminiEmbeddingBackend", () => {
         "ast-managed-key",
         "gemini-embedding-2",
         {
-          managedBaseUrl:
-            "https://platform.example.com/v1/runtime-proxy/gemini",
+          cloudBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
           taskType: "RETRIEVAL_DOCUMENT",
           dimensions: 3072,
         },
@@ -358,7 +356,7 @@ describe("GeminiEmbeddingBackend", () => {
       }
     });
 
-    test("uses direct Google API URL when managedBaseUrl is not set", async () => {
+    test("uses direct Google API URL when cloudBaseUrl is not set", async () => {
       const backend = new GeminiEmbeddingBackend("direct-key", "test-model");
       await backend.embed(["hello"]);
 
@@ -370,13 +368,12 @@ describe("GeminiEmbeddingBackend", () => {
       expect(headers["Authorization"]).toBeUndefined();
     });
 
-    test("includes outputDimensionality with managed proxy", async () => {
+    test("includes outputDimensionality with cloud proxy", async () => {
       const backend = new GeminiEmbeddingBackend(
         "ast-managed-key",
         "gemini-embedding-2",
         {
-          managedBaseUrl:
-            "https://platform.example.com/v1/runtime-proxy/gemini",
+          cloudBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
           dimensions: 3072,
         },
       );
@@ -475,11 +472,11 @@ describe("GeminiEmbeddingBackend: batched text inputs", () => {
     expect(vectors.map((v) => v[0])).toEqual(texts(250).map(textIndex));
   });
 
-  test("managed text inputs use single calls from the first request and preserve vector order", async () => {
+  test("cloud text inputs use single calls from the first request and preserve vector order", async () => {
     const fetchMock = routedFetch();
     globalThis.fetch = fetchMock as unknown as typeof fetch;
     const backend = new GeminiEmbeddingBackend("test-key", "test-model", {
-      managedBaseUrl: "https://proxy.example.com/v1/runtime-proxy/gemini",
+      cloudBaseUrl: "https://proxy.example.com/v1/runtime-proxy/gemini",
       interCallDelayMs: 0,
     });
 

package/src/persistence/embeddings/embedding-gemini.ts

@@ -44,8 +44,8 @@ const BATCH_ROUTE_UNAVAILABLE_STATUSES = new Set([404, 405, 501]);
 export interface GeminiEmbeddingOptions {
   taskType?: EmbeddingTaskType;
   dimensions?: number;
-  /** When set, routes requests through the managed proxy at this base URL. */
-  managedBaseUrl?: string;
+  /** When set, routes requests through the cloud proxy at this base URL. */
+  cloudBaseUrl?: string;
   /**
    * Milliseconds to sleep between sequential embed calls to yield to the
    * event loop. Defaults to 5000 in production; set to 0 in tests.
@@ -59,7 +59,7 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
   private readonly apiKey: string;
   private readonly taskType?: EmbeddingTaskType;
   private readonly dimensions?: number;
-  private readonly managedBaseUrl?: string;
+  private readonly cloudBaseUrl?: string;
   private readonly interCallDelayMs: number;
   /**
    * Set once the batch route has answered that it does not exist, so later
@@ -72,13 +72,13 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     this.model = model;
     this.taskType = options?.taskType;
     this.dimensions = options?.dimensions;
-    this.managedBaseUrl = options?.managedBaseUrl;
+    this.cloudBaseUrl = options?.cloudBaseUrl;
     this.interCallDelayMs = options?.interCallDelayMs ?? 100;
   }
 
-  /** True when requests route through the managed platform proxy. */
+  /** True when requests route through the cloud cloud proxy. */
   get managed(): boolean {
-    return Boolean(this.managedBaseUrl);
+    return Boolean(this.cloudBaseUrl);
   }
 
   /**
@@ -272,7 +272,7 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     // as a protobuf oneof populated from the URL path (internally `_model`),
     // so adding it to the body triggers a 400: "oneof field '_model' is
     // already set. Cannot set 'model'". This holds for both the direct API
-    // and the managed proxy, which forwards the body unchanged; the platform
+    // and the cloud proxy, which forwards the body unchanged; the cloud
     // billing layer parses the model from the URL path instead.
     if (this.taskType) {
       body.taskType = this.taskType;
@@ -305,11 +305,11 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     return values;
   }
 
-  /** The model's `:embedContent` or `:batchEmbedContents` URL, direct or via the managed proxy. */
+  /** The model's `:embedContent` or `:batchEmbedContents` URL, direct or via the cloud proxy. */
   private endpointUrl(method: "embedContent" | "batchEmbedContents"): string {
     const model = encodeURIComponent(this.model);
-    return this.managedBaseUrl
-      ? `${this.managedBaseUrl}/v1beta/models/${model}:${method}`
+    return this.cloudBaseUrl
+      ? `${this.cloudBaseUrl}/v1beta/models/${model}:${method}`
       : `https://generativelanguage.googleapis.com/v1beta/models/${model}:${method}?key=${encodeURIComponent(this.apiKey)}`;
   }
 
@@ -317,7 +317,7 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     const headers: Record<string, string> = {
       "Content-Type": "application/json",
     };
-    if (this.managedBaseUrl) {
+    if (this.cloudBaseUrl) {
       headers["Authorization"] = `Bearer ${this.apiKey}`;
     }
     return headers;

package/src/persistence/embeddings/embedding-runtime-manager.ts

@@ -469,9 +469,9 @@ export class EmbeddingRuntimeManager {
         throw new DOMException("Aborted", "AbortError");
       }
 
-      log.info("npm packages downloaded, stripping non-platform binaries");
+      log.info("npm packages downloaded, stripping non-cloud binaries");
 
-      // Step 2: Strip non-platform native binaries
+      // Step 2: Strip non-cloud native binaries
       const onnxBinDir = join(
         nodeModules,
         "onnxruntime-node",

package/src/persistence/jobs-store.ts

@@ -381,7 +381,7 @@ function mergeSkillCardEntries(
 }
 
 /**
- * One rewrite of a managed skill by a background pass, as the receipt job's
+ * One rewrite of a cloud skill by a background pass, as the receipt job's
  * payload carries it. `entryId` is the producing tool call's, so a replayed
  * call merges as a no-op; the conversation ids are what the receipt links
  * to and what a conversation delete purges by.

package/src/persistence/lifecycle-events-store.ts

@@ -15,7 +15,7 @@ export interface LifecycleEvent {
  * Optional typed attributes a lifecycle event carries alongside its name.
  *
  * Every one is nullable and optional on the wire, so a caller with nothing to
- * say omits it and a platform that predates the field ignores it. They exist
+ * say omits it and a cloud that predates the field ignores it. They exist
  * so grouping dimensions (risk, access preset, surface) are columns rather
  * than substrings of `event_name`, which the server caps at 64 chars.
  */

package/src/persistence/llm-request-log-sink-clickhouse.ts

@@ -29,8 +29,8 @@
  * Writes are best-effort: a ClickHouse outage logs and is swallowed so it
  * can never abort a turn.
  */
+import { resolveCloudAssistantIdOrNull } from "../config/cloud-identity.js";
 import { getConfigReadOnly } from "../config/loader.js";
-import { resolvePlatformAssistantIdOrNull } from "../config/platform-identity.js";
 import type { LlmRequestLogsClickHouseConfig } from "../config/schemas/llm-request-logs.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -99,7 +99,7 @@ export class ClickHouseLlmRequestLogSink implements LlmRequestLogWriter {
       deps.resolvePassword ??
       (() => readCredentialOrNull("clickhouse", "password"));
     this.resolveAssistantId =
-      deps.resolveAssistantId ?? resolvePlatformAssistantIdOrNull;
+      deps.resolveAssistantId ?? resolveCloudAssistantIdOrNull;
     this.fetchImpl = deps.fetchImpl ?? globalThis.fetch.bind(globalThis);
   }
 
@@ -258,7 +258,7 @@ export class ClickHouseLlmRequestLogSink implements LlmRequestLogWriter {
     const val = await this.resolveAssistantId();
     if (!val) {
       throw new Error(
-        "cadet:platform_assistant_id credential is required when readSource=clickhouse",
+        "Cadet Cloud assistant id is required when readSource=clickhouse",
       );
     }
     this.cachedAssistantId = val;

package/src/persistence/llm-request-log-source-clickhouse.ts

@@ -15,7 +15,7 @@
  * than the local source. Acceptable for the "internal use while we
  * finetune prompts" use case; revisit when mirror updates are added.
  */
-import { resolvePlatformAssistantIdOrNull } from "../config/platform-identity.js";
+import { resolveCloudAssistantIdOrNull } from "../config/cloud-identity.js";
 import type { LlmRequestLogsClickHouseConfig } from "../config/schemas/llm-request-logs.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -139,7 +139,7 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
       deps.resolvePassword ??
       (() => readCredentialOrNull("clickhouse", "password"));
     this.resolveAssistantId =
-      deps.resolveAssistantId ?? resolvePlatformAssistantIdOrNull;
+      deps.resolveAssistantId ?? resolveCloudAssistantIdOrNull;
     this.resolveTurnMessageIds =
       deps.resolveTurnMessageIds ?? getAssistantMessageIdsInTurn;
     this.resolveMessage = deps.resolveMessage ?? getMessageById;
@@ -500,7 +500,7 @@ export class ClickHouseLlmRequestLogSource implements LlmRequestLogSource {
     const val = await this.resolveAssistantId();
     if (!val) {
       throw new Error(
-        "cadet:platform_assistant_id credential is required when readSource=clickhouse",
+        "Cadet Cloud assistant id is required when readSource=clickhouse",
       );
     }
     this.cachedAssistantId = val;

package/src/persistence/migrations/224-oauth-providers-managed-service-is-paid.ts

@@ -4,7 +4,7 @@ import { getSqliteFrom } from "../db-connection.js";
 /**
  * Add the `managed_service_is_paid` column to `oauth_providers`.
  *
- * Flags whether a provider's managed OAuth variant requires a paid plan
+ * Flags whether a provider's cloud OAuth variant requires a paid plan
  * upstream (e.g. Twitter). Defaults to 0 (false) for all existing rows.
  *
  * Mirrors the pattern from migration 178. The raw.exec() call below is

package/src/persistence/migrations/296-rewrite-balanced-economy-profile-pins.test.ts

@@ -96,7 +96,7 @@ describe("migration 296: rewrite balanced-economy profile pins", () => {
     expect(pin(sqlite, "conversations", "c1")).toBe("balanced-economy");
   });
 
-  test("rewrites pins when balanced-economy is the managed profile in config", () => {
+  test("rewrites pins when balanced-economy is the cloud profile in config", () => {
     writeWorkspaceConfig({
       llm: { profiles: { "balanced-economy": { source: "managed" } } },
     });

package/src/persistence/migrations/296-rewrite-balanced-economy-profile-pins.ts

@@ -13,14 +13,14 @@ const PIN_TABLES = ["conversations", "cron_jobs"] as const;
 /**
  * Rewrite persisted `balanced-economy` inference-profile pins to `balanced`.
  *
- * The managed `balanced-economy` profile folds into `balanced` (both resolve to
+ * The cloud `balanced-economy` profile folds into `balanced` (both resolve to
  * MiniMax M3 on Fireworks). The workspace-config migration removes the profile
  * definition, but a profile key can also be pinned outside config.json — on a
  * conversation (`conversations.inference_profile`) or a schedule
  * (`cron_jobs.inference_profile`). Left unrewritten those pins dangle, and
  * `resolveCallSiteConfig` treats an unresolvable override as a silent
  * fall-through to the active/default profile — dropping the user's intended
- * MiniMax route. `balanced-economy` is a reserved managed-profile key, so every
+ * MiniMax route. `balanced-economy` is a reserved cloud-profile key, so every
  * persisted pin refers to the now-folded profile.
  *
  * Ownership guard: the companion workspace migration keeps a `balanced-economy`

package/src/persistence/migrations/306-rewrite-frontier-profile-pins.test.ts

@@ -96,7 +96,7 @@ describe("migration 306: rewrite frontier profile pins", () => {
     expect(pin(sqlite, "conversations", "c1")).toBe("frontier");
   });
 
-  test("rewrites pins when frontier is the managed profile in config", () => {
+  test("rewrites pins when frontier is the cloud profile in config", () => {
     writeWorkspaceConfig({
       llm: { profiles: { frontier: { source: "managed" } } },
     });

package/src/persistence/migrations/306-rewrite-frontier-profile-pins.ts

@@ -13,7 +13,7 @@ const PIN_TABLES = ["conversations", "cron_jobs"] as const;
 /**
  * Rewrite persisted `frontier` inference-profile pins to `quality-optimized`.
  *
- * The managed `frontier` profile folds into `quality-optimized` (both resolve to
+ * The cloud `frontier` profile folds into `quality-optimized` (both resolve to
  * Anthropic Opus on `anthropic-managed`). The workspace-config migration removes
  * the profile definition, but a profile key can also be pinned outside
  * config.json — on a conversation (`conversations.inference_profile`) or a

package/src/persistence/migrations/351-schedule-skill-script-handoff.ts

@@ -8,7 +8,7 @@ import { getSqliteFrom } from "../db-connection.js";
  *   script's stdout to an agent turn instead of only recording it on the run
  *   row. Defaults to 0 so every pre-existing script schedule keeps its
  *   no-LLM behaviour.
- * - `skill_id` — the managed skill whose `scripts/` the command invokes. NULL
+ * - `skill_id` — the cloud skill whose `scripts/` the command invokes. NULL
  *   (all pre-existing rows) means the schedule is not bound to a skill.
  * - `skill_version_hash` — the skill's content hash at creation time,
  *   re-checked before each firing so a rewritten script cannot keep running

package/src/persistence/migrations/361-normalize-managed-connection-rows.test.ts

@@ -58,8 +58,8 @@ function readRow(
   return row;
 }
 
-describe("migration 361: normalize managed connection rows", () => {
-  test("rewrites a platform-auth row with a concrete provider to provider cadet", () => {
+describe("migration 361: normalize cloud connection rows", () => {
+  test("rewrites a cloud-auth row with a concrete provider to provider cadet", () => {
     const { sqlite, db } = createTestDb();
     insertRow(sqlite, "managed-openai", "openai", '{"type":"platform"}');
 
@@ -79,7 +79,7 @@ describe("migration 361: normalize managed connection rows", () => {
     expect(readRow(sqlite, "cadet").provider).toBe("cadet");
   });
 
-  test("rewrites a cadet-provider row with non-platform auth to platform auth", () => {
+  test("rewrites a cadet-provider row with non-cloud auth to platform auth", () => {
     const { sqlite, db } = createTestDb();
     insertRow(
       sqlite,

package/src/persistence/migrations/361-normalize-managed-connection-rows.ts

@@ -5,23 +5,23 @@ const PLATFORM_AUTH_JSON = JSON.stringify({ type: "platform" });
 
 /**
  * Reconcile `provider_connections` rows so platform auth and provider
- * "cadet" always pair. The two columns record the same fact (the managed,
+ * "cadet" always pair. The two columns record the same fact (the cloud,
  * platform-billed route); auth derivation sets them together and the
  * connection routes reject writes that split them, but rows written before
  * that guard can disagree. The provider column is the authoritative managed
- * signal (`isCadetManagedConnection`), so mismatched rows must converge:
+ * signal (`isCadetCloudConnection`), so mismatched rows must converge:
  *
  * - Platform auth with any other provider: the provider becomes "cadet".
- *   These rows dispatch through the managed proxy (transport selection keys
- *   on the managed identity), so normalizing the provider preserves billing
+ *   These rows dispatch through the cloud proxy (transport selection keys
+ *   on the cloud identity), so normalizing the provider preserves billing
  *   and transport behavior, while normalizing the auth instead would
- *   silently turn a platform-billed row into a keyless BYOK row. This also
+ *   silently turn a cloud-billed row into a keyless BYOK row. This also
  *   heals a stuck pre-consolidation canonical row (name "cadet", concrete
  *   provider, platform auth) that boot seeding skips because its provider
  *   differs from the sentinel.
  * - Provider "cadet" with any other auth: the auth becomes
- *   `{"type":"platform"}`. A cadet row means the managed route by
- *   definition, and non-platform auth on it never yields a usable adapter.
+ *   `{"type":"platform"}`. A cadet row means the cloud route by
+ *   definition, and non-cloud auth on it never yields a usable adapter.
  *
  * Rows whose auth column is not valid JSON are left alone (the DB loaders
  * already treat them as invalid). Idempotent: a reconciled row matches

package/src/persistence/migrations/__tests__/319-remove-legacy-managed-connections.test.ts

@@ -45,8 +45,8 @@ const LEGACY = [
   "together-managed",
 ];
 
-describe("migration 319 — remove legacy *-managed connections", () => {
-  test("deletes all five legacy managed connections", () => {
+describe("migration 319 — remove legacy *-cloud connections", () => {
+  test("deletes all five legacy cloud connections", () => {
     const db = createTestDb();
     migrateCreateProviderConnections(db); // seeds anthropic/openai/gemini-managed
     for (const name of LEGACY) {

package/src/persistence/schema/oauth.ts

@@ -29,7 +29,7 @@ export const oauthProviders = sqliteTable("oauth_providers", {
   pingBody: text("ping_body"),
   revokeUrl: text("revoke_url"),
   revokeBodyTemplate: text("revoke_body_template"),
-  managedServiceConfigKey: text("managed_service_config_key"),
+  cloudServiceConfigKey: text("managed_service_config_key"),
   managedServiceIsPaid: integer("managed_service_is_paid", { mode: "boolean" })
     .notNull()
     .default(false),

package/src/plugin-api/index.ts

@@ -197,10 +197,10 @@ export type {
 export { CredentialStoreError, storeCredential } from "./store-credential.js";
 // Resolve the public URL a third party should deliver to for one of the
 // plugin's own ingress routes. Which URL is correct depends on how the
-// assistant is reachable (a managed platform callback route, or a configured
+// assistant is reachable (a cloud platform callback route, or a configured
 // public ingress), and `ingress.publicBaseUrl` alone does not decide it. Uses
 // the same resolution as `webhooks register`, and registers the callback route
-// on the managed branches. The plugin defaults to the one in context.
+// on the cloud branches. The plugin defaults to the one in context.
 export { resolveWebhookUrl, type WebhookUrlOptions } from "./webhook-url.js";
 // Resolve the redirect URI an authorization server should send a user back
 // to after consent. One shared route serves every OAuth flow in the
@@ -209,12 +209,12 @@ export { resolveWebhookUrl, type WebhookUrlOptions } from "./webhook-url.js";
 // when it publishes something that has to name the redirect URI ahead of the
 // flow, such as a Client ID Metadata Document, whose `redirect_uris` an
 // authorization server matches exactly. Throws when no public ingress is
-// configured and the assistant is not connected to the platform, which is the
+// configured and the assistant is not connected to the cloud, which is the
 // case where no URL would work.
 export { resolveOauthCallbackUrl } from "../inbound/oauth-callback-url.js";
 // Resolve a provider for a call site (optionally overriding the profile) so a
 // plugin can run inference through the workspace's configured profiles and
-// credentials — managed-proxy or BYOK — without supplying its own API key.
+// credentials — cloud-proxy or BYOK — without supplying its own API key.
 // Pair with `getModelProfiles` to pick a profile. Returns `null` when no
 // provider is configured. By default `overrideProfile` layers below any
 // per-call-site config the workspace has pinned (e.g. a cheap `inference`

package/src/plugin-api/model-profiles.test.ts

@@ -158,7 +158,7 @@ describe("getModelProfiles", () => {
     );
   });
 
-  test("default profile descriptions use the managed column without a default provider", () => {
+  test("default profile descriptions use the cloud column without a default provider", () => {
     const result = listProfiles();
     expect(result.find((p) => p.key === "quality-optimized")?.description).toBe(
       "High-quality results with the most capable model",

package/src/plugin-api/model-profiles.ts

@@ -7,7 +7,7 @@ import type { ModelProfileInfo } from "./types.js";
 /**
  * List the workspace inference profiles a plugin can route to, in the order a
  * user-facing model picker presents them (`llm.profileOrder` first, then the
- * rest alphabetically). Managed backup routes and the managed Jev profile
+ * rest alphabetically). Managed backup routes and the cloud Jev profile
  * are omitted with the rest of the conversation view: a plugin routes
  * conversation turns, and a decision model cannot answer them.
  * Metadata-only entries without a provider, model, or mix are not routing

package/src/plugin-api/transcription-session.ts

@@ -7,7 +7,7 @@
  * receives partial and final transcript events back through the
  * `start(onEvent)` callback, closing with `stop`. The consumer drives this
  * three-method contract without knowing the concrete provider (Deepgram,
- * Whisper, Gemini, xAI, or Cadet-managed speech), its wire protocol, or its
+ * Whisper, Gemini, xAI, or Cadet Cloud speech), its wire protocol, or its
  * credentials.
  */
 

package/src/plugin-api/vision-support.test.ts

@@ -243,7 +243,7 @@ describe("doesSupportVision with a BYO default provider", () => {
     expect(doesSupportVision(profile("cost-optimized"))).toBe(false);
   });
 
-  test("without a default provider, a default profile judges the managed column", () => {
+  test("without a default provider, a default profile judges the cloud column", () => {
     // Null-reduction: no default provider resolves cost-optimized through the
     // cadet column (deepseek-v4p1-flash, vision-capable).
     setMockConfig({});

package/src/plugin-api/webhook-url.ts

@@ -3,10 +3,10 @@
  *
  * A plugin that receives third-party webhooks has to tell the vendor where to
  * deliver. Which URL is correct depends on how the assistant is reachable:
- * a platform pod and a platform-connected assistant are served through a
+ * a cloud pod and a cloud-connected assistant are served through a
  * managed callback route, while a self-hosted deployment is served through its
  * configured public ingress. `ingress.publicBaseUrl` alone does not decide it,
- * because on a platform-connected assistant that value holds the Tunnel
+ * because on a cloud-connected assistant that value holds the Tunnel
  * address, which is not where plugin routes are served.
  *
  * `resolveCallbackUrl` owns that decision for every caller in the codebase
@@ -16,9 +16,9 @@
 
 import { createHash } from "node:crypto";
 
-import { getIsPlatform } from "../config/env-registry.js";
+import { getIsCloud } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
-import { resolveCallbackUrl } from "../inbound/platform-callback-registration.js";
+import { resolveCallbackUrl } from "../inbound/cloud-callback-registration.js";
 import { getPublicBaseUrl } from "../inbound/public-ingress-urls.js";
 import { getCurrentPluginName } from "../plugins/plugin-execution-context.js";
 
@@ -72,16 +72,16 @@ export interface WebhookUrlOptions {
    * explicitly from a plugin route handler, where no context is established.
    */
   plugin?: string;
-  /** Human-readable label for the platform's admin display. */
+  /** Human-readable label for the cloud's admin display. */
   sourceIdentifier?: string;
 }
 
 /**
  * Registration type for one route.
  *
- * The platform keys a callback route by type, so two routes of one plugin need
+ * The cloud keys a callback route by type, so two routes of one plugin need
  * two types or the second registration replaces the first. The slug keeps the
- * type legible in the platform's admin display and the digest keeps it unique:
+ * type legible in the cloud's admin display and the digest keeps it unique:
  * `events-v1` and `events_v1` share a slug and differ here.
  */
 function registrationType(plugin: string, route: string): string {
@@ -91,7 +91,7 @@ function registrationType(plugin: string, route: string): string {
 }
 
 /**
- * Keep a trailing slash on a managed callback URL.
+ * Keep a trailing slash on a cloud callback URL.
  *
  * Django in front of managed callbacks canonicalizes onto `/`. A vendor given
  * the slashless spelling is 301'd, and clients that follow a 301 on POST
@@ -99,7 +99,7 @@ function registrationType(plugin: string, route: string): string {
  *
  * Query-bearing URLs are left alone: this resolver passes no query
  * parameters, and appending there would cut into the query rather than the
- * path. The callback path registered with the platform stays slashless. The
+ * path. The callback path registered with the cloud stays slashless. The
  * platform strips slashes on store, and Django's path converter typically
  * does not include the final `/` in the lookup key.
  */
@@ -113,12 +113,12 @@ function withTrailingSlash(url: string): string {
 /**
  * Resolve the public URL a third party should deliver to for `path`.
  *
- * On the managed branches this registers a callback route with the platform,
+ * On the cloud branches this registers a callback route with the cloud,
  * which is idempotent and matches what `assistant webhooks register` does.
  *
  * @throws when the plugin cannot be determined, when `path` is not one the
  *   gateway would serve, or when no ingress is configured and the assistant is
- *   not connected to the platform. That last case has no URL that would work,
+ *   not connected to the cloud. That last case has no URL that would work,
  *   and a plausible one would produce a vendor registration that silently
  *   receives nothing.
  */
@@ -160,7 +160,7 @@ export async function resolveWebhookUrl(
   // so that is the spelling to hand out. On a pod the supplier URL is only
   // returned once its path is claimed, so this condition holds exactly for
   // tunnel URLs; every other branch keeps the trailing slash.
-  if (getIsPlatform() && resolved === ingressUrl) {
+  if (getIsCloud() && resolved === ingressUrl) {
     return resolved;
   }
   return withTrailingSlash(resolved);

package/src/plugins/__tests__/source-fingerprint.test.ts

@@ -21,7 +21,7 @@ import { afterAll, describe, expect, test } from "bun:test";
 
 import { snapshotPluginSource } from "../source-fingerprint.js";
 
-// Resolved: snapshots report realpaths, and the platform temp directory can
+// Resolved: snapshots report realpaths, and the cloud temp directory can
 // itself sit behind a link, so an unresolved fixture root would make every
 // fixture path an alias of itself.
 const root = realpathSync(mkdtempSync(join(tmpdir(), "source-fingerprint-")));