@mycadet/assistant 0.12.10 → 0.13.0

package/src/schedule/schedule-store.ts

@@ -49,13 +49,6 @@ const logger = getLogger("schedule-store");
 
 function notifySchedulesChanged(): void {
   publishSchedulesChanged();
-  void import("../background-wake/publisher.js")
-    .then(({ refreshBackgroundWakeIntent }) =>
-      refreshBackgroundWakeIntent("schedule-changed"),
-    )
-    .catch((err) =>
-      logger.warn({ err }, "Failed to queue background wake refresh"),
-    );
 }
 
 export type ScheduleMode =

package/src/schedule/scheduler.ts

@@ -1,4 +1,3 @@
-import { refreshBackgroundWakeIntent } from "../background-wake/publisher.js";
 import { resolveSingleRouteProfileKey } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { findConversationOrSubagent } from "../daemon/conversation-registry.js";
@@ -556,10 +555,6 @@ export function startScheduler(): SchedulerHandle {
     },
   };
 
-  // Publish the initial background wake intent now that the scheduler is live
-  // and its schedules are visible to `computeNextBackgroundWakeIntent`.
-  refreshBackgroundWakeIntent("daemon-startup");
-
   return instance;
 }
 

package/src/schedule/worker.ts

@@ -144,7 +144,7 @@ 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 — otherwise valid credentials are sent to the wrong platform and
-  // rejected for both inference and background-wake requests.
+  // rejected for inference requests.
   await ensureCloudIdentityIds();
 
   // This process is the sole runner of schedule execution and hosts real agent

package/src/stt/__tests__/daemon-batch-transcriber.test.ts

@@ -610,16 +610,8 @@ describe("normalizeSttError", () => {
   });
 });
 
-describe("cadet factory case", () => {
-  test("constructs the cloud transcriber with no API key", () => {
-    const transcriber = createDaemonBatchTranscriber(null, "cadet");
-    expect(transcriber?.providerId).toBe("cadet");
-    expect(transcriber?.boundaryId).toBe("daemon-batch");
-  });
-
-  test("still returns null for key-based providers without a key", () => {
-    expect(createDaemonBatchTranscriber(null, "deepgram")).toBeNull();
-  });
+test("still returns null for key-based providers without a key", () => {
+  expect(createDaemonBatchTranscriber(null, "deepgram")).toBeNull();
 });
 
 describe("deepgram-flux factory case", () => {

package/src/stt/daemon-batch-transcriber.ts

@@ -205,32 +205,6 @@ export function normalizeSttError(err: unknown): SttError {
   return new SttError("provider-error", message);
 }
 
-// ---------------------------------------------------------------------------
-// Cadet Cloud adapter — implements BatchTranscriber on top of the
-// platform's cloud speech endpoint. No API key: the cloud connection
-// is the credential.
-// ---------------------------------------------------------------------------
-
-class CadetManagedBatchTranscriber implements BatchTranscriber {
-  readonly providerId = "cadet" as const;
-  readonly boundaryId = "daemon-batch" as const;
-
-  constructor(private readonly language: string | undefined) {}
-
-  async transcribe(
-    request: SttTranscribeRequest,
-  ): Promise<SttTranscribeResult> {
-    const { cadetCloudTranscribe } =
-      await import("../providers/speech-to-text/cadet-cloud.js");
-    return cadetCloudTranscribe(
-      request.audio,
-      request.mimeType,
-      request.signal,
-      this.language,
-    );
-  }
-}
-
 /**
  * Create a `BatchTranscriber` for the daemon-batch boundary.
  *
@@ -241,10 +215,9 @@ class CadetManagedBatchTranscriber implements BatchTranscriber {
  * is unavailable.
  *
  * `language` is the spoken language, forwarded to providers whose batch API
- * accepts one: Deepgram (where `"multi"` also pins nova-3), xAI (where
+ * accepts one: Deepgram (where `"multi"` also pins nova-3) and xAI (where
  * `"multi"` is dropped because it is a Deepgram-specific value, not a
- * language code), and the Cadet Cloud path, whose cloud proxy passes
- * it to Deepgram server-side. Whisper and Gemini auto-detect natively and
+ * language code). Whisper and Gemini auto-detect natively and
  * take no language parameter, so it is silently ignored for them.
  *
  * Throws an {@link SttError} for a provider with no batch endpoint at all,
@@ -255,11 +228,6 @@ export function createDaemonBatchTranscriber(
   providerId: SttProviderId,
   language?: string,
 ): BatchTranscriber | null {
-  // Cloud speech authenticates via the cloud connection, not an API
-  // key. Callers pass canonical ids; the resolver maps legacy ones first.
-  if (providerId === "cadet") {
-    return new CadetManagedBatchTranscriber(language);
-  }
   if (!apiKey) {
     return null;
   }
@@ -274,11 +242,9 @@ export function createDaemonBatchTranscriber(
     case "xai":
       return new XAIBatchTranscriber(apiKey, language);
     case "deepgram-flux":
-    case "cadet-flux":
       // Same copy the resolver raises, so a direct factory caller and a
-      // config-driven one report the mismatch identically. Both Flux
-      // variants are streaming-only: the model has no batch endpoint, BYOK
-      // or managed.
+      // config-driven one report the mismatch identically. Flux is
+      // streaming-only: the model has no batch endpoint.
       throw new SttError("provider-error", batchBoundaryGapReason(providerId), {
         userFacing: true,
       });

package/src/stt/types.ts

@@ -52,15 +52,7 @@ export type SttProviderId =
    */
   | "deepgram-flux"
   | "google-gemini"
-  | "xai"
-  | "cadet"
-  /**
-   * Cloud Flux: the same conversational model as `deepgram-flux`, reached
-   * through the cloud's speech relay instead of a Deepgram key. Dials the
-   * relay's STT v2 endpoint asking for native Flux frames, so it keeps the
-   * turn events the relay's default v1-shaped translation drops.
-   */
-  | "cadet-flux";
+  | "xai";
 
 /**
  * Telephony-specific STT capability class.

package/src/tools/network/__tests__/web-search.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { useMemorySecureKeyMap } from "../../../__tests__/helpers/secure-keys.js";
 import { setConfig } from "../../../__tests__/helpers/set-config.js";
@@ -15,14 +15,6 @@ function setKey(provider: string, value: string | undefined): void {
     secureKeys.set(credentialKey(provider, "api_key"), value);
   }
 }
-let mockManagedSearchProxyResult: any;
-let mockManagedSearchAvailable = true;
-let mockManagedSearchProxyCalls: Array<{
-  provider: string;
-  request: Record<string, unknown>;
-  signal?: AbortSignal;
-}> = [];
-
 /**
  * Seed the web-search service into the workspace config. Pass `undefined`
  * for mode to write a post-migration-132 config carrying only `provider`.
@@ -42,18 +34,6 @@ function seedWebSearch(
   });
 }
 
-mock.module("../cloud-search-proxy.js", () => ({
-  callManagedSearchProxy: async (
-    provider: string,
-    request: Record<string, unknown>,
-    signal?: AbortSignal,
-  ) => {
-    mockManagedSearchProxyCalls.push({ provider, request, signal });
-    return mockManagedSearchProxyResult;
-  },
-  managedSearchAvailable: async () => mockManagedSearchAvailable,
-}));
-
 // Import after the mocks above so the module under test sees them.
 const { webSearchTool } = await import("../web-search.js");
 
@@ -73,14 +53,6 @@ describe("web_search tool", () => {
     setKey("tinyfish", undefined);
     setKey("exa", undefined);
     setKey("serply", undefined);
-    mockManagedSearchProxyCalls = [];
-    mockManagedSearchAvailable = true;
-    mockManagedSearchProxyResult = {
-      ok: true,
-      status: 200,
-      headers: { "content-type": "application/json" },
-      body: { web: { results: [] } },
-    };
   });
 
   afterEach(() => {
@@ -115,58 +87,7 @@ describe("web_search tool", () => {
     expect(result.content).toContain("No web search API key configured");
   });
 
-  // ---- Provider cadet (managed, provider is the only axis) ---------------
-
-  test("provider cadet with no mode routes to the cloud proxy", async () => {
-    seedWebSearch(undefined, "cadet");
-
-    const result = await execute({ query: "cadet managed query" });
-
-    expect(result.isError).toBe(false);
-    expect(mockManagedSearchProxyCalls).toHaveLength(1);
-    expect(mockManagedSearchProxyCalls[0].provider).toBe("brave");
-  });
-
-  test("provider cadet routes managed even under a stale your-own mode", async () => {
-    // The provider choice wins over a leftover legacy mode key.
-    seedWebSearch("your-own", "cadet");
-
-    const result = await execute({ query: "stale mode query" });
-
-    expect(result.isError).toBe(false);
-    expect(mockManagedSearchProxyCalls).toHaveLength(1);
-  });
-
-  test("provider cadet surfaces a 402 hard error and never falls back to BYOK keys", async () => {
-    // Billing rule: an explicit cadet choice must never silently reroute to
-    // a user's paid third-party key (and vice versa).
-    seedWebSearch(undefined, "cadet");
-    setKey("perplexity", "pplx-should-not-be-used");
-    mockManagedSearchProxyResult = {
-      ok: false,
-      kind: "platform-error",
-      status: 402,
-      headers: { "content-type": "application/json" },
-      body: { detail: "Insufficient balance" },
-      message: "Cloud search proxy returned status 402: Insufficient balance",
-    };
-    let byokFetchCalls = 0;
-    globalThis.fetch = (async () => {
-      byokFetchCalls += 1;
-      return new Response("{}", { status: 200 });
-    }) as any;
-
-    const result = await execute({ query: "billing query" });
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("account balance");
-    expect(result.content).toContain("different web search provider");
-    expect(byokFetchCalls).toBe(0);
-  });
-
-  // ---- Provider Native fallback order (keys first, proxy last) ------------
-
-  test("provider native with a BYOK key uses the key, not the proxy", async () => {
+  test("provider native with a BYOK key uses the key", async () => {
     seedWebSearch(undefined, "inference-provider-native");
     setKey("perplexity", "pplx-test-key");
     globalThis.fetch = (async () =>
@@ -182,27 +103,15 @@ describe("web_search tool", () => {
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain("BYOK answer");
-    expect(mockManagedSearchProxyCalls).toHaveLength(0);
   });
 
-  test("provider native with no keys falls back to the cloud proxy", async () => {
+  test("provider native with no keys reports the no-key error", async () => {
     seedWebSearch(undefined, "inference-provider-native");
 
     const result = await execute({ query: "no key native query" });
 
-    expect(result.isError).toBe(false);
-    expect(mockManagedSearchProxyCalls).toHaveLength(1);
-  });
-
-  test("provider native with no keys and no platform reports the no-key error", async () => {
-    seedWebSearch(undefined, "inference-provider-native");
-    mockManagedSearchAvailable = false;
-
-    const result = await execute({ query: "offline native query" });
-
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No web search API key configured");
-    expect(mockManagedSearchProxyCalls).toHaveLength(0);
   });
 
   // ---- Perplexity provider ------------------------------------------------
@@ -471,161 +380,6 @@ describe("web_search tool", () => {
     expect(callCount).toBe(4);
   });
 
-  // ---- Cloud Brave provider -------------------------------------------
-
-  test("provider cadet uses Brave proxy without BYOK provider keys", async () => {
-    seedWebSearch(undefined, "cadet");
-    mockManagedSearchProxyResult = {
-      ok: true,
-      status: 200,
-      headers: { "content-type": "application/json" },
-      body: {
-        web: {
-          results: [
-            {
-              title: "Cloud Result",
-              url: "https://example.com/managed",
-              description: "Cloud Brave result",
-            },
-          ],
-        },
-      },
-    };
-
-    const result = await execute({
-      query: "managed query",
-      count: 5,
-      offset: 2,
-      freshness: "pw",
-    });
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Cloud Result");
-    expect(mockManagedSearchProxyCalls).toHaveLength(1);
-    expect(mockManagedSearchProxyCalls[0]).toMatchObject({
-      provider: "brave",
-      request: {
-        method: "GET",
-        path: "/res/v1/web/search",
-        query: {
-          q: "managed query",
-          count: "5",
-          offset: "2",
-          freshness: "pw",
-        },
-        headers: {
-          Accept: "application/json",
-        },
-        body: null,
-      },
-    });
-  });
-
-  test("managed Brave formats results like direct Brave", async () => {
-    const braveBody = {
-      web: {
-        results: [
-          {
-            title: "Same Result",
-            url: "https://example.com/same",
-            description: "Same description",
-            age: "1 day ago",
-            extra_snippets: ["Same snippet"],
-          },
-        ],
-      },
-    };
-
-    seedWebSearch("your-own", "brave");
-    setKey("brave", "brave-key");
-    globalThis.fetch = (async () => {
-      return new Response(JSON.stringify(braveBody), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    }) as any;
-
-    const directResult = await execute({ query: "same query" });
-
-    seedWebSearch(undefined, "cadet");
-    setKey("brave", undefined);
-    mockManagedSearchProxyResult = {
-      ok: true,
-      status: 200,
-      headers: { "content-type": "application/json" },
-      body: braveBody,
-    };
-
-    const managedResult = await execute({ query: "same query" });
-
-    expect(managedResult.isError).toBe(false);
-    expect(managedResult.content).toBe(directResult.content);
-    expect(managedResult.activityMetadata.webSearch.results).toEqual(
-      directResult.activityMetadata.webSearch.results,
-    );
-  });
-
-  test("provider cadet passes abort signal to the cloud proxy", async () => {
-    seedWebSearch(undefined, "cadet");
-    const controller = new AbortController();
-
-    await execute({ query: "abortable query" }, { signal: controller.signal });
-
-    expect(mockManagedSearchProxyCalls).toHaveLength(1);
-    expect(mockManagedSearchProxyCalls[0].signal).toBe(controller.signal);
-  });
-
-  test("provider cadet maps insufficient balance to a cloud usage error", async () => {
-    seedWebSearch(undefined, "cadet");
-    mockManagedSearchProxyResult = {
-      ok: false,
-      kind: "platform-error",
-      status: 402,
-      headers: { "content-type": "application/json" },
-      body: { detail: "Insufficient balance" },
-      message: "Cloud search proxy returned status 402: Insufficient balance",
-    };
-
-    const result = await execute({ query: "billing query" });
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Managed web search");
-    expect(result.content).toContain("account balance");
-    expect(result.content).toContain("different web search provider");
-  });
-
-  test("provider cadet maps proxied provider errors to a tool error", async () => {
-    seedWebSearch(undefined, "cadet");
-    mockManagedSearchProxyResult = {
-      ok: true,
-      status: 400,
-      headers: { "content-type": "application/json" },
-      body: { error: "Bad upstream request" },
-    };
-
-    const result = await execute({ query: "provider error query" });
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "Cloud Brave Search provider returned status 400",
-    );
-  });
-
-  test("provider cadet returns a clear error when platform context is unavailable", async () => {
-    seedWebSearch(undefined, "cadet");
-    mockManagedSearchProxyResult = {
-      ok: false,
-      kind: "unavailable",
-      message: "Cloud search proxy is unavailable in this environment.",
-    };
-
-    const result = await execute({ query: "local managed query" });
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("Cloud search proxy is unavailable");
-    expect(result.content).toContain("Log in to Cadet");
-  });
-
   test("your-own mode keeps direct Brave BYOK behavior unchanged", async () => {
     seedWebSearch("your-own", "brave");
     setKey("brave", "brave-direct-key");
@@ -641,7 +395,6 @@ describe("web_search tool", () => {
     const result = await execute({ query: "direct query" });
 
     expect(result.isError).toBe(false);
-    expect(mockManagedSearchProxyCalls).toHaveLength(0);
     expect(capturedHeaders!.get("X-Subscription-Token")).toBe(
       "brave-direct-key",
     );

package/src/tools/network/web-search.ts

@@ -21,7 +21,6 @@ import type {
   ToolDefinition,
   ToolExecutionResult,
 } from "../types.js";
-import type { ManagedSearchProxyResult } from "./cloud-search-proxy.js";
 import { extractDomain } from "./domain-normalize.js";
 import {
   extractFirecrawlCompatSearchResults,
@@ -242,10 +241,8 @@ function getWebSearchProvider(): WebSearchProvider {
   // In Your Own mode, `inference-provider-native` is only executable when the
   // inference provider swaps this tool for a native hosted-search definition.
   // If this app-executed tool is still invoked, fall back to the existing BYOK
-  // provider chain. `cadet` short-circuits into the cloud branch before
-  // this function runs, so its coercion here only satisfies the return type
-  // and keeps an undefined WEB_SEARCH_ADAPTERS lookup unreachable.
-  if (configured === "inference-provider-native" || configured === "cadet") {
+  // provider chain.
+  if (configured === "inference-provider-native") {
     return "perplexity";
   }
   return configured as WebSearchProvider;
@@ -1181,110 +1178,6 @@ async function executeBraveSearch(
   );
 }
 
-async function executeManagedBraveSearch(
-  query: string,
-  count: number,
-  offset: number,
-  freshness: string | undefined,
-  signal?: AbortSignal,
-): Promise<ToolExecutionResult> {
-  const { callManagedSearchProxy } = await import("./cloud-search-proxy.js");
-  const startedAt = Date.now();
-  const proxyResult = await callManagedSearchProxy(
-    "brave",
-    {
-      method: "GET",
-      path: BRAVE_SEARCH_PATH,
-      query: braveQueryParams(query, count, offset, freshness),
-      headers: {
-        Accept: "application/json",
-      },
-      body: null,
-    },
-    signal,
-  );
-
-  if (!proxyResult.ok) {
-    // Keep billing/auth/unavailable mapping as specific copy; route genuine
-    // platform 5xx (transport-level failures) to the friendly backend helper.
-    if (proxyResult.kind === "platform-error" && proxyResult.status >= 500) {
-      return backendFailureResult(
-        query,
-        "brave",
-        startedAt,
-        {
-          statusCode: proxyResult.status,
-          error: rawBodyDetail(proxyResult.body),
-        },
-        managedSearchProxyErrorMessage(proxyResult),
-      );
-    }
-    return errorResult(
-      query,
-      "brave",
-      startedAt,
-      managedSearchProxyErrorMessage(proxyResult),
-    );
-  }
-
-  if (proxyResult.status >= 200 && proxyResult.status < 300) {
-    return successfulBraveResult(
-      proxyResult.body as BraveSearchResponse,
-      query,
-      startedAt,
-    );
-  }
-
-  if (proxyResult.status === 401 || proxyResult.status === 403) {
-    return errorResult(
-      query,
-      "brave",
-      startedAt,
-      "Cloud Brave Search is not authenticated correctly. This is a Cadet Cloud configuration issue.",
-    );
-  }
-
-  if (proxyResult.status === 429 || proxyResult.status >= 500) {
-    return backendFailureResult(
-      query,
-      "brave",
-      startedAt,
-      {
-        statusCode: proxyResult.status,
-        error: rawBodyDetail(proxyResult.body),
-      },
-      proxyResult.status === 429
-        ? "Cloud Brave Search rate limit exceeded. Try again shortly."
-        : `Cloud Brave Search provider returned status ${proxyResult.status}`,
-    );
-  }
-
-  return errorResult(
-    query,
-    "brave",
-    startedAt,
-    `Cloud Brave Search provider returned status ${proxyResult.status}`,
-  );
-}
-
-function managedSearchProxyErrorMessage(
-  result: Exclude<ManagedSearchProxyResult, { ok: true }>,
-): string {
-  if (result.kind === "unavailable") {
-    return `${result.message} Log in to Cadet or choose a different web search provider in Settings.`;
-  }
-
-  if (result.kind === "platform-error" && result.status === 402) {
-    return "Managed web search is unavailable because your Cadet account balance is too low. Add funds or choose a different web search provider in Settings.";
-  }
-
-  if (result.kind === "platform-error") {
-    return `Managed web search platform request failed: ${result.message}`;
-  }
-
-  return result.message;
-}
-
 async function executePerplexitySearch(
   query: string,
   apiKey: string,
@@ -2264,14 +2157,6 @@ const braveSearchAdapter: WebSearchAdapter = {
     executeBraveSearch(query, count, offset, freshness, apiKey, signal),
 };
 
-const managedBraveSearchAdapter: WebSearchAdapter = {
-  id: "brave",
-  providerKeyName: "brave",
-  fallbackOrder: 2,
-  execute: ({ query, count, offset, freshness, signal }) =>
-    executeManagedBraveSearch(query, count, offset, freshness, signal),
-};
-
 const tavilySearchAdapter: WebSearchAdapter = {
   id: "tavily",
   providerKeyName: "tavily",
@@ -2414,12 +2299,6 @@ export const webSearchTool = {
     }
 
     const startedAt = Date.now();
-    // An explicit Cadet choice is unconditionally managed: proxy errors
-    // (including 402) surface to the user and never fall back to BYOK keys.
-    // The config schema normalizes the legacy `cadet` id to `cadet` on
-    // parse, so this is the only spelling that survives here.
-    const managedSearch =
-      getConfig().services["web-search"].provider === "cadet";
 
     const count =
       typeof input.count === "number"
@@ -2432,33 +2311,6 @@ export const webSearchTool = {
     const freshness =
       typeof input.freshness === "string" ? input.freshness : undefined;
 
-    const executeManagedSearch = async (): Promise<ToolExecutionResult> => {
-      try {
-        log.debug({ query, provider: "brave" }, "Executing managed web search");
-        return await managedBraveSearchAdapter.execute({
-          query,
-          count,
-          offset,
-          freshness,
-          apiKey: "",
-          signal: context.signal,
-        });
-      } catch (err) {
-        log.error({ err }, "Managed web search failed");
-        return networkFailureResult(
-          query,
-          "brave",
-          startedAt,
-          err,
-          context.signal,
-        );
-      }
-    };
-
-    if (managedSearch) {
-      return executeManagedSearch();
-    }
-
     let provider = getWebSearchProvider();
     let apiKey = await getApiKey(provider);
 
@@ -2496,21 +2348,8 @@ export const webSearchTool = {
 
       if (!apiKey) {
         // Provider Native reaches this app-executed path only when the
-        // inference model had no hosted search of its own. The user's own keys
-        // win above; the cloud proxy is the last resort, which is what
-        // `mode: "managed"` did for installs that never configured a search
-        // key. Read the configured provider off config — the local `provider`
-        // has already been coerced to "perplexity".
-        if (
-          getConfig().services["web-search"].provider ===
-          "inference-provider-native"
-        ) {
-          const { managedSearchAvailable } =
-            await import("./cloud-search-proxy.js");
-          if (await managedSearchAvailable()) {
-            return executeManagedSearch();
-          }
-        }
+        // inference model had no hosted search of its own. The user's own
+        // keys win above; without one the run fails with the setup hint.
         return errorResult(
           query,
           provider,

package/src/tts/__tests__/provider-resolution.test.ts

@@ -89,11 +89,6 @@ describe("managed TTS provider resolution", () => {
       typeof resolveTtsConfig
     >[0];
 
-  test("resolves the cadet provider", () => {
-    const config = configWith({ provider: "cadet", providers: {} });
-    expect(resolveTtsConfig(config).provider).toBe("cadet");
-  });
-
   test("resolves a BYOK provider", () => {
     const config = configWith({ provider: "deepgram", providers: {} });
     expect(resolveTtsConfig(config).provider).toBe("deepgram");