@mycadet/assistant 0.12.7 → 0.12.9

package/src/__tests__/{platform-proxy-context.test.ts → cloud-proxy-context.test.ts}

@@ -8,139 +8,139 @@ const secureKeys = useMemorySecureKeyMap();
 const ASSISTANT_API_KEY = credentialKey("cadet", "assistant_api_key");
 
 // Mutable state for env stubs
-let mockPlatformBaseUrl = "";
+let mockCloudBaseUrl = "";
 
 mock.module("../config/env.js", () => ({
-  getPlatformBaseUrl: () => mockPlatformBaseUrl,
+  getCloudBaseUrl: () => mockCloudBaseUrl,
 }));
 
 import {
-  buildManagedBaseUrl,
-  hasManagedProxyPrereqs,
+  buildCloudBaseUrl,
+  hasCloudProxyPrereqs,
   managedFallbackEnabledFor,
-  resolveManagedProxyContext,
-} from "../providers/platform-proxy/context.js";
+  resolveCloudProxyContext,
+} from "../providers/cloud-proxy/context.js";
 
-describe("resolveManagedProxyContext", () => {
+describe("resolveCloudProxyContext", () => {
   beforeEach(() => {
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
     secureKeys.delete(ASSISTANT_API_KEY);
   });
 
   test("returns disabled when platform URL is empty", async () => {
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
     secureKeys.set(ASSISTANT_API_KEY, "sk-test-key");
 
-    const ctx = await resolveManagedProxyContext();
+    const ctx = await resolveCloudProxyContext();
     expect(ctx.enabled).toBe(false);
-    expect(ctx.platformBaseUrl).toBe("");
+    expect(ctx.cloudBaseUrl).toBe("");
   });
 
   test("returns disabled when assistant API key is missing", async () => {
-    mockPlatformBaseUrl = "https://platform.example.com";
+    mockCloudBaseUrl = "https://platform.example.com";
     secureKeys.delete(ASSISTANT_API_KEY);
 
-    const ctx = await resolveManagedProxyContext();
+    const ctx = await resolveCloudProxyContext();
     expect(ctx.enabled).toBe(false);
     expect(ctx.assistantApiKey).toBe("");
   });
 
   test("returns disabled when both are missing", async () => {
-    const ctx = await resolveManagedProxyContext();
+    const ctx = await resolveCloudProxyContext();
     expect(ctx.enabled).toBe(false);
   });
 
   test("returns enabled when both platform URL and API key are present", async () => {
-    mockPlatformBaseUrl = "https://platform.example.com/";
+    mockCloudBaseUrl = "https://platform.example.com/";
     secureKeys.set(ASSISTANT_API_KEY, "sk-test-key");
 
-    const ctx = await resolveManagedProxyContext();
+    const ctx = await resolveCloudProxyContext();
     expect(ctx.enabled).toBe(true);
-    expect(ctx.platformBaseUrl).toBe("https://platform.example.com");
+    expect(ctx.cloudBaseUrl).toBe("https://platform.example.com");
     expect(ctx.assistantApiKey).toBe("sk-test-key");
   });
 
   test("strips trailing slashes from platform URL", async () => {
-    mockPlatformBaseUrl = "https://platform.example.com///";
+    mockCloudBaseUrl = "https://platform.example.com///";
     secureKeys.set(ASSISTANT_API_KEY, "sk-test-key");
 
-    const ctx = await resolveManagedProxyContext();
-    expect(ctx.platformBaseUrl).toBe("https://platform.example.com");
+    const ctx = await resolveCloudProxyContext();
+    expect(ctx.cloudBaseUrl).toBe("https://platform.example.com");
   });
 });
 
-describe("hasManagedProxyPrereqs", () => {
+describe("hasCloudProxyPrereqs", () => {
   beforeEach(() => {
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
     secureKeys.delete(ASSISTANT_API_KEY);
   });
 
   test("returns false when prerequisites are missing", async () => {
-    expect(await hasManagedProxyPrereqs()).toBe(false);
+    expect(await hasCloudProxyPrereqs()).toBe(false);
   });
 
   test("returns true when prerequisites are satisfied", async () => {
-    mockPlatformBaseUrl = "https://platform.example.com";
+    mockCloudBaseUrl = "https://platform.example.com";
     secureKeys.set(ASSISTANT_API_KEY, "sk-test-key");
-    expect(await hasManagedProxyPrereqs()).toBe(true);
+    expect(await hasCloudProxyPrereqs()).toBe(true);
   });
 });
 
-describe("buildManagedBaseUrl", () => {
+describe("buildCloudBaseUrl", () => {
   beforeEach(() => {
-    mockPlatformBaseUrl = "https://platform.example.com";
+    mockCloudBaseUrl = "https://platform.example.com";
     secureKeys.set(ASSISTANT_API_KEY, "sk-test-key");
   });
 
-  test("builds correct URL for managed providers", async () => {
-    expect(await buildManagedBaseUrl("anthropic")).toBe(
+  test("builds correct URL for cloud providers", async () => {
+    expect(await buildCloudBaseUrl("anthropic")).toBe(
       "https://platform.example.com/v1/runtime-proxy/anthropic",
     );
-    expect(await buildManagedBaseUrl("gemini")).toBe(
+    expect(await buildCloudBaseUrl("gemini")).toBe(
       "https://platform.example.com/v1/runtime-proxy/gemini",
     );
-    expect(await buildManagedBaseUrl("openai")).toBe(
+    expect(await buildCloudBaseUrl("openai")).toBe(
       "https://platform.example.com/v1/runtime-proxy/openai",
     );
   });
 
   test("returns managed URL for fireworks", async () => {
-    expect(await buildManagedBaseUrl("fireworks")).toBe(
+    expect(await buildCloudBaseUrl("fireworks")).toBe(
       "https://platform.example.com/v1/runtime-proxy/fireworks",
     );
   });
 
-  test("returns undefined for non-managed providers", async () => {
-    expect(await buildManagedBaseUrl("openrouter")).toBeUndefined();
-    expect(await buildManagedBaseUrl("ollama")).toBeUndefined();
+  test("returns undefined for non-cloud providers", async () => {
+    expect(await buildCloudBaseUrl("openrouter")).toBeUndefined();
+    expect(await buildCloudBaseUrl("ollama")).toBeUndefined();
   });
 
   test("returns undefined for unknown provider", async () => {
-    expect(await buildManagedBaseUrl("unknown-provider")).toBeUndefined();
+    expect(await buildCloudBaseUrl("unknown-provider")).toBeUndefined();
   });
 
   test("returns undefined when prerequisites are missing", async () => {
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
     secureKeys.delete(ASSISTANT_API_KEY);
-    expect(await buildManagedBaseUrl("anthropic")).toBeUndefined();
-    expect(await buildManagedBaseUrl("gemini")).toBeUndefined();
-    expect(await buildManagedBaseUrl("openai")).toBeUndefined();
+    expect(await buildCloudBaseUrl("anthropic")).toBeUndefined();
+    expect(await buildCloudBaseUrl("gemini")).toBeUndefined();
+    expect(await buildCloudBaseUrl("openai")).toBeUndefined();
   });
 });
 
 describe("managedFallbackEnabledFor", () => {
   beforeEach(() => {
-    mockPlatformBaseUrl = "https://platform.example.com";
+    mockCloudBaseUrl = "https://platform.example.com";
     secureKeys.set(ASSISTANT_API_KEY, "sk-test-key");
   });
 
-  test("returns true only for managed fallback providers with prerequisites", async () => {
+  test("returns true only for cloud fallback providers with prerequisites", async () => {
     expect(await managedFallbackEnabledFor("anthropic")).toBe(true);
     expect(await managedFallbackEnabledFor("gemini")).toBe(true);
     expect(await managedFallbackEnabledFor("openai")).toBe(true);
   });
 
-  test("returns false for non-managed provider", async () => {
+  test("returns false for non-cloud provider", async () => {
     expect(await managedFallbackEnabledFor("ollama")).toBe(false);
   });
 
@@ -149,7 +149,7 @@ describe("managedFallbackEnabledFor", () => {
   });
 
   test("returns false when prerequisites are missing", async () => {
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
     secureKeys.delete(ASSISTANT_API_KEY);
     expect(await managedFallbackEnabledFor("anthropic")).toBe(false);
     expect(await managedFallbackEnabledFor("gemini")).toBe(false);

package/src/__tests__/{managed-speech-defaults.test.ts → cloud-speech-defaults.test.ts}

@@ -3,16 +3,16 @@ import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import * as actualTtsCapability from "../calls/telephony-tts-capability.js";
-import * as actualManagedSpeech from "../platform/managed-speech.js";
+import * as actualCloudSpeech from "../cloud/cloud-speech.js";
 import * as actualResolve from "../providers/speech-to-text/resolve.js";
 
-let mockManagedSpeechAvailable = false;
+let mockCloudSpeechAvailable = false;
 let mockSttKeyResolves = false;
 let mockTtsSecretResolves = false;
 
-mock.module("../platform/managed-speech.js", () => ({
-  ...actualManagedSpeech,
-  managedSpeechAvailable: async () => mockManagedSpeechAvailable,
+mock.module("../cloud/cloud-speech.js", () => ({
+  ...actualCloudSpeech,
+  managedSpeechAvailable: async () => mockCloudSpeechAvailable,
 }));
 
 mock.module("../providers/speech-to-text/resolve.js", () => ({
@@ -25,11 +25,11 @@ mock.module("../calls/telephony-tts-capability.js", () => ({
   ttsSecretResolves: async () => mockTtsSecretResolves,
 }));
 
-import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import {
-  maybeDefaultSpeechToManaged,
+  maybeDefaultSpeechToCloud,
   resolveEffectiveSpeechProviders,
-} from "../config/managed-speech-defaults.js";
+} from "../config/cloud-speech-defaults.js";
+import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import { sttCatalogKeyForRole } from "../stt/roles.js";
 
 const WORKSPACE_DIR = process.env.CADET_WORKSPACE_DIR!;
@@ -53,23 +53,23 @@ function readConfig(): Record<string, unknown> {
 beforeEach(() => {
   ensureTestDir();
   writeConfig({});
-  mockManagedSpeechAvailable = false;
+  mockCloudSpeechAvailable = false;
   mockSttKeyResolves = false;
   mockTtsSecretResolves = false;
 });
 
-describe("maybeDefaultSpeechToManaged", () => {
-  test("no-ops when managed speech is unavailable", async () => {
-    await maybeDefaultSpeechToManaged();
+describe("maybeDefaultSpeechToCloud", () => {
+  test("no-ops when cloud speech is unavailable", async () => {
+    await maybeDefaultSpeechToCloud();
 
     const config = readConfig();
     expect(config.services).toBeUndefined();
   });
 
   test("defaults both services to cadet when no BYOK credentials resolve", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const config = readConfig();
     expect((config.services as any)?.stt?.provider).toBe("cadet");
@@ -78,10 +78,10 @@ describe("maybeDefaultSpeechToManaged", () => {
   });
 
   test("leaves a service alone when its BYOK credential resolves", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     mockSttKeyResolves = true;
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const config = readConfig();
     expect((config.services as any)?.stt?.provider).toBeUndefined();
@@ -89,18 +89,18 @@ describe("maybeDefaultSpeechToManaged", () => {
   });
 
   test("no-ops when both BYOK credentials resolve", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     mockSttKeyResolves = true;
     mockTtsSecretResolves = true;
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const config = readConfig();
     expect(config.services).toBeUndefined();
   });
 
   test("no-ops when services are already on cadet", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: {
         stt: { provider: "cadet" },
@@ -108,7 +108,7 @@ describe("maybeDefaultSpeechToManaged", () => {
       },
     });
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const config = readConfig();
     expect(config).toEqual({
@@ -122,8 +122,8 @@ describe("maybeDefaultSpeechToManaged", () => {
   test("a narrowing stand-in is written to the live-voice role, not the global", async () => {
     // BYOK Flux with no key: the stand-in preserves turn detection, so it is
     // cadet-flux, which streams and nothing else. Writing that globally is
-    // how batch transcription and telephony disappear for a managed user.
-    mockManagedSpeechAvailable = true;
+    // how batch transcription and telephony disappear for a cloud user.
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: {
         stt: {
@@ -134,7 +134,7 @@ describe("maybeDefaultSpeechToManaged", () => {
       },
     });
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const stt = (readConfig().services as any).stt;
     expect(stt.roles.liveVoice).toEqual({ provider: "cadet", model: "flux" });
@@ -144,7 +144,7 @@ describe("maybeDefaultSpeechToManaged", () => {
   });
 
   test("the role write leaves batch and telephony on a provider that answers", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: {
         stt: {
@@ -155,7 +155,7 @@ describe("maybeDefaultSpeechToManaged", () => {
       },
     });
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     invalidateConfigCache();
     const stt = getConfig().services.stt;
@@ -168,7 +168,7 @@ describe("maybeDefaultSpeechToManaged", () => {
     // Korean is outside Flux's ten-language roster, so the relay would reject
     // the dial. Standing in with Flux hands the speaker a dead mic rather
     // than a worse transcriber.
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: {
         stt: {
@@ -180,7 +180,7 @@ describe("maybeDefaultSpeechToManaged", () => {
       },
     });
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const stt = (readConfig().services as any).stt;
     expect(stt.provider).toBe("cadet");
@@ -189,7 +189,7 @@ describe("maybeDefaultSpeechToManaged", () => {
   });
 
   test("a language Flux does serve still reaches the flux stand-in", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: {
         stt: {
@@ -201,7 +201,7 @@ describe("maybeDefaultSpeechToManaged", () => {
       },
     });
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const stt = (readConfig().services as any).stt;
     expect(stt.roles.liveVoice).toEqual({ provider: "cadet", model: "flux" });
@@ -210,7 +210,7 @@ describe("maybeDefaultSpeechToManaged", () => {
   test("a capability-preserving stand-in still writes the global provider", async () => {
     // Plain deepgram has no turn detection, so the stand-in is plain cadet,
     // which serves every role. That one belongs on the global, not a role.
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: {
         stt: { provider: "deepgram" },
@@ -218,7 +218,7 @@ describe("maybeDefaultSpeechToManaged", () => {
       },
     });
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const stt = (readConfig().services as any).stt;
     expect(stt.provider).toBe("cadet");
@@ -226,7 +226,7 @@ describe("maybeDefaultSpeechToManaged", () => {
   });
 
   test("never repoints an explicit BYOK provider with resolving credentials", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     mockSttKeyResolves = true;
     mockTtsSecretResolves = true;
     writeConfig({
@@ -236,7 +236,7 @@ describe("maybeDefaultSpeechToManaged", () => {
       },
     });
 
-    await maybeDefaultSpeechToManaged();
+    await maybeDefaultSpeechToCloud();
 
     const config = readConfig();
     expect((config.services as any).stt.provider).toBe("deepgram");
@@ -245,11 +245,11 @@ describe("maybeDefaultSpeechToManaged", () => {
 });
 
 describe("managed live voice runs Flux", () => {
-  // Turn detection is the only reason to reach for that family, and a managed
+  // Turn detection is the only reason to reach for that family, and a cloud
   // user cannot ask for it: the provider picker offers no family, so `cadet`
   // is as specific as they can be.
   test("live voice upgrades to the flux family", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({ services: { stt: { provider: "cadet" } } });
 
     const { stt } = await resolveEffectiveSpeechProviders(undefined, {
@@ -262,7 +262,7 @@ describe("managed live voice runs Flux", () => {
   test("no other consumer follows it there", async () => {
     // The family streams and nothing else, so batch and telephony would lose
     // their transcriber entirely.
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({ services: { stt: { provider: "cadet" } } });
 
     for (const role of ["batch", "telephony", "dictation", "watch"] as const) {
@@ -278,7 +278,7 @@ describe("managed live voice runs Flux", () => {
   test("a family the user named wins", async () => {
     // `services.stt.providers.cadet.model` accepts nova-3, so quietly
     // overriding it would be the silent substitution roles exist to prevent.
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: {
         stt: { provider: "cadet", providers: { cadet: { model: "nova-3" } } },
@@ -293,7 +293,7 @@ describe("managed live voice runs Flux", () => {
   });
 
   test("a language the family cannot serve stays on nova-3", async () => {
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({
       services: { stt: { provider: "cadet", language: "ko" } },
     });
@@ -305,8 +305,8 @@ describe("managed live voice runs Flux", () => {
     expect(stt).toBe("cadet");
   });
 
-  test("nothing is upgraded while managed speech is unavailable", async () => {
-    mockManagedSpeechAvailable = false;
+  test("nothing is upgraded while cloud speech is unavailable", async () => {
+    mockCloudSpeechAvailable = false;
     writeConfig({ services: { stt: { provider: "cadet" } } });
 
     const { stt } = await resolveEffectiveSpeechProviders(undefined, {
@@ -319,7 +319,7 @@ describe("managed live voice runs Flux", () => {
   test("the upgrade writes no config", async () => {
     // A resolution rule, not a substitution: nothing lands on disk for a user
     // to discover, reset, or have to migrate.
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     writeConfig({ services: { stt: { provider: "cadet" } } });
     const before = JSON.stringify(readConfig());