@mycadet/assistant 0.12.10 → 0.13.0

package/src/live-voice/live-voice-session.ts

@@ -8262,14 +8262,18 @@ export async function defaultSpawnBackgroundContinuation(args: {
 async function defaultResolveStreamingTranscriber(
   options: ResolveStreamingTranscriberOptions,
 ): Promise<StreamingTranscriber | null> {
-  const { resolveEffectiveSpeechProviders } =
-    await import("../config/cloud-speech-defaults.js");
   const { resolveStreamingTranscriber } =
     await import("../providers/speech-to-text/resolve.js");
-  const { stt } = await resolveEffectiveSpeechProviders(undefined, {
-    role: "liveVoice",
-  });
-  return resolveStreamingTranscriber({ ...options, providerId: stt });
+  const { sttCatalogKeyForRole } = await import("../stt/roles.js");
+  const { getConfig } = await import("../config/loader.js");
+  // The live-voice role's configured provider is the one that gets dialed —
+  // the session resolves it here (rather than trusting a caller's override)
+  // so readiness and transcription agree.
+  const providerId = sttCatalogKeyForRole(
+    getConfig().services.stt,
+    "liveVoice",
+  );
+  return resolveStreamingTranscriber({ ...options, providerId });
 }
 
 async function defaultResolveLiveVoiceCredentialReadiness(): Promise<LiveVoiceCredentialReadiness> {

package/src/live-voice/live-voice-tts.ts

@@ -220,14 +220,7 @@ async function resolveLiveVoiceStreamingTtsProvider(
   configOverride?: LiveVoiceTtsConfig,
 ): Promise<ResolvedStreamingTtsProvider> {
   const config = configOverride ?? (await loadAssistantConfig());
-  const { resolveEffectiveSpeechProviders } =
-    await import("../config/cloud-speech-defaults.js");
-  const { tts: effectiveProviderId } =
-    await resolveEffectiveSpeechProviders(config);
-  const { provider: providerId, providerConfig } = resolveTtsConfig(
-    config,
-    effectiveProviderId,
-  );
+  const { provider: providerId, providerConfig } = resolveTtsConfig(config);
 
   let provider: TtsProvider;
   try {

package/src/plugins/defaults/memory/worker.ts

@@ -60,9 +60,9 @@ async function main(): Promise<void> {
   // standalone process must do it itself so getCloudBaseUrl() resolves to
   // the persisted platform environment instead of the CADET_ENVIRONMENT
   // default. Retrospective and consolidation passes wake real agent
-  // conversations whose inference and background-wake requests go through the
-  // cloud proxy — without rehydration those requests hit the wrong platform
-  // and are rejected.
+  // conversations whose inference requests go through the cloud proxy —
+  // without rehydration those requests hit the wrong platform and are
+  // rejected.
   await ensureCloudIdentityIds();
 
   // Jobs in this process wake real agent conversations, so it registers the

package/src/prompts/persona-resolver.ts

@@ -385,41 +385,6 @@ export function ensureGuardianPersonaFile(userFile: string): void {
   log.debug({ path: filePath }, "Wrote guardian persona scaffold");
 }
 
-/**
- * Return `true` when the persona file at `filePath` has been edited by
- * the user (its stripped content differs from the bare scaffold
- * template). Returns `false` when the file is missing, unreadable,
- * empty after stripping, or byte-identical to the template after
- * stripping comment lines.
- *
- * Used by the vbundle importer to decide whether a legacy
- * `prompts/USER.md` entry may safely overwrite `users/<slug>.md`.
- */
-export function isGuardianPersonaCustomized(filePath: string): boolean {
-  if (!existsSync(filePath)) {
-    return false;
-  }
-
-  let content: string;
-  try {
-    content = readFileSync(filePath, "utf-8");
-  } catch (err) {
-    log.warn(
-      { err, path: filePath },
-      "Failed to read persona file while checking customization",
-    );
-    return false;
-  }
-
-  const stripped = stripCommentLines(content);
-  if (stripped.length === 0) {
-    return false;
-  }
-
-  const templateStripped = stripCommentLines(GUARDIAN_PERSONA_TEMPLATE);
-  return stripped !== templateStripped;
-}
-
 // ── Onboarding section writer ────────────────────────────────────
 
 const ONBOARDING_HEADING = "## Onboarding Context";

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

@@ -38,7 +38,9 @@ describe("search-provider-catalog", () => {
   });
 
   test("cloud providers omit BYOK-only fields", () => {
-    const managed = SEARCH_PROVIDER_CATALOG.filter((p) => p.kind === "managed");
+    const managed = SEARCH_PROVIDER_CATALOG.filter(
+      (p) => p.secretKey === undefined,
+    );
     for (const provider of managed) {
       expect(provider.envVar).toBeUndefined();
       expect(provider.secretKey).toBeUndefined();
@@ -75,9 +77,8 @@ describe("search-provider-catalog", () => {
     expect(SEARCH_PROVIDER_FALLBACK_ORDER).toEqual(sorted);
   });
 
-  test("cadet is a cloud provider outside the BYOK fallback chain", () => {
-    expect(getSearchProvider("cadet")?.kind).toBe("managed");
-    expect(BYOK_SEARCH_PROVIDERS.map((p) => p.id)).not.toContain("cadet");
+  test("the retired cadet cloud search provider is no longer in the catalog", () => {
+    expect(getSearchProvider("cadet")).toBeUndefined();
     expect(SEARCH_PROVIDER_FALLBACK_ORDER).not.toContain("cadet");
   });
 
@@ -89,7 +90,6 @@ describe("search-provider-catalog", () => {
 
   test("SearXNG is a keyless BYOK provider that requires an instance URL", () => {
     const searxng = getSearchProvider("searxng");
-    expect(searxng?.kind).toBe("byok");
     expect(searxng?.keyless).toBe(true);
     expect(searxng?.supportsApiBase).toBe(true);
     expect(searxng?.defaultApiBase).toBeUndefined();
@@ -98,7 +98,6 @@ describe("search-provider-catalog", () => {
 
   test("TinyFish is a keyed BYOK provider with a cloud API base", () => {
     const tinyfish = getSearchProvider("tinyfish");
-    expect(tinyfish?.kind).toBe("byok");
     expect(tinyfish?.keyless).toBeUndefined();
     expect(tinyfish?.supportsApiBase).toBe(true);
     expect(tinyfish?.defaultApiBase).toBe("https://api.search.tinyfish.ai");
@@ -107,7 +106,6 @@ describe("search-provider-catalog", () => {
 
   test("Exa is a keyed BYOK provider without a custom API base", () => {
     const exa = getSearchProvider("exa");
-    expect(exa?.kind).toBe("byok");
     expect(exa?.keyless).toBeUndefined();
     expect(exa?.supportsApiBase).toBeUndefined();
     expect(exa?.envVar).toBe("EXA_API_KEY");
@@ -115,7 +113,6 @@ describe("search-provider-catalog", () => {
 
   test("Serply is a keyed BYOK provider without a custom API base", () => {
     const serply = getSearchProvider("serply");
-    expect(serply?.kind).toBe("byok");
     expect(serply?.keyless).toBeUndefined();
     expect(serply?.supportsApiBase).toBeUndefined();
     expect(serply?.envVar).toBe("SERPLY_API_KEY");

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

@@ -33,10 +33,8 @@ describe("describeSttFailure", () => {
     test("timeout uses provider-agnostic copy", () => {
       const copy = describeSttFailure(
         new SttError("timeout", "The operation was aborted"),
-        "cadet",
+        "deepgram",
       );
-      // A managed timeout (AbortError) carries no marker, so it still gets the
-      // friendly copy rather than the raw abort string.
       expect(copy).toBe("Transcription timed out.");
     });
 
@@ -50,27 +48,28 @@ describe("describeSttFailure", () => {
     });
   });
 
-  describe("cloud speech (userFacing marker)", () => {
+  describe("userFacing marker passthrough", () => {
     test("auth failure surfaces the reconnect remediation verbatim", () => {
       const message =
         "Cloud speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";
       const copy = describeSttFailure(
         new SttError("auth", message, { userFacing: true }),
-        "cadet",
+        "deepgram",
       );
-      // The BYOK "check your API key in Settings → Voice" rewrite must not
-      // clobber managed remediation — managed users hold no speech key.
+      // The userFacing marker means upstream already produced provider-
+      // appropriate copy — the BYOK "check your API key in Settings →
+      // Voice" rewrite must not clobber it.
       expect(copy).toBe(message);
       expect(copy).not.toContain("API key");
       expect(copy).not.toContain("Settings → Voice");
     });
 
-    test("credits-exhausted message survives the provider-error branch", () => {
+    test("a provider-error message with the marker survives verbatim", () => {
       const message =
-        "Cadet credits are exhausted — add funds to your Cadet account to continue using managed transcription.";
+        "Upstream transcription is temporarily unavailable — try again shortly.";
       const copy = describeSttFailure(
         new SttError("provider-error", message, { userFacing: true }),
-        "cadet",
+        "deepgram",
       );
       expect(copy).toBe(message);
       expect(copy).not.toContain("returned an error while transcribing");

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

@@ -27,11 +27,10 @@
  * The split between adapter (which carries the executor) and catalog (which
  * carries metadata) keeps the catalog purely declarative — adding an entry
  * never forces a code rebuild downstream and the JSON projection stays
- * trivial.
+ * trivial. BYOK-ness is expressed by the presence of key fields (secretKey /
+ * envVar / apiKeyPrefix).
  */
 
-export type SearchProviderKind = "managed" | "byok";
-
 export interface SearchProviderCatalogEntry {
   /** Stable provider identifier. Matches config + secret-catalog values. */
   readonly id: string;
@@ -42,26 +41,14 @@ export interface SearchProviderCatalogEntry {
    * privacy notices). Defaults to {@link displayName} when omitted.
    */
   readonly displayNameLong?: string;
-  /**
-   * Authentication style for the search provider choice.
-   *
-   * `managed` means the choice does not require a user-supplied search API key.
-   * `cadet` searches through the Cadet Cloud search proxy, billed to
-   * Cadet credits; the cloud connection is the credential. For
-   * `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 cloud search proxy only when no user search key is
-   * configured.
-   *
-   * `byok` providers require a user-supplied API key.
-   */
-  readonly kind: SearchProviderKind;
   /**
    * BYOK provider that also works without a user-supplied key (keyless by
    * default; a key is optional and only lifts rate limits). The daemon adapter
    * runs it even when no key is stored, and the missing-key fallback/error path
-   * does not treat it as fatal.
+   * does not treat it as fatal. The one managed-shaped entry
+   * (`inference-provider-native`) routes to the inference provider's own
+   * hosted web-search tool when the model supports one, and never carries
+   * key fields.
    */
   readonly keyless?: boolean;
   /** Placeholder shown in the API-key input. BYOK providers only. */
@@ -87,23 +74,13 @@ export interface SearchProviderCatalogEntry {
 }
 
 export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
-  // 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",
-    displayName: "Cadet",
-    displayNameLong: "Cadet Managed Search",
-    kind: "managed",
-  },
   {
     id: "inference-provider-native",
     displayName: "Provider Native",
-    kind: "managed",
   },
   {
     id: "perplexity",
     displayName: "Perplexity",
-    kind: "byok",
     apiKeyPrefix: "pplx-...",
     envVar: "PERPLEXITY_API_KEY",
     secretKey: "perplexity",
@@ -114,7 +91,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
     id: "brave",
     displayName: "Brave",
     displayNameLong: "Brave Search",
-    kind: "byok",
     apiKeyPrefix: "BSA...",
     envVar: "BRAVE_API_KEY",
     secretKey: "brave",
@@ -124,7 +100,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "tavily",
     displayName: "Tavily",
-    kind: "byok",
     apiKeyPrefix: "tvly-...",
     envVar: "TAVILY_API_KEY",
     secretKey: "tavily",
@@ -134,7 +109,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "firecrawl",
     displayName: "Firecrawl",
-    kind: "byok",
     apiKeyPrefix: "fc-...",
     envVar: "FIRECRAWL_API_KEY",
     secretKey: "firecrawl",
@@ -144,7 +118,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "keenable",
     displayName: "Keenable",
-    kind: "byok",
     keyless: true,
     apiKeyPrefix: "keen_... (optional)",
     envVar: "KEENABLE_API_KEY",
@@ -155,7 +128,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "fastcrw",
     displayName: "fastCRW",
-    kind: "byok",
     apiKeyPrefix: "crw_live_...",
     envVar: "FASTCRW_API_KEY",
     secretKey: "fastcrw",
@@ -167,7 +139,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "searxng",
     displayName: "SearXNG",
-    kind: "byok",
     keyless: true,
     apiKeyPrefix: "token (optional)",
     envVar: "SEARXNG_API_KEY",
@@ -179,7 +150,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "tinyfish",
     displayName: "TinyFish",
-    kind: "byok",
     apiKeyPrefix: "TinyFish API key...",
     envVar: "TINYFISH_API_KEY",
     secretKey: "tinyfish",
@@ -191,7 +161,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "exa",
     displayName: "Exa",
-    kind: "byok",
     apiKeyPrefix: "Exa API key...",
     envVar: "EXA_API_KEY",
     secretKey: "exa",
@@ -201,7 +170,6 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
   {
     id: "serply",
     displayName: "Serply",
-    kind: "byok",
     apiKeyPrefix: "Serply API key...",
     envVar: "SERPLY_API_KEY",
     secretKey: "serply",
@@ -216,7 +184,7 @@ export const SEARCH_PROVIDER_IDS: readonly string[] =
 
 /** Catalog entries that store an API key under their bare provider name. */
 export const BYOK_SEARCH_PROVIDERS: readonly SearchProviderCatalogEntry[] =
-  SEARCH_PROVIDER_CATALOG.filter((p) => p.kind === "byok");
+  SEARCH_PROVIDER_CATALOG.filter((p) => p.secretKey !== undefined);
 
 /** BYOK provider ids, ordered by `fallbackOrder` (ascending). */
 export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] =

package/src/providers/speech-to-text/__tests__/provider-catalog.test.ts

@@ -14,7 +14,6 @@ import {
   sttConfigForCatalogKey,
   supportsBoundary,
   supportsDiarization,
-  supportsProviderTurnDetection,
 } from "../provider-catalog.js";
 
 // ---------------------------------------------------------------------------
@@ -177,7 +176,6 @@ describe("STT provider catalog", () => {
 
   const expectedLanguageSelection = [
     ["deepgram", "manual"],
-    ["cadet", "manual"],
     ["xai", "manual"],
     // Flux takes no language parameter: its model is monolingual English.
     ["deepgram-flux", "auto"],
@@ -268,12 +266,12 @@ describe("model families", () => {
   test("flux rows are variants, not separately selectable providers", () => {
     // The whole point of folding these back: a model choice must not cost a
     // provider enum entry and a picker row.
-    for (const id of ["deepgram-flux", "cadet-flux"] as const) {
+    for (const id of ["deepgram-flux"] as const) {
       expect(getProviderEntry(id)?.variantOf).toBeDefined();
       expect(listSelectableProviderIds()).not.toContain(id);
     }
     expect(listSelectableProviderIds()).toEqual(
-      expect.arrayContaining(["deepgram", "cadet"]),
+      expect.arrayContaining(["deepgram"]),
     );
   });
 
@@ -284,12 +282,6 @@ describe("model families", () => {
         providers: { deepgram: { model: "flux" } },
       }),
     ).toBe("deepgram-flux");
-    expect(
-      resolveSttCatalogKey({
-        provider: "cadet",
-        providers: { cadet: { model: "flux" } },
-      }),
-    ).toBe("cadet-flux");
   });
 
   test("no model, or one the provider does not offer, resolves to the base row", () => {
@@ -314,7 +306,7 @@ describe("model families", () => {
     expect(
       resolveSttCatalogKey({
         provider: "deepgram",
-        providers: { cadet: { model: "flux" } },
+        providers: { xai: { model: "flux" } },
       }),
     ).toBe("deepgram");
   });
@@ -322,20 +314,14 @@ describe("model families", () => {
   test("names the base family so a stale variant model can be overwritten", () => {
     // Substituting away from a variant has to write something: leaving the
     // old model behind resolves straight back to the variant on next load.
-    expect(baseModelFamilyFor("cadet")).toBe("nova-3");
     expect(baseModelFamilyFor("deepgram")).toBe("nova-3");
     // Nothing to write, and no variant that could have left a stale value.
     expect(baseModelFamilyFor("openai-whisper")).toBeUndefined();
-    expect(baseModelFamilyFor("cadet-flux")).toBeUndefined();
   });
 
   test("round-trips a resolved key back to the config that selects it", () => {
     // Anything persisting a resolved provider needs this: the key itself is
     // not a valid services.stt.provider value.
-    expect(sttConfigForCatalogKey("cadet-flux")).toEqual({
-      provider: "cadet",
-      model: "flux",
-    });
     expect(sttConfigForCatalogKey("deepgram")).toEqual({
       provider: "deepgram",
     });
@@ -347,33 +333,3 @@ describe("model families", () => {
     expect(listProviderModelFamilies("deepgram-flux")).toEqual([]);
   });
 });
-
-describe("cadet-flux (managed Flux)", () => {
-  test("shares the cadet connection rather than a second credential", () => {
-    expect(getProviderEntry("cadet-flux")?.credentialProvider).toBe("cadet");
-    expect(listCredentialProviderNames()).not.toContain("cadet-flux");
-  });
-
-  test("is streaming-only, like the BYOK Flux entry", () => {
-    expect(supportsBoundary("cadet-flux", "daemon-streaming")).toBe(true);
-    expect(supportsBoundary("cadet-flux", "daemon-batch")).toBe(false);
-  });
-
-  test("decides end-of-turn itself, unlike plain cadet", () => {
-    // The relay is dialed with contract=flux, so Flux's turn events survive.
-    expect(supportsProviderTurnDetection("cadet-flux")).toBe(true);
-    expect(supportsProviderTurnDetection("cadet")).toBe(false);
-  });
-
-  test("stays off telephony", () => {
-    // The relay maps Finalize onto CloseStream and utterance-boundary finals
-    // are a nova-3 concept, so calls stay on `cadet`.
-    expect(getProviderEntry("cadet-flux")?.telephonyMode).toBe("none");
-  });
-
-  test("exposes a language picker, unlike BYOK Flux", () => {
-    // The relay picks flux-general-en or flux-general-multi from the language
-    // it is sent, so the selection is meaningful here.
-    expect(getProviderEntry("cadet-flux")?.languageSelection).toBe("manual");
-  });
-});