@mycadet/assistant 0.12.7 → 0.12.9

package/src/__tests__/image-credentials.test.ts

@@ -11,13 +11,13 @@ const secureKeys = useMemorySecureKeyMap();
 // Module mocks — must appear before importing the module under test
 // ---------------------------------------------------------------------------
 
-let mockPlatformBaseUrl = "";
+let mockCloudBaseUrl = "";
 let mockAssistantApiKey = "";
 
-mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => ({
-    enabled: !!mockPlatformBaseUrl && !!mockAssistantApiKey,
-    platformBaseUrl: mockPlatformBaseUrl,
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: async () => ({
+    enabled: !!mockCloudBaseUrl && !!mockAssistantApiKey,
+    cloudBaseUrl: mockCloudBaseUrl,
     assistantApiKey: mockAssistantApiKey,
   }),
 }));
@@ -31,13 +31,13 @@ import {
 describe("resolveImageGenCredentials", () => {
   beforeEach(() => {
     secureKeys.clear(); // no provider keys configured
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
     mockAssistantApiKey = "";
   });
 
   describe("managed mode", () => {
-    test("returns managed-proxy credentials when context is enabled", async () => {
-      mockPlatformBaseUrl = "https://platform.example.com";
+    test("returns cloud-proxy credentials when context is enabled", async () => {
+      mockCloudBaseUrl = "https://platform.example.com";
       mockAssistantApiKey = "sk-assistant-key";
 
       const result = await resolveImageGenCredentials({
@@ -47,14 +47,14 @@ describe("resolveImageGenCredentials", () => {
 
       expect(result.errorHint).toBeUndefined();
       expect(result.credentials).toEqual({
-        type: "managed-proxy",
+        type: "cloud-proxy",
         assistantApiKey: "sk-assistant-key",
         baseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
       });
     });
 
     test("returns errorHint mentioning 'log in to Cadet' when platform URL is missing", async () => {
-      mockPlatformBaseUrl = "";
+      mockCloudBaseUrl = "";
       mockAssistantApiKey = "sk-assistant-key";
 
       const result = await resolveImageGenCredentials({
@@ -68,7 +68,7 @@ describe("resolveImageGenCredentials", () => {
     });
 
     test("returns errorHint when assistant API key is empty (TOCTOU-safe)", async () => {
-      mockPlatformBaseUrl = "https://platform.example.com";
+      mockCloudBaseUrl = "https://platform.example.com";
       mockAssistantApiKey = "";
 
       const result = await resolveImageGenCredentials({
@@ -240,7 +240,7 @@ describe("resolveImageGenRouting", () => {
       credentialKey("gemini", "api_key"),
       "gemini-key-should-not-be-used",
     );
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
 
     const routing = resolveImageGenRouting({
       provider: "cadet",
@@ -252,6 +252,6 @@ describe("resolveImageGenRouting", () => {
     });
 
     expect(result.credentials).toBeUndefined();
-    expect(result.errorHint).toContain("Managed proxy is not available");
+    expect(result.errorHint).toContain("Cloud proxy is not available");
   });
 });

package/src/__tests__/inbound-admitted-introduction-nudge.test.ts

@@ -5,13 +5,19 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-process.env.DISABLE_HTTP_AUTH = "true";
+import {
+  DEFAULT_ENABLED_FLAG_KEYS,
+  setOverridesForTesting,
+} from "../__tests__/feature-flag-test-helpers.js";
 
-// Enable the channel-trust-floors flag so the admission-policy stage runs.
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "channel-trust-floors",
-}));
+// Real flag cache seeded to mirror the former module mock: every flag off
+// except channel-trust-floors, which gates the admission-policy stage.
+const FLAGS = {
+  ...Object.fromEntries(DEFAULT_ENABLED_FLAG_KEYS.map((k) => [k, false])),
+  "channel-trust-floors": true,
+} as Record<string, boolean>;
+
+process.env.DISABLE_HTTP_AUTH = "true";
 
 mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
@@ -179,6 +185,8 @@ function accessRequests() {
 
 describe("introduction nudge on first admit", () => {
   beforeEach(() => {
+    setOverridesForTesting(FLAGS);
+
     resetState();
     installNoopProcessor();
   });

package/src/__tests__/inbound-trust-verdict.test.ts

@@ -6,13 +6,19 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-process.env.DISABLE_HTTP_AUTH = "true";
+import {
+  DEFAULT_ENABLED_FLAG_KEYS,
+  setOverridesForTesting,
+} from "../__tests__/feature-flag-test-helpers.js";
 
-// Enable the channel-trust-floors flag so the admission-policy stage runs.
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "channel-trust-floors",
-}));
+// Real flag cache seeded to mirror the former module mock: every flag off
+// except channel-trust-floors, which gates the admission-policy stage.
+const FLAGS = {
+  ...Object.fromEntries(DEFAULT_ENABLED_FLAG_KEYS.map((k) => [k, false])),
+  "channel-trust-floors": true,
+} as Record<string, boolean>;
+
+process.env.DISABLE_HTTP_AUTH = "true";
 
 mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
@@ -117,6 +123,8 @@ function memberVerdict(
 
 describe("inbound trust verdict → TrustContext", () => {
   beforeEach(() => {
+    setOverridesForTesting(FLAGS);
+
     resetTables();
     setAdapterProcessMessage(undefined);
   });

package/src/__tests__/inference-no-mode-boot-e2e.test.ts

@@ -33,8 +33,8 @@ const preMockModules: ReadonlyArray<[string, Record<string, unknown>]> = [
     { ...(await import("../security/secure-keys.js")) },
   ],
   [
-    "../providers/platform-proxy/context.js",
-    { ...(await import("../providers/platform-proxy/context.js")) },
+    "../providers/cloud-proxy/context.js",
+    { ...(await import("../providers/cloud-proxy/context.js")) },
   ],
   [
     "../providers/inference/connections.js",
@@ -60,15 +60,15 @@ afterAll(() => {
 // Vault mock — keyed by credential name.
 const mockVault = useMemorySecureKeys();
 
-// Managed proxy context — always unavailable in this test (no platform auth).
-mock.module("../providers/platform-proxy/context.js", () => ({
-  buildManagedBaseUrl: async () => null,
-  resolveManagedProxyContext: async () => {
-    throw new Error("managed proxy not available in test");
+// Cloud proxy context — always unavailable in this test (no platform auth).
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  buildCloudBaseUrl: async () => null,
+  resolveCloudProxyContext: async () => {
+    throw new Error("cloud proxy not available in test");
   },
 }));
 
-// DB mock — getConnection returns null (no managed connections seeded yet).
+// DB mock — getConnection returns null (no cloud connections seeded yet).
 const mockGetConnection: Record<string, unknown> = {};
 mock.module("../providers/inference/connections.js", () => ({
   getConnection: (_db: unknown, name: string) =>
@@ -258,20 +258,20 @@ describe("inference-no-mode-boot-e2e: config without services.inference.mode", (
     expect(typeof provider.sendMessage).toBe("function");
   });
 
-  // ── Gate 4: platform-auth connection fails with ConnectionResolutionError ─
+  // ── Gate 4: cloud-auth connection fails with ConnectionResolutionError ─
 
   test("ConnectionResolutionError is exported with expected reason codes", () => {
     const err = new ConnectionResolutionError(
       "anthropic-managed",
       "not_found",
-      'provider_connection "anthropic-managed" not found — managed connections not yet seeded (PR-D)',
+      'provider_connection "anthropic-managed" not found — cloud connections not yet seeded (PR-D)',
     );
     expect(err).toBeInstanceOf(ConnectionResolutionError);
     expect(err.reason).toBe("not_found");
     expect(err.connectionName).toBe("anthropic-managed");
   });
 
-  test("tryResolveProviderForConnectionName throws not_found for an unseed managed connection", async () => {
+  test("tryResolveProviderForConnectionName throws not_found for an unseed cloud connection", async () => {
     // anthropic-managed is not in mockGetConnection (simulates PR-D not yet run).
     const { tryResolveProviderForConnectionName } =
       await import("../providers/connection-resolution.js");

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -25,15 +25,15 @@ mock.module("../runtime/assistant-event.js", () => ({
 }));
 
 // The default profiles used below (`balanced`, `cost-optimized`) route through
-// the Cadet-managed connection, and the handler's availability guard judges
+// the Cadet Cloud connection, and the handler's availability guard judges
 // that route for real. Stand in for a signed-in platform session so the pin
 // path under test is the healthy one; `managedProxyEnabled` is flipped by the
 // guard test.
 let managedProxyEnabled = true;
-mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => ({
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: async () => ({
     enabled: managedProxyEnabled,
-    platformBaseUrl: "https://platform.example",
+    cloudBaseUrl: "https://platform.example",
     assistantApiKey: managedProxyEnabled ? "key" : "",
   }),
 }));
@@ -66,7 +66,7 @@ import { setConfig } from "./helpers/set-config.js";
 
 await initializeDb();
 
-// The Cadet-managed connection row the default profiles resolve to.
+// The Cadet Cloud connection row the default profiles resolve to.
 getDb()
   .insert(providerConnections)
   .values({
@@ -426,9 +426,9 @@ describe("setInferenceProfileSession", () => {
     }
   });
 
-  test("BYOK default provider — pins a managed preset without a Cadet sign-in", async () => {
+  test("BYOK default provider — pins a cloud preset without a Cadet sign-in", async () => {
     const conv = createConversation("sess-handler-byok-preset");
-    // Signed out of Cadet, but llm.default points the managed
+    // Signed out of Cadet, but llm.default points the cloud
     // presets at the user's own anthropic connection — the pin must judge
     // that body, not the Cadet column.
     managedProxyEnabled = false;

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -13,13 +13,13 @@ mock.module("../runtime/assistant-event.js", () => ({
   buildAssistantEvent: (event: unknown) => event,
 }));
 
-// "balanced"/"cost-optimized" route through the Cadet-managed connection, and
+// "balanced"/"cost-optimized" route through the Cadet Cloud connection, and
 // the open handler's availability guard judges that route for real. Stand in
 // for a signed-in platform session so these tests exercise the healthy path.
-mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => ({
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: async () => ({
     enabled: true,
-    platformBaseUrl: "https://platform.example",
+    cloudBaseUrl: "https://platform.example",
     assistantApiKey: "key",
   }),
 }));
@@ -38,7 +38,7 @@ import { resetDbForTesting } from "./db-test-helpers.js";
 
 await initializeDb();
 
-// The Cadet-managed connection row the default profiles resolve to.
+// The Cadet Cloud connection row the default profiles resolve to.
 getDb()
   .insert(providerConnections)
   .values({

package/src/__tests__/inference-profile-validation-jev.test.ts

@@ -3,7 +3,7 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import { validateInferenceProfileKey } from "../config/inference-profile-validation.js";
 import { setConfig } from "./helpers/set-config.js";
 
-describe("validateInferenceProfileKey and the managed Jev profile", () => {
+describe("validateInferenceProfileKey and the cloud Jev profile", () => {
   beforeEach(() => {
     setConfig("llm", { profiles: {} });
   });

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -2,8 +2,8 @@
  * Tests for initFeatureFlagOverrides() — the async IPC call that
  * pre-populates the feature flag cache before CLI program construction.
  *
- * Uses the shared mock-gateway-ipc utility (installed in test-preload.ts)
- * which mocks node:net so no test connects to a real gateway socket.
+ * Uses the requests-mock gateway channel (transport installed in
+ * test-preload.ts) so no test connects to a real gateway socket.
  */
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 
@@ -13,21 +13,23 @@ import {
   isAssistantFeatureFlagEnabled,
   refreshOverridesFromGateway,
 } from "../config/assistant-feature-flags.js";
-import { mockGatewayIpc, resetMockGatewayIpc } from "./mock-gateway-ipc.js";
+import { mockIpc, resetRequestMockChannels } from "./requests-mock.js";
 
 beforeEach(() => {
   clearFeatureFlagOverridesCache();
-  resetMockGatewayIpc();
 });
 
 afterEach(() => {
   clearFeatureFlagOverridesCache();
-  resetMockGatewayIpc();
 });
 
 describe("initFeatureFlagOverrides", () => {
   it("populates cache from gateway IPC response", async () => {
-    mockGatewayIpc({ "foo-enabled": true, "bar-enabled": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {
+      "foo-enabled": true,
+      "bar-enabled": true,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -37,7 +39,8 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("falls back gracefully when gateway socket is unavailable", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     // Disable retries — production retries the IPC fetch on failure to
     // dodge the daemon-vs-gateway startup race, but here we're explicitly
@@ -51,7 +54,11 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("respects false values from gateway IPC", async () => {
-    mockGatewayIpc({ "gated-feature": true, "disabled-feature": false });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {
+      "gated-feature": true,
+      "disabled-feature": false,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -63,7 +70,8 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("does not cache empty gateway response", async () => {
-    mockGatewayIpc({});
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {});
 
     // Disable retries — this test explicitly simulates a sustained empty
     // response (gateway up but reporting zero flags) and should not wait
@@ -80,10 +88,11 @@ describe("initFeatureFlagOverrides", () => {
     // returns empty (gateway not yet ready), but a later attempt sees
     // the populated flag map. The retry loop in init should bridge this
     // gap without losing the flag.
-    mockGatewayIpc({});
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {});
     setTimeout(() => {
-      resetMockGatewayIpc();
-      mockGatewayIpc({ "retry-test-flag": true });
+      resetRequestMockChannels();
+      gateway.on("get_feature_flags", { "retry-test-flag": true });
     }, 50);
 
     await initFeatureFlagOverrides({ retryBackoffsMs: [200] });
@@ -93,14 +102,18 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("does not re-fetch when cache is already populated", async () => {
-    mockGatewayIpc({ "first-call": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "first-call": true });
 
     await initFeatureFlagOverrides();
 
     // Change what IPC would return — if the guard is broken and init
     // re-fetches, "first-call" would flip to false.
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "first-call": false, "second-call": true });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", {
+      "first-call": false,
+      "second-call": true,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -114,11 +127,12 @@ describe("initFeatureFlagOverrides", () => {
 
 describe("refreshOverridesFromGateway", () => {
   it("replaces the cache with the new gateway values", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "moving-flag": false });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", { "moving-flag": false });
 
     expect(await refreshOverridesFromGateway()).toBe(true);
 
@@ -127,11 +141,12 @@ describe("refreshOverridesFromGateway", () => {
   });
 
   it("keeps the last known values when the refresh fails", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc(null, { error: true });
+    resetRequestMockChannels();
+    gateway.failConnect();
 
     expect(await refreshOverridesFromGateway()).toBe(false);
 
@@ -143,11 +158,12 @@ describe("refreshOverridesFromGateway", () => {
   });
 
   it("keeps the cache readable for the whole call", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "moving-flag": false });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", { "moving-flag": false });
 
     const config = {} as any;
     const inFlight = refreshOverridesFromGateway();

package/src/__tests__/input-repairs.test.ts

@@ -8,7 +8,7 @@ import {
   bundledToolInputRepairs,
 } from "../tools/shared/input-repairs.js";
 
-const TOOL = "scaffold_managed_skill";
+const TOOL = "scaffold_cloud_skill";
 const FIND_TOOL = "find_similar_skills";
 
 /** The real manifest entries the repairs describe. */

package/src/__tests__/install-skill-routing.test.ts

@@ -2,6 +2,8 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setAllFlagsOnForTesting } from "../__tests__/feature-flag-test-helpers.js";
+
 // ---------------------------------------------------------------------------
 // Mock state
 // ---------------------------------------------------------------------------
@@ -94,9 +96,6 @@ mock.module("../skills/skillssh-registry.js", () => ({
 mock.module("../skills/install-meta.js", () => ({
   readInstallMeta: () => null,
 }));
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: () => true,
-}));
 mock.module("../config/skill-state.js", () => ({
   resolveSkillStates: () => [],
   skillFlagKey: () => null,
@@ -139,10 +138,10 @@ mock.module("../skills/catalog-install.js", () => ({
 mock.module("../skills/catalog-search.js", () => ({
   filterByQuery: () => [],
 }));
-mock.module("../skills/managed-store.js", () => ({
-  createManagedSkill: () => ({ created: true }),
-  deleteManagedSkill: () => ({ deleted: true }),
-  validateManagedSkillId: () => null,
+mock.module("../skills/cloud-store.js", () => ({
+  createCloudSkill: () => ({ created: true }),
+  deleteCloudSkill: () => ({ deleted: true }),
+  validateCloudSkillId: () => null,
 }));
 mock.module("../plugins/defaults/memory/graph/capability-seed.js", () => ({
   deleteSkillCapabilityNode: () => {},
@@ -181,6 +180,9 @@ import { installSkill } from "../daemon/handlers/skills.js";
 
 describe("installSkill routing", () => {
   beforeEach(() => {
+    // Real flag resolution replaces the former blanket module mock.
+    setAllFlagsOnForTesting();
+
     rmSync(TEST_SKILLS_DIR, { recursive: true, force: true });
     mkdirSync(TEST_SKILLS_DIR, { recursive: true });
     installedSkillIds.clear();
@@ -388,7 +390,7 @@ Body.
     mockCatalogSkills.mockReturnValue([
       {
         id: "platform-skill",
-        displayName: "Platform Skill",
+        displayName: "Cloud Skill",
         description: "A platform-specific skill",
         source: "bundled",
         directoryPath: "/tmp/test-bundled-skills/platform-skill",

package/src/__tests__/integration-status.test.ts

@@ -45,15 +45,15 @@ mock.module("../oauth/oauth-store.js", () => ({
       slack: "slack",
     };
     return managedKeys[provider]
-      ? { managedServiceConfigKey: managedKeys[provider] }
+      ? { cloudServiceConfigKey: managedKeys[provider] }
       : undefined;
   },
 }));
 
-mock.module("../platform/client.js", () => ({
-  CadetPlatformClient: {
+mock.module("../cloud/client.js", () => ({
+  CadetCloudClient: {
     create: async () => ({
-      platformAssistantId: "test-assistant",
+      cloudAssistantId: "test-assistant",
       fetch: async (path: string) => {
         const url = new URL(`http://localhost${path}`);
         const provider = url.searchParams.get("provider");
@@ -237,7 +237,7 @@ describe("integration-status", () => {
       expect(slack?.connected).toBe(true);
     });
 
-    test("formatIntegrationSummary reflects managed connections", async () => {
+    test("formatIntegrationSummary reflects cloud connections", async () => {
       setPlatformConnected("google", "google");
       setPlatformConnected("slack", "slack");
 

package/src/__tests__/internal-telemetry-routes.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
-import type { ConsentState } from "../platform/consent-cache.js";
+import type { ConsentState } from "../cloud/consent-cache.js";
 
 // Toggle for the share_analytics consent the real store consults. The store
 // module is intentionally NOT mocked here — it has its own DB-backed tests, and
@@ -9,12 +9,12 @@ import type { ConsentState } from "../platform/consent-cache.js";
 // auth-fallback test order-independent.
 let shareAnalytics: ConsentState = true;
 
-mock.module("../platform/consent-cache.js", () => ({
+mock.module("../cloud/consent-cache.js", () => ({
   getRawShareAnalytics: () => shareAnalytics,
 }));
 
 // The watchdog relay must go through the direct (unbuffered) emit; capture the
-// forwarded arguments instead of POSTing to the platform.
+// forwarded arguments instead of POSTing to the cloud.
 const emitCalls: {
   checkName: string;
   detail: Record<string, unknown> | null;

package/src/__tests__/invite-routes-http.test.ts

@@ -111,7 +111,7 @@ async function handleTriggerInviteCall(params: {
 await initializeDb();
 
 // Pin the `inviteInstructionGenerator` call site to a connectionless profile.
-// The call site's catalog default (`cost-optimized`) carries the managed
+// The call site's catalog default (`cost-optimized`) carries the cloud
 // `cadet` provider_connection, which does not exist in this test workspace's
 // DB — resolution would throw instead of degrading. A profile with no
 // provider_connection resolves to "no provider available", so instruction

package/src/__tests__/llm-catalog-parity.test.ts

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import { DEFAULT_PROVIDER_CHOICES } from "../config/schemas/llm.js";
+import { PLATFORM_PROVIDER_META } from "../providers/cloud-proxy/constants.js";
 import {
   catalogModelSupportsText,
   getCatalogProviderForModel,
@@ -10,7 +11,6 @@ import {
   PROVIDER_CATALOG,
   supportsForcedToolChoiceWithThinking,
 } from "../providers/model-catalog.js";
-import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
 import { resolvePricing, resolvePricingForUsage } from "../util/pricing.js";
 
 /**
@@ -84,7 +84,7 @@ interface ClientCatalogEntry {
   envVar?: string;
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
-  supportsPlatformAuth?: boolean;
+  supportsCloudAuth?: boolean;
   featureFlag?: string;
   defaultModel: string;
   models: ClientCatalogModel[];
@@ -137,9 +137,7 @@ describe("LLM catalog parity: daemon vs client", () => {
       expect(clientEntry.setupHint).toBe(daemonEntry.setupHint);
       expect(clientEntry.envVar).toBe(daemonEntry.envVar);
       expect(clientEntry.apiKeyPlaceholder).toBe(daemonEntry.apiKeyPlaceholder);
-      expect(clientEntry.supportsPlatformAuth).toBe(
-        daemonEntry.supportsPlatformAuth,
-      );
+      expect(clientEntry.supportsCloudAuth).toBe(daemonEntry.supportsCloudAuth);
       expect(clientEntry.featureFlag).toBe(daemonEntry.featureFlag);
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
@@ -148,7 +146,7 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
-  test("supportsPlatformAuth mirrors PLATFORM_PROVIDER_META", () => {
+  test("supportsCloudAuth mirrors PLATFORM_PROVIDER_META", () => {
     // The catalog field is derived from PLATFORM_PROVIDER_META at build
     // time. This test guards against future hand-edits to model-catalog.ts
     // that would let the two drift. Adding a provider to PLATFORM_PROVIDER_META
@@ -157,7 +155,7 @@ describe("LLM catalog parity: daemon vs client", () => {
     for (const entry of PROVIDER_CATALOG) {
       const expectedSupportsManagedAuth =
         PLATFORM_PROVIDER_META[entry.id]?.managed === true;
-      expect(entry.supportsPlatformAuth).toBe(expectedSupportsManagedAuth);
+      expect(entry.supportsCloudAuth).toBe(expectedSupportsManagedAuth);
     }
   });
 

package/src/__tests__/llm-request-log-source-clickhouse.test.ts

@@ -302,7 +302,7 @@ describe("ClickHouseLlmRequestLogSource", () => {
     );
   });
 
-  test("missing cadet:platform_assistant_id surfaces a clear error", async () => {
+  test("a missing Cadet Cloud assistant id surfaces a clear error", async () => {
     const src = new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
       resolveUrl: async () => "https://ch.example.test",
       resolvePassword: async () => "x",
@@ -310,7 +310,7 @@ describe("ClickHouseLlmRequestLogSource", () => {
       fetchImpl: fakeFetchReturning(""),
     });
     await expect(src.getRequestLogById("log-1")).rejects.toThrow(
-      /cadet:platform_assistant_id credential is required/,
+      /Cadet Cloud assistant id is required/,
     );
   });
 });