fix(voice): let a failed STT probe recover on a later mount

The app QueryClient sets retryOnMount: false and retry: 1, and
refetchOnWindowFocus only refetches stale queries — which an infinite
staleTime never becomes. So one transient failure cached the error for
the life of the client and hid the mic until a full page reload.

The effect this replaced refetched on every run, so retryOnMount: true
restores parity: no refetch after success, a retry per mount after
failure. Test asserts recovery under the app's real query defaults and
fails without the override.

Author: waleedlatif1

apps/sim/hooks/queries/voice.test.tsx

@@ -16,9 +16,11 @@ import { useVoiceSettings, voiceSettingsKeys } from '@/hooks/queries/voice'
 /** Trees rendered by a test, torn down in afterEach so observers do not leak across tests. */
 const mountedRoots: Root[] = []
 
-function renderHookWithClient<T>(useHook: () => T): { getResult: () => T } {
+function renderHookWithClient<T>(
+  useHook: () => T,
+  queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+): { getResult: () => T } {
   ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
-  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
   const container = document.createElement('div')
   const root: Root = createRoot(container)
   mountedRoots.push(root)
@@ -102,6 +104,30 @@ describe('useVoiceSettings', () => {
     expect(getResult().isError).toBe(true)
   })
 
+  /**
+   * The app's QueryClient sets `retryOnMount: false`, and an infinite staleTime
+   * never goes stale, so without an explicit override a single transient
+   * failure would cache the error for the life of the client and keep the mic
+   * hidden until a full reload.
+   */
+  it('recovers on a later mount after a failed probe, under the app query defaults', async () => {
+    const appDefaults = new QueryClient({
+      defaultOptions: { queries: { retry: false, retryOnMount: false, staleTime: 30 * 1000 } },
+    })
+
+    mockRequestJson.mockRejectedValueOnce(new Error('offline'))
+    renderHookWithClient(() => useVoiceSettings(), appDefaults)
+    await flush()
+    expect(mockRequestJson).toHaveBeenCalledTimes(1)
+
+    mockRequestJson.mockResolvedValue({ sttAvailable: true })
+    const second = renderHookWithClient(() => useVoiceSettings(), appDefaults)
+    await flush()
+
+    expect(mockRequestJson).toHaveBeenCalledTimes(2)
+    expect(second.getResult().data).toBe(true)
+  })
+
   it('dedupes across simultaneous consumers', async () => {
     mockRequestJson.mockResolvedValue({ sttAvailable: true })
 

apps/sim/hooks/queries/voice.ts

@@ -31,12 +31,19 @@ async function fetchSttAvailable(signal?: AbortSignal): Promise<boolean> {
  * Deliberately no `initialData`: consumers derive their support flag from
  * `data === true`, so the first client render matches the server render
  * (unavailable) until the fetch resolves.
+ *
+ * `retryOnMount` overrides the app default of `false`. An infinite staleTime
+ * never goes stale, and `refetchOnWindowFocus` only refetches stale queries, so
+ * without this a single transient failure would cache the error for the life of
+ * the QueryClient and hide the mic until a full reload. Retrying per mount
+ * matches the effect this replaced, which refetched every time it ran.
  */
 export function useVoiceSettings(options?: { enabled?: boolean }) {
   return useQuery({
     queryKey: voiceSettingsKeys.settings(),
     queryFn: ({ signal }) => fetchSttAvailable(signal),
     enabled: options?.enabled ?? true,
     staleTime: VOICE_SETTINGS_STALE_TIME,
+    retryOnMount: true,
   })
 }