gloomberb 0.10.0 → 0.10.2

package/src/news/aggregator.ts

@@ -17,17 +17,30 @@ export { buildNewsQueryKey } from "./news-model";
 
 export interface NewsServiceOptions {
   pollIntervalMs?: number;
+  inactiveQueryTtlMs?: number;
+  maxInactiveQueries?: number;
+  now?: () => number;
 }
 
 export type NewsQueryListener = (state: NewsQueryState) => void;
 
 const DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;
+const DEFAULT_INACTIVE_QUERY_TTL_MS = 10 * 60 * 1000;
+const DEFAULT_MAX_INACTIVE_QUERIES = 50;
 
 interface SourceFetchResult {
   articles: NewsArticle[];
   sourceIds: string[];
 }
 
+interface NewsQueryEntry {
+  query: NewsQuery;
+  state: NewsQueryState;
+  inFlight: Promise<NewsQueryState> | null;
+  refs: number;
+  lastAccessedAt: number;
+}
+
 function newsCapabilityPriority(source: NewsCapability): number {
   return source.priority ?? 1000;
 }
@@ -39,17 +52,20 @@ function newsCapabilitySourceId(source: NewsCapability): string {
 export class NewsService {
   private readonly sources = new Map<string, NewsCapability>();
   private readonly listeners = new Set<() => void>();
-  private readonly queryStates = new Map<string, NewsQueryState>();
-  private readonly queryByKey = new Map<string, NewsQuery>();
-  private readonly watchedQueries = new Map<string, { query: NewsQuery; refs: number }>();
-  private readonly inFlight = new Map<string, Promise<NewsQueryState>>();
+  private readonly queries = new Map<string, NewsQueryEntry>();
   private articles: NewsArticle[] = [];
   private version = 0;
   private pollTimer: ReturnType<typeof setInterval> | null = null;
   private readonly pollIntervalMs: number;
+  private readonly inactiveQueryTtlMs: number;
+  private readonly maxInactiveQueries: number;
+  private readonly now: () => number;
 
   constructor(options: NewsServiceOptions = {}) {
     this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.inactiveQueryTtlMs = Math.max(1, options.inactiveQueryTtlMs ?? DEFAULT_INACTIVE_QUERY_TTL_MS);
+    this.maxInactiveQueries = Math.max(1, Math.floor(options.maxInactiveQueries ?? DEFAULT_MAX_INACTIVE_QUERIES));
+    this.now = options.now ?? Date.now;
   }
 
   register(source: NewsCapability): () => void {
@@ -89,29 +105,24 @@ export class NewsService {
   watchQuery(query: NewsQuery, listener: NewsQueryListener): () => void {
     const normalized = normalizeNewsQuery(query);
     const key = buildNewsQueryKey(normalized);
-    const currentWatch = this.watchedQueries.get(key);
-    this.watchedQueries.set(key, {
-      query: normalized,
-      refs: (currentWatch?.refs ?? 0) + 1,
-    });
+    const entry = this.getOrCreateQueryEntry(normalized);
+    entry.refs++;
 
-    const emit = () => listener(this.queryStates.get(key) ?? createIdleNewsQueryState());
+    const emit = () => listener(this.queries.get(key)?.state ?? createIdleNewsQueryState());
     const unsubscribe = this.subscribe(emit);
     emit();
-    void this.refreshQuery(normalized, false, { track: false });
+    void this.refreshQuery(normalized, false);
 
     let disposed = false;
     return () => {
       if (disposed) return;
       disposed = true;
       unsubscribe();
-      const watch = this.watchedQueries.get(key);
-      if (!watch) return;
-      if (watch.refs <= 1) {
-        this.watchedQueries.delete(key);
-      } else {
-        this.watchedQueries.set(key, { query: watch.query, refs: watch.refs - 1 });
-      }
+      const current = this.queries.get(key);
+      if (!current) return;
+      current.refs = Math.max(0, current.refs - 1);
+      current.lastAccessedAt = this.now();
+      this.pruneInactiveQueries();
     };
   }
 
@@ -128,9 +139,7 @@ export class NewsService {
 
   getQueryState(query: NewsQuery): NewsQueryState {
     const normalized = normalizeNewsQuery(query);
-    const key = buildNewsQueryKey(normalized);
-    this.queryByKey.set(key, normalized);
-    return this.queryStates.get(key) ?? createIdleNewsQueryState();
+    return this.getOrCreateQueryEntry(normalized).state;
   }
 
   async load(query: NewsQuery): Promise<NewsQueryState> {
@@ -160,36 +169,28 @@ export class NewsService {
   }
 
   private async pollActiveQueries(): Promise<void> {
-    const queries = new Map<string, NewsQuery>();
-    for (const query of this.queryByKey.values()) {
-      queries.set(buildNewsQueryKey(query), query);
-    }
-    for (const [key, watch] of this.watchedQueries) {
-      queries.set(key, watch.query);
-    }
-    if (queries.size === 0) return;
-    await Promise.allSettled([...queries.values()].map((query) => this.refreshQuery(query, false, { track: false })));
+    this.pruneInactiveQueries();
+    const queries = [...this.queries.values()]
+      .filter((entry) => entry.refs > 0)
+      .map((entry) => entry.query);
+    if (queries.length === 0) return;
+    await Promise.allSettled(queries.map((query) => this.refreshQuery(query, false)));
   }
 
   private async refreshQuery(
     query: NewsQuery,
     showLoading: boolean,
-    options: { track?: boolean } = {},
   ): Promise<NewsQueryState> {
-    const key = buildNewsQueryKey(query);
-    if (options.track !== false) {
-      this.queryByKey.set(key, query);
-    }
-    const existingFlight = this.inFlight.get(key);
-    if (existingFlight) return existingFlight;
+    const entry = this.getOrCreateQueryEntry(query);
+    if (entry.inFlight) return entry.inFlight;
 
-    const current = this.queryStates.get(key) ?? createIdleNewsQueryState();
+    const current = entry.state;
     if (showLoading) {
-      this.queryStates.set(key, {
+      entry.state = {
         ...current,
         phase: current.articles.length > 0 ? "refreshing" : "loading",
         error: null,
-      });
+      };
       this.notify();
     }
 
@@ -201,10 +202,11 @@ export class NewsService {
           phase: "ready",
           articles,
           error: null,
-          updatedAt: Date.now(),
+          updatedAt: this.now(),
           sourceIds: result.sourceIds,
         };
-        this.queryStates.set(key, state);
+        entry.state = state;
+        entry.lastAccessedAt = this.now();
         this.rebuildArticlePool();
         this.notify();
         return state;
@@ -214,18 +216,60 @@ export class NewsService {
           phase: "error",
           error: error instanceof Error ? error.message : String(error),
         };
-        this.queryStates.set(key, state);
+        entry.state = state;
+        entry.lastAccessedAt = this.now();
         this.notify();
         return state;
       } finally {
-        this.inFlight.delete(key);
+        entry.inFlight = null;
+        this.pruneInactiveQueries();
       }
     })();
 
-    this.inFlight.set(key, promise);
+    entry.inFlight = promise;
     return promise;
   }
 
+  private getOrCreateQueryEntry(query: NewsQuery): NewsQueryEntry {
+    const key = buildNewsQueryKey(query);
+    const now = this.now();
+    this.pruneInactiveQueries(now);
+    const existing = this.queries.get(key);
+    if (existing) {
+      existing.lastAccessedAt = now;
+      return existing;
+    }
+    const entry: NewsQueryEntry = {
+      query,
+      state: createIdleNewsQueryState(),
+      inFlight: null,
+      refs: 0,
+      lastAccessedAt: now,
+    };
+    this.queries.set(key, entry);
+    this.pruneInactiveQueries(now);
+    return entry;
+  }
+
+  private pruneInactiveQueries(now = this.now()): void {
+    const inactive = [...this.queries.entries()]
+      .filter(([, entry]) => entry.refs === 0 && entry.inFlight === null)
+      .sort((left, right) => right[1].lastAccessedAt - left[1].lastAccessedAt);
+
+    let retained = 0;
+    let changed = false;
+    for (const [key, entry] of inactive) {
+      const expired = now - entry.lastAccessedAt >= this.inactiveQueryTtlMs;
+      if (expired || retained >= this.maxInactiveQueries) {
+        this.queries.delete(key);
+        changed = true;
+      } else {
+        retained++;
+      }
+    }
+    if (changed) this.rebuildArticlePool();
+  }
+
   private enabledSources(query: NewsQuery): NewsCapability[] {
     return [...this.sources.values()]
       .filter((source) => source.isEnabled?.() !== false)
@@ -277,7 +321,7 @@ export class NewsService {
 
   private seedCachedSource(source: NewsCapability): void {
     const news = source.provider;
-    const queries = [...this.queryByKey.values()];
+    const queries = [...this.queries.values()].map((entry) => entry.query);
     if (queries.length === 0) queries.push(DEFAULT_GLOBAL_QUERY);
 
     let changed = false;
@@ -286,15 +330,14 @@ export class NewsService {
       const cached = (news.getCachedNews?.(query) ?? [])
         .map((article) => markDetailCapableArticle(source, article));
       if (cached.length === 0) continue;
-      const key = buildNewsQueryKey(query);
-      const current = this.queryStates.get(key) ?? createIdleNewsQueryState();
-      this.queryStates.set(key, {
+      const entry = this.getOrCreateQueryEntry(query);
+      entry.state = {
         phase: "ready",
-        articles: filterNewsArticlesForQuery(dedupeNewsArticles([...current.articles, ...cached]), query),
+        articles: filterNewsArticlesForQuery(dedupeNewsArticles([...entry.state.articles, ...cached]), query),
         error: null,
-        updatedAt: Date.now(),
-        sourceIds: [...new Set([...current.sourceIds, newsCapabilitySourceId(source)])],
-      });
+        updatedAt: this.now(),
+        sourceIds: [...new Set([...entry.state.sourceIds, newsCapabilitySourceId(source)])],
+      };
       changed = true;
     }
     if (changed) {
@@ -304,21 +347,21 @@ export class NewsService {
   }
 
   private rebuildArticlePool(): void {
-    this.articles = dedupeNewsArticles([...this.queryStates.values()].flatMap((state) => state.articles));
+    this.articles = dedupeNewsArticles([...this.queries.values()].flatMap((entry) => entry.state.articles));
   }
 
   private mergeStoryDetail(article: NewsArticle): void {
     let changed = false;
-    for (const [key, state] of this.queryStates) {
+    for (const entry of this.queries.values()) {
       let stateChanged = false;
-      const nextArticles = state.articles.map((existing) => {
+      const nextArticles = entry.state.articles.map((existing) => {
         if (existing.id !== article.id) return existing;
         stateChanged = true;
         changed = true;
         return mergeNewsArticle(existing, article);
       });
       if (stateChanged) {
-        this.queryStates.set(key, { ...state, articles: nextArticles });
+        entry.state = { ...entry.state, articles: nextArticles };
       }
     }
 

package/src/news/hooks.test.tsx

@@ -0,0 +1,64 @@
+import { afterEach, expect, test } from "bun:test";
+import { act, useState } from "react";
+import { testRender } from "../renderers/opentui/test-utils";
+import type { NewsService } from "./aggregator";
+import { setSharedNewsService, useNewsArticles } from "./hooks";
+import type { NewsQueryState } from "./types";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let rerenderHarness: (() => void) | null = null;
+
+function NewsHookHarness() {
+  const [renderCount, setRenderCount] = useState(0);
+  rerenderHarness = () => setRenderCount((current) => current + 1);
+  const state = useNewsArticles({ feed: "latest", limit: 20 });
+  return <text>{state.phase}:{renderCount}</text>;
+}
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => testSetup?.renderer.destroy());
+    testSetup = undefined;
+  }
+  rerenderHarness = null;
+  setSharedNewsService(null);
+});
+
+test("useNewsArticles watches once and unwatches on unmount", async () => {
+  let watchCount = 0;
+  let unwatchCount = 0;
+  const readyState: NewsQueryState = {
+    phase: "ready",
+    articles: [],
+    error: null,
+    updatedAt: 1,
+    sourceIds: [],
+  };
+  const service = {
+    getQueryState: () => readyState,
+    watchQuery: () => {
+      watchCount++;
+      return () => {
+        unwatchCount++;
+      };
+    },
+  } as unknown as NewsService;
+  setSharedNewsService(service);
+
+  testSetup = await testRender(<NewsHookHarness />, { width: 20, height: 1 });
+  await act(async () => testSetup?.renderOnce());
+
+  expect(watchCount).toBe(1);
+  expect(unwatchCount).toBe(0);
+
+  await act(async () => {
+    rerenderHarness?.();
+    await Promise.resolve();
+    await testSetup?.renderOnce();
+  });
+  expect(watchCount).toBe(1);
+
+  await act(async () => testSetup?.renderer.destroy());
+  testSetup = undefined;
+  expect(unwatchCount).toBe(1);
+});

package/src/news/hooks.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useSyncExternalStore } from "react";
+import { useCallback, useSyncExternalStore } from "react";
 import { buildNewsQueryKey, type NewsService } from "./aggregator";
 import type { NewsArticle, NewsQuery, NewsQueryState } from "./types";
 
@@ -8,34 +8,27 @@ export function setSharedNewsService(service: NewsService | null): void {
   sharedService = service;
 }
 
-function idleState(): NewsQueryState {
-  return {
-    phase: "idle",
-    articles: [],
-    error: null,
-    updatedAt: null,
-    sourceIds: [],
-  };
-}
-
-function useNewsServiceVersion(): number {
-  if (!sharedService) return 0;
-  return useSyncExternalStore(
-    (cb) => sharedService!.subscribe(cb),
-    () => sharedService!.getVersion(),
-  );
-}
+const IDLE_NEWS_QUERY_STATE: NewsQueryState = {
+  phase: "idle",
+  articles: [],
+  error: null,
+  updatedAt: null,
+  sourceIds: [],
+};
 
 export function useNewsArticles(query: NewsQuery | null | undefined): NewsQueryState {
+  const service = sharedService;
   const key = query ? buildNewsQueryKey(query) : null;
-  useNewsServiceVersion();
-
-  useEffect(() => {
-    if (!query || !sharedService) return;
-    void sharedService.load(query);
-  }, [key]);
+  const subscribe = useCallback((listener: () => void) => {
+    if (!query || !service) return () => {};
+    return service.watchQuery(query, () => listener());
+  }, [key, service]);
+  const getSnapshot = useCallback(
+    () => query && service ? service.getQueryState(query) : IDLE_NEWS_QUERY_STATE,
+    [key, service],
+  );
 
-  return query && sharedService ? sharedService.getQueryState(query) : idleState();
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
 
 export function useLoadNewsStory(): (storyId: string) => Promise<NewsArticle | null> {

package/src/plugins/builtin/account-management/footer.ts

@@ -3,6 +3,7 @@ import { usePaneFooter, type PaneHint } from "../../../components";
 import type { AccountProfile } from "../../../api-client";
 import { formatPlan, type AccountDraft } from "./model";
 import { t } from "../../../i18n";
+import { useAppLanguage } from "../../../i18n/react";
 
 export function useAccountManagementFooter({
   busy,
@@ -19,9 +20,10 @@ export function useAccountManagementFooter({
   profile: AccountProfile | null;
   saveProfile: () => Promise<void>;
 }) {
+  const language = useAppLanguage();
   const footerHints = useMemo<PaneHint[]>(() => [
     { id: "save", key: "Ctrl+S", label: t("save"), onPress: () => { void saveProfile(); }, disabled: !!busy || !hasSession },
-  ], [busy, hasSession, saveProfile]);
+  ], [busy, hasSession, language, saveProfile]);
 
   usePaneFooter("account-management", () => ({
     info: [
@@ -33,5 +35,5 @@ export function useAccountManagementFooter({
       ] : []),
     ],
     hints: footerHints,
-  }), [draft.profilePublic, footerHints, message, profile]);
+  }), [draft.profilePublic, footerHints, language, message, profile]);
 }

package/src/plugins/builtin/account-management/pane.tsx

@@ -48,15 +48,15 @@ import { useCloudSyncStatus } from "../../../sync/react";
 import { cloudSyncController } from "../../../sync/controller";
 import { setSyncedProfileAnalytics } from "../../../sync/profile-analytics";
 import { t } from "../../../i18n";
+import { useAppLanguage } from "../../../i18n/react";
 import {
   consumeRequestedAccountManagementTab,
   subscribeRequestedAccountManagementTab,
   type AccountManagementTab,
 } from "./navigation";
+import { CLOUD_UPGRADE_URL } from "../shared/cloud-upgrade";
 
 type AccountBusy = "profile" | "password" | "alerts" | "billing" | "delete" | null;
-const CLOUD_UPGRADE_URL = "https://gloom.sh/cloud?upgrade=pro";
-
 const ACCOUNT_TAB_DEFS: Array<{ label: string; value: AccountManagementTab }> = [
   { label: "Profile", value: "profile" },
   { label: "Emails", value: "emails" },
@@ -88,7 +88,8 @@ const ACCOUNT_TAB_FIELD_ORDER: Record<AccountManagementTab, AccountFieldKey[]> =
 };
 
 const PLAN_COMPARISON_ROWS = [
-  { capability: "Market data", free: "Delayed", pro: "Real-time", proTone: "positive" },
+  { capability: "US equities", free: "15m delay", pro: "Real-time", proTone: "positive" },
+  { capability: "Options data", free: "15m delay", pro: "Real-time", proTone: "positive" },
   { capability: "News", free: "12h delay", pro: "Real-time wire", proTone: "positive" },
   { capability: "Cloud sync", free: "Included", pro: "Included", proTone: "neutral" },
   { capability: "X data", free: "No", pro: "Included", proTone: "positive" },
@@ -286,6 +287,7 @@ function PlanComparison({
 }
 
 export function AccountManagementPane({ focused, width, height }: PaneProps) {
+  const language = useAppLanguage();
   const dialog = useDialog();
   const renderer = useRendererHost();
   const isDesktop = useUiHost().kind === "desktop-web";
@@ -335,7 +337,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
   const portfolioHoldingCounts = useMemo(() => countPortfolioHoldings(tickers), [tickers]);
   const portfolioChoices = useMemo(
     () => buildPortfolioChoices(portfolios, portfolioHoldingCounts),
-    [portfolioHoldingCounts, portfolios],
+    [language, portfolioHoldingCounts, portfolios],
   );
   const selectedAnalyticsPortfolio = useMemo(
     () => portfolios.find((portfolio) => portfolio.id === draft.sharedPortfolioId) ?? null,
@@ -419,6 +421,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
     [
       beta,
       draft.sharedPortfolioId,
+      language,
       portfolioTickers,
       selectedAnalyticsPortfolio,
       oneYearReturn,
@@ -448,6 +451,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
     [
       draft.profilePublic,
       draft.sharedPortfolioId,
+      language,
       profile,
       selectedAnalyticsPortfolio,
       syncStatus.phase,
@@ -469,6 +473,7 @@ export function AccountManagementPane({ focused, width, height }: PaneProps) {
   }, [
     draft.profilePublic,
     draft.sharedPortfolioId,
+    language,
     profile,
     syncStatus.phase,
   ]);

package/src/plugins/builtin/ai/agent-history.ts

@@ -52,18 +52,20 @@ function optionalString(value: unknown): string | undefined {
 function normalizeAssistantContent(value: unknown): AiAgentAssistantContent | null {
   if (!isRecord(value)) return null;
   if (value.type === "text" && typeof value.text === "string") {
+    const textSignature = optionalString(value.textSignature);
     return {
       type: "text",
       text: value.text,
-      ...(optionalString(value.textSignature) ? { textSignature: value.textSignature } : {}),
+      ...(textSignature ? { textSignature } : {}),
     };
   }
   if (value.type === "thinking" && typeof value.thinking === "string") {
+    const thinkingSignature = optionalString(value.thinkingSignature);
     return {
       type: "thinking",
       thinking: value.thinking,
-      ...(optionalString(value.thinkingSignature)
-        ? { thinkingSignature: value.thinkingSignature }
+      ...(thinkingSignature
+        ? { thinkingSignature }
         : {}),
       ...(typeof value.redacted === "boolean" ? { redacted: value.redacted } : {}),
     };
@@ -74,13 +76,14 @@ function normalizeAssistantContent(value: unknown): AiAgentAssistantContent | nu
     && typeof value.name === "string"
     && isRecord(value.arguments)
   ) {
+    const thoughtSignature = optionalString(value.thoughtSignature);
     return {
       type: "toolCall",
       id: value.id,
       name: value.name,
       arguments: { ...value.arguments },
-      ...(optionalString(value.thoughtSignature)
-        ? { thoughtSignature: value.thoughtSignature }
+      ...(thoughtSignature
+        ? { thoughtSignature }
         : {}),
     };
   }
@@ -91,14 +94,15 @@ function normalizeToolResultContent(value: unknown): AiAgentTextContent | null {
   if (!isRecord(value) || value.type !== "text" || typeof value.text !== "string") {
     return null;
   }
+  const textSignature = optionalString(value.textSignature);
   return {
     type: "text",
     text: value.text,
-    ...(optionalString(value.textSignature) ? { textSignature: value.textSignature } : {}),
+    ...(textSignature ? { textSignature } : {}),
   };
 }
 
-export function normalizeAiAgentHistoryMessage(value: unknown): AiAgentHistoryMessage | null {
+function normalizeAiAgentHistoryMessage(value: unknown): AiAgentHistoryMessage | null {
   if (!isRecord(value)) return null;
   if (value.role === "user" && typeof value.content === "string") {
     return { role: "user", content: value.content };

package/src/plugins/builtin/ai/ask-ai-detail-tab.tsx

@@ -16,8 +16,6 @@ import { buildTickerAiContext } from "./ticker-context";
 import {
   migrateLegacyAiProviderId,
   resolveDefaultAiProviderId,
-  __setDetectedProvidersForTests,
-  type AiProvider,
 } from "./providers";
 import { runAiPrompt, type AiConversationMessage } from "./runner";
 import { isAiProviderReady, resolveReadyAiRunnerDefault } from "./runner-selection";
@@ -47,9 +45,6 @@ const LEGACY_HISTORY_PROVIDER_IDS: Readonly<Record<string, string>> = {
   google: "gemini",
 };
 
-export { __setDetectedProvidersForTests };
-export type { AiProvider };
-
 function sameMessages(left: readonly ChatMessage[], right: readonly ChatMessage[]): boolean {
   return left.length === right.length && left.every((message, index) => {
     const other = right[index];

package/src/plugins/builtin/ai/ask-ai.test.tsx

@@ -12,9 +12,8 @@ import {
   AskAiResearchTab as AskAiTab,
   __resetAskAiHistoryForTests,
   __setAskAiHistoryForTests,
-  __setDetectedProvidersForTests,
-  type AiProvider,
 } from "./ask-ai-detail-tab";
+import { setDetectedProviders, type AiProvider } from "./providers";
 import { setAiRunHost, setAiRuntimeCatalog, type AiRunHost } from "./runner";
 import type { TickerRecord } from "../../../types/ticker";
 
@@ -93,7 +92,7 @@ async function flushFrame() {
 }
 
 function setProviders(providers: AiProvider[]) {
-  __setDetectedProvidersForTests(providers);
+  setDetectedProviders(providers);
 }
 
 function readyProvider(id: AiProvider["id"] = "anthropic"): AiProvider {
@@ -113,7 +112,7 @@ afterEach(async () => {
     });
     testSetup = undefined;
   }
-  __setDetectedProvidersForTests(null);
+  setDetectedProviders(null);
   __resetAskAiHistoryForTests();
   setAiRunHost(null);
   setAiRuntimeCatalog({ providers: [], accounts: [], models: [] });

package/src/plugins/builtin/ai/index.test.ts

@@ -5,7 +5,7 @@ import { aiPlugin } from "./index";
 import {
   AI_PROVIDER_IDS,
   getAiProviderDefinition,
-  __setDetectedProvidersForTests,
+  setDetectedProviders,
   type AiProviderId,
 } from "./providers";
 import {
@@ -109,7 +109,7 @@ function setupPlugin(config = createDefaultConfig("/tmp/gloomberb-ai-plugin")) {
 }
 
 afterEach(() => {
-  __setDetectedProvidersForTests(null);
+  setDetectedProviders(null);
   setAiRunHost(null);
   setAiRuntimeCatalog({ providers: [], accounts: [], models: [] });
 });