@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

package/dist/src/ui/hooks/useQuotaAndFallback.test.js

@@ -5,10 +5,22 @@
  */
 import { vi, describe, it, expect, beforeEach, afterEach, } from 'vitest';
 import { act } from 'react';
-import { renderHook } from '../../test-utils/render.js';
-import { UserTierId, AuthType, TerminalQuotaError, makeFakeConfig, RetryableQuotaError, PREVIEW_GEMINI_MODEL, ModelNotFoundError, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL, } from '@google/gemini-cli-core';
+import { renderHook, mockSettings } from '../../test-utils/render.js';
+import { waitFor } from '../../test-utils/async.js';
+import { UserTierId, AuthType, TerminalQuotaError, makeFakeConfig, RetryableQuotaError, PREVIEW_GEMINI_MODEL, ModelNotFoundError, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL, getG1CreditBalance, shouldAutoUseCredits, shouldShowOverageMenu, shouldShowEmptyWalletMenu, logBillingEvent, G1_CREDIT_TYPE, } from '@google/gemini-cli-core';
 import { useQuotaAndFallback } from './useQuotaAndFallback.js';
 import { MessageType } from '../types.js';
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getG1CreditBalance: vi.fn(),
+        shouldAutoUseCredits: vi.fn(),
+        shouldShowOverageMenu: vi.fn(),
+        shouldShowEmptyWalletMenu: vi.fn(),
+        logBillingEvent: vi.fn(),
+    };
+});
 describe('useQuotaAndFallback', () => {
     let mockConfig;
     let mockHistoryManager;
@@ -42,51 +54,104 @@ describe('useQuotaAndFallback', () => {
         vi.spyOn(mockConfig, 'setModel');
         vi.spyOn(mockConfig, 'setActiveModel');
         vi.spyOn(mockConfig, 'activateFallbackMode');
+        // Mock billing utility functions
+        vi.mocked(getG1CreditBalance).mockReturnValue(0);
+        vi.mocked(shouldAutoUseCredits).mockReturnValue(false);
+        vi.mocked(shouldShowOverageMenu).mockReturnValue(false);
+        vi.mocked(shouldShowEmptyWalletMenu).mockReturnValue(false);
     });
     afterEach(() => {
-        vi.clearAllMocks();
+        vi.restoreAllMocks();
     });
-    it('should register a fallback handler on initialization', () => {
-        renderHook(() => useQuotaAndFallback({
+    it('should register a fallback handler on initialization', async () => {
+        await renderHook(() => useQuotaAndFallback({
             config: mockConfig,
             historyManager: mockHistoryManager,
             userTier: UserTierId.FREE,
             setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
             onShowAuthSelection: mockOnShowAuthSelection,
+            paidTier: null,
+            settings: mockSettings,
         }));
         expect(setFallbackHandlerSpy).toHaveBeenCalledTimes(1);
         expect(setFallbackHandlerSpy.mock.calls[0][0]).toBeInstanceOf(Function);
     });
     describe('Fallback Handler Logic', () => {
-        // Helper function to render the hook and extract the registered handler
-        const getRegisteredHandler = () => {
-            renderHook(() => useQuotaAndFallback({
+        it('should show fallback dialog but omit switch to API key message if authType is not LOGIN_WITH_GOOGLE', async () => {
+            // Override the default mock from beforeEach for this specific test
+            vi.spyOn(mockConfig, 'getContentGeneratorConfig').mockReturnValue({
+                authType: AuthType.USE_GEMINI,
+            });
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
-            return setFallbackHandlerSpy.mock.calls[0][0];
-        };
-        it('should return null and take no action if authType is not LOGIN_WITH_GOOGLE', async () => {
-            // Override the default mock from beforeEach for this specific test
-            vi.spyOn(mockConfig, 'getContentGeneratorConfig').mockReturnValue({
-                authType: AuthType.USE_GEMINI,
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            const error = new TerminalQuotaError('pro quota', mockGoogleApiError, 1000 * 60 * 5);
+            act(() => {
+                void handler('gemini-pro', 'gemini-flash', error);
             });
-            const handler = getRegisteredHandler();
-            const result = await handler('gemini-pro', 'gemini-flash', new Error());
-            expect(result).toBeNull();
-            expect(mockHistoryManager.addItem).not.toHaveBeenCalled();
+            expect(result.current.proQuotaRequest).not.toBeNull();
+            expect(result.current.proQuotaRequest?.message).not.toContain('/auth to switch to API key.');
+        });
+        it('should auto-retry transient capacity failures in low verbosity mode', async () => {
+            const { result } = await renderHook(() => useQuotaAndFallback({
+                config: mockConfig,
+                historyManager: mockHistoryManager,
+                userTier: UserTierId.FREE,
+                setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
+                errorVerbosity: 'low',
+            }));
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            const intent = await handler('gemini-pro', 'gemini-flash', new RetryableQuotaError('retryable quota', mockGoogleApiError, 5));
+            expect(intent).toBe('retry_once');
+            expect(result.current.proQuotaRequest).toBeNull();
+            expect(mockSetModelSwitchedFromQuotaError).not.toHaveBeenCalledWith(true);
+            expect(mockConfig.setQuotaErrorOccurred).not.toHaveBeenCalledWith(true);
+        });
+        it('should still prompt for terminal quota in low verbosity mode', async () => {
+            const { result } = await renderHook(() => useQuotaAndFallback({
+                config: mockConfig,
+                historyManager: mockHistoryManager,
+                userTier: UserTierId.FREE,
+                setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
+                errorVerbosity: 'low',
+            }));
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            let promise;
+            act(() => {
+                promise = handler('gemini-pro', 'gemini-flash', new TerminalQuotaError('pro quota', mockGoogleApiError));
+            });
+            expect(result.current.proQuotaRequest).not.toBeNull();
+            act(() => {
+                result.current.handleProQuotaChoice('retry_later');
+            });
+            await promise;
         });
         describe('Interactive Fallback', () => {
             it('should set an interactive request for a terminal quota error', async () => {
-                const { result } = renderHook(() => useQuotaAndFallback({
+                const { result } = await renderHook(() => useQuotaAndFallback({
                     config: mockConfig,
                     historyManager: mockHistoryManager,
                     userTier: UserTierId.FREE,
                     setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                     onShowAuthSelection: mockOnShowAuthSelection,
+                    paidTier: null,
+                    settings: mockSettings,
                 }));
                 const handler = setFallbackHandlerSpy.mock
                     .calls[0][0];
@@ -119,12 +184,14 @@ describe('useQuotaAndFallback', () => {
                 expect(mockHistoryManager.addItem).toHaveBeenCalledTimes(1);
             });
             it('should show the model name for a terminal quota error on a non-pro model', async () => {
-                const { result } = renderHook(() => useQuotaAndFallback({
+                const { result } = await renderHook(() => useQuotaAndFallback({
                     config: mockConfig,
                     historyManager: mockHistoryManager,
                     userTier: UserTierId.FREE,
                     setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                     onShowAuthSelection: mockOnShowAuthSelection,
+                    paidTier: null,
+                    settings: mockSettings,
                 }));
                 const handler = setFallbackHandlerSpy.mock
                     .calls[0][0];
@@ -145,12 +212,14 @@ describe('useQuotaAndFallback', () => {
                 await promise;
             });
             it('should handle terminal quota error without retry delay', async () => {
-                const { result } = renderHook(() => useQuotaAndFallback({
+                const { result } = await renderHook(() => useQuotaAndFallback({
                     config: mockConfig,
                     historyManager: mockHistoryManager,
                     userTier: UserTierId.FREE,
                     setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                     onShowAuthSelection: mockOnShowAuthSelection,
+                    paidTier: null,
+                    settings: mockSettings,
                 }));
                 const handler = setFallbackHandlerSpy.mock
                     .calls[0][0];
@@ -169,12 +238,14 @@ describe('useQuotaAndFallback', () => {
                 await promise;
             });
             it('should handle race conditions by stopping subsequent requests', async () => {
-                const { result } = renderHook(() => useQuotaAndFallback({
+                const { result } = await renderHook(() => useQuotaAndFallback({
                     config: mockConfig,
                     historyManager: mockHistoryManager,
                     userTier: UserTierId.FREE,
                     setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                     onShowAuthSelection: mockOnShowAuthSelection,
+                    paidTier: null,
+                    settings: mockSettings,
                 }));
                 const handler = setFallbackHandlerSpy.mock
                     .calls[0][0];
@@ -211,12 +282,14 @@ describe('useQuotaAndFallback', () => {
             ];
             for (const { description, error } of testCases) {
                 it(`should handle ${description} correctly`, async () => {
-                    const { result } = renderHook(() => useQuotaAndFallback({
+                    const { result } = await renderHook(() => useQuotaAndFallback({
                         config: mockConfig,
                         historyManager: mockHistoryManager,
                         userTier: UserTierId.FREE,
                         setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                         onShowAuthSelection: mockOnShowAuthSelection,
+                        paidTier: null,
+                        settings: mockSettings,
                     }));
                     const handler = setFallbackHandlerSpy.mock
                         .calls[0][0];
@@ -253,12 +326,14 @@ describe('useQuotaAndFallback', () => {
                 });
             }
             it('should handle ModelNotFoundError correctly', async () => {
-                const { result } = renderHook(() => useQuotaAndFallback({
+                const { result } = await renderHook(() => useQuotaAndFallback({
                     config: mockConfig,
                     historyManager: mockHistoryManager,
                     userTier: UserTierId.FREE,
                     setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                     onShowAuthSelection: mockOnShowAuthSelection,
+                    paidTier: null,
+                    settings: mockSettings,
                 }));
                 const handler = setFallbackHandlerSpy.mock
                     .calls[0][0];
@@ -284,16 +359,211 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
                 expect(intent).toBe('retry_always');
                 expect(result.current.proQuotaRequest).toBeNull();
             });
+            it('should handle ModelNotFoundError with invalid model correctly', async () => {
+                const { result } = await renderHook(() => useQuotaAndFallback({
+                    config: mockConfig,
+                    historyManager: mockHistoryManager,
+                    userTier: UserTierId.FREE,
+                    setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                    onShowAuthSelection: mockOnShowAuthSelection,
+                    paidTier: null,
+                    settings: mockSettings,
+                }));
+                const handler = setFallbackHandlerSpy.mock
+                    .calls[0][0];
+                let promise;
+                const error = new ModelNotFoundError('model not found', 404);
+                act(() => {
+                    promise = handler('invalid-model', 'gemini-2.5-pro', error);
+                });
+                const request = result.current.proQuotaRequest;
+                expect(request).not.toBeNull();
+                expect(request?.failedModel).toBe('invalid-model');
+                expect(request?.isModelNotFoundError).toBe(true);
+                const message = request.message;
+                expect(message).toBe(`Model "invalid-model" was not found or is invalid.
+/model to switch models.`);
+                act(() => {
+                    result.current.handleProQuotaChoice('retry_always');
+                });
+                const intent = await promise;
+                expect(intent).toBe('retry_always');
+            });
+        });
+    });
+    describe('G1 AI Credits Flow', () => {
+        const mockPaidTier = {
+            id: UserTierId.STANDARD,
+            userTier: UserTierId.STANDARD,
+            availableCredits: [
+                {
+                    creditType: G1_CREDIT_TYPE,
+                    creditAmount: '100',
+                },
+            ],
+        };
+        beforeEach(() => {
+            // Default to having credits
+            vi.mocked(getG1CreditBalance).mockReturnValue(100);
+        });
+        it('should fall through to ProQuotaDialog if credits are already active (strategy=always)', async () => {
+            // If shouldAutoUseCredits is true, credits were already active on the
+            // failed request — they didn't help. Fall through to ProQuotaDialog
+            // so the user can downgrade to Flash instead of retrying infinitely.
+            vi.mocked(shouldAutoUseCredits).mockReturnValue(true);
+            const { result } = await renderHook(() => useQuotaAndFallback({
+                config: mockConfig,
+                historyManager: mockHistoryManager,
+                userTier: UserTierId.STANDARD,
+                setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: mockPaidTier,
+                settings: mockSettings,
+            }));
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            const error = new TerminalQuotaError('pro quota', mockGoogleApiError, 1000 * 60 * 5);
+            const intentPromise = handler(PREVIEW_GEMINI_MODEL, 'gemini-flash', error);
+            // Since credits didn't help, the ProQuotaDialog should be shown
+            await waitFor(() => {
+                expect(result.current.proQuotaRequest).not.toBeNull();
+            });
+            // Resolve it to verify the flow completes
+            act(() => {
+                result.current.handleProQuotaChoice('stop');
+            });
+            const intent = await intentPromise;
+            expect(intent).toBe('stop');
+        });
+        it('should show overage menu if balance > 0 and not auto-using', async () => {
+            vi.mocked(shouldAutoUseCredits).mockReturnValue(false);
+            vi.mocked(shouldShowOverageMenu).mockReturnValue(true);
+            const { result } = await renderHook(() => useQuotaAndFallback({
+                config: mockConfig,
+                historyManager: mockHistoryManager,
+                userTier: UserTierId.STANDARD,
+                setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: mockPaidTier,
+                settings: mockSettings,
+            }));
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            let promise;
+            act(() => {
+                promise = handler(PREVIEW_GEMINI_MODEL, 'gemini-flash', new TerminalQuotaError('pro quota', mockGoogleApiError));
+            });
+            expect(result.current.overageMenuRequest).not.toBeNull();
+            expect(result.current.overageMenuRequest?.creditBalance).toBe(100);
+            expect(logBillingEvent).toHaveBeenCalled();
+            // Simulate choosing "Use Credits"
+            await act(async () => {
+                result.current.handleOverageMenuChoice('use_credits');
+                await promise;
+            });
+            const intent = await promise;
+            expect(intent).toBe('retry_with_credits');
+        });
+        it('should handle use_fallback from overage menu', async () => {
+            vi.mocked(shouldAutoUseCredits).mockReturnValue(false);
+            vi.mocked(shouldShowOverageMenu).mockReturnValue(true);
+            const { result } = await renderHook(() => useQuotaAndFallback({
+                config: mockConfig,
+                historyManager: mockHistoryManager,
+                userTier: UserTierId.STANDARD,
+                setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: mockPaidTier,
+                settings: mockSettings,
+            }));
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            let promise;
+            act(() => {
+                promise = handler(PREVIEW_GEMINI_MODEL, 'gemini-flash', new TerminalQuotaError('pro quota', mockGoogleApiError));
+            });
+            // Simulate choosing "Switch to fallback"
+            await act(async () => {
+                result.current.handleOverageMenuChoice('use_fallback');
+                await promise;
+            });
+            const intent = await promise;
+            expect(intent).toBe('retry_always');
+        });
+        it('should show empty wallet menu if balance is 0', async () => {
+            vi.mocked(getG1CreditBalance).mockReturnValue(0);
+            vi.mocked(shouldAutoUseCredits).mockReturnValue(false);
+            vi.mocked(shouldShowOverageMenu).mockReturnValue(false);
+            vi.mocked(shouldShowEmptyWalletMenu).mockReturnValue(true);
+            const { result } = await renderHook(() => useQuotaAndFallback({
+                config: mockConfig,
+                historyManager: mockHistoryManager,
+                userTier: UserTierId.STANDARD,
+                setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: { ...mockPaidTier, availableCredits: [] },
+                settings: mockSettings,
+            }));
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            let promise;
+            act(() => {
+                promise = handler(PREVIEW_GEMINI_MODEL, 'gemini-flash', new TerminalQuotaError('pro quota', mockGoogleApiError));
+            });
+            expect(result.current.emptyWalletRequest).not.toBeNull();
+            expect(logBillingEvent).toHaveBeenCalled();
+            // Simulate choosing "Stop"
+            await act(async () => {
+                result.current.handleEmptyWalletChoice('stop');
+                await promise;
+            });
+            const intent = await promise;
+            expect(intent).toBe('stop');
+        });
+        it('should add info message to history when get_credits is selected', async () => {
+            vi.mocked(getG1CreditBalance).mockReturnValue(0);
+            vi.mocked(shouldAutoUseCredits).mockReturnValue(false);
+            vi.mocked(shouldShowOverageMenu).mockReturnValue(false);
+            vi.mocked(shouldShowEmptyWalletMenu).mockReturnValue(true);
+            const { result } = await renderHook(() => useQuotaAndFallback({
+                config: mockConfig,
+                historyManager: mockHistoryManager,
+                userTier: UserTierId.STANDARD,
+                setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
+                onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: { ...mockPaidTier, availableCredits: [] },
+                settings: mockSettings,
+            }));
+            const handler = setFallbackHandlerSpy.mock
+                .calls[0][0];
+            let promise;
+            act(() => {
+                promise = handler(PREVIEW_GEMINI_MODEL, 'gemini-flash', new TerminalQuotaError('pro quota', mockGoogleApiError));
+            });
+            expect(result.current.emptyWalletRequest).not.toBeNull();
+            // Simulate choosing "Get AI Credits"
+            await act(async () => {
+                result.current.handleEmptyWalletChoice('get_credits');
+                await promise;
+            });
+            const intent = await promise;
+            expect(intent).toBe('stop');
+            expect(mockHistoryManager.addItem).toHaveBeenCalledWith(expect.objectContaining({
+                type: MessageType.INFO,
+                text: expect.stringContaining('few minutes'),
+            }), expect.any(Number));
         });
     });
     describe('handleProQuotaChoice', () => {
-        it('should do nothing if there is no pending pro quota request', () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+        it('should do nothing if there is no pending pro quota request', async () => {
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             act(() => {
                 result.current.handleProQuotaChoice('retry_later');
@@ -301,12 +571,14 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(mockHistoryManager.addItem).not.toHaveBeenCalled();
         });
         it('should resolve intent to "retry_later"', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setFallbackHandlerSpy.mock
                 .calls[0][0];
@@ -322,12 +594,14 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(result.current.proQuotaRequest).toBeNull();
         });
         it('should resolve intent to "retry_always" and add info message on continue', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setFallbackHandlerSpy.mock
                 .calls[0][0];
@@ -351,12 +625,14 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(lastCall.text).toContain('Switched to fallback model gemini-flash');
         });
         it('should show a special message when falling back from the preview model', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setFallbackHandlerSpy.mock
                 .calls[0][0];
@@ -374,12 +650,14 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(lastCall.text).toContain(`Switched to fallback model gemini-2.5-pro`);
         });
         it('should show a special message when falling back from the preview model, but do not show periodical check message for flash model fallback', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setFallbackHandlerSpy.mock
                 .calls[0][0];
@@ -402,24 +680,28 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
         beforeEach(() => {
             setValidationHandlerSpy = vi.spyOn(mockConfig, 'setValidationHandler');
         });
-        it('should register a validation handler on initialization', () => {
-            renderHook(() => useQuotaAndFallback({
+        it('should register a validation handler on initialization', async () => {
+            await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             expect(setValidationHandlerSpy).toHaveBeenCalledTimes(1);
             expect(setValidationHandlerSpy.mock.calls[0][0]).toBeInstanceOf(Function);
         });
         it('should set a validation request when handler is called', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setValidationHandlerSpy.mock.calls[0][0];
             let promise;
@@ -440,12 +722,14 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(result.current.validationRequest).toBeNull();
         });
         it('should handle race conditions by returning cancel for subsequent requests', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setValidationHandlerSpy.mock.calls[0][0];
             let promise1;
@@ -470,12 +754,14 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(result.current.validationRequest).toBeNull();
         });
         it('should call onShowAuthSelection when change_auth is chosen', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setValidationHandlerSpy.mock.calls[0][0];
             let promise;
@@ -490,12 +776,14 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(mockOnShowAuthSelection).toHaveBeenCalledTimes(1);
         });
         it('should call onShowAuthSelection when cancel is chosen', async () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             const handler = setValidationHandlerSpy.mock.calls[0][0];
             let promise;
@@ -509,13 +797,15 @@ Your admin might have disabled the access. Contact them to enable the Preview Re
             expect(intent).toBe('cancel');
             expect(mockOnShowAuthSelection).toHaveBeenCalledTimes(1);
         });
-        it('should do nothing if handleValidationChoice is called without pending request', () => {
-            const { result } = renderHook(() => useQuotaAndFallback({
+        it('should do nothing if handleValidationChoice is called without pending request', async () => {
+            const { result } = await renderHook(() => useQuotaAndFallback({
                 config: mockConfig,
                 historyManager: mockHistoryManager,
                 userTier: UserTierId.FREE,
                 setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
                 onShowAuthSelection: mockOnShowAuthSelection,
+                paidTier: null,
+                settings: mockSettings,
             }));
             act(() => {
                 result.current.handleValidationChoice('verify');