@mycadet/assistant 0.12.11 → 0.13.0

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");

package/src/tts/provider-catalog.ts

@@ -21,7 +21,6 @@ import type {
   TtsProviderCatalogEntry,
   TtsProviderDefinition,
 } from "./provider-definition.js";
-import { cadetTtsProviderDefinition } from "./providers/cadet-provider.js";
 import { deepgramTtsProviderDefinition } from "./providers/deepgram-provider.js";
 import { elevenLabsTtsProviderDefinition } from "./providers/elevenlabs-provider.js";
 import { fishAudioTtsProviderDefinition } from "./providers/fish-audio-provider.js";
@@ -48,15 +47,12 @@ const DEFINITIONS = {
   "fish-audio": fishAudioTtsProviderDefinition,
   deepgram: deepgramTtsProviderDefinition,
   xai: xaiTtsProviderDefinition,
-  cadet: cadetTtsProviderDefinition,
 } as const satisfies Record<TtsProviderId, TtsProviderDefinition>;
 
 /**
  * Definitions in display order (e.g. settings dropdowns).
  */
-// cadet leads: it is the cloud option, selected like any other provider.
 const CATALOG: readonly TtsProviderDefinition[] = [
-  DEFINITIONS.cadet,
   DEFINITIONS.elevenlabs,
   DEFINITIONS["fish-audio"],
   DEFINITIONS.deepgram,

package/src/tts/types.ts

@@ -28,7 +28,6 @@ export const TTS_PROVIDER_IDS = [
   "fish-audio",
   "deepgram",
   "xai",
-  "cadet",
 ] as const;
 
 /**