@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/hooks/usePhraseCycler.js

@@ -0,0 +1,141 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useRef } from 'react';
+import { INFORMATIVE_TIPS } from '../constants/tips.js';
+import { WITTY_LOADING_PHRASES } from '../constants/wittyPhrases.js';
+export const PHRASE_CHANGE_INTERVAL_MS = 10000;
+export const WITTY_PHRASE_CHANGE_INTERVAL_MS = 5000;
+export const INTERACTIVE_SHELL_WAITING_PHRASE = '! Shell awaiting input (Tab to focus)';
+/**
+ * Custom hook to manage cycling through loading phrases.
+ * @param isActive Whether the phrase cycling should be active.
+ * @param isWaiting Whether to show a specific waiting phrase.
+ * @param shouldShowFocusHint Whether to show the shell focus hint.
+ * @param showTips Whether to show informative tips.
+ * @param showWit Whether to show witty phrases.
+ * @param customPhrases Optional list of custom phrases to use instead of built-in witty phrases.
+ * @param maxLength Optional maximum length for the selected phrase.
+ * @returns The current loading phrase.
+ */
+export const usePhraseCycler = (isActive, isWaiting, shouldShowFocusHint, showTips = true, showWit = true, customPhrases, maxLength) => {
+    const [currentTipState, setCurrentTipState] = useState(undefined);
+    const [currentWittyPhraseState, setCurrentWittyPhraseState] = useState(undefined);
+    const tipIntervalRef = useRef(null);
+    const wittyIntervalRef = useRef(null);
+    const lastTipChangeTimeRef = useRef(0);
+    const lastWittyChangeTimeRef = useRef(0);
+    const lastSelectedTipRef = useRef(undefined);
+    const lastSelectedWittyPhraseRef = useRef(undefined);
+    const MIN_TIP_DISPLAY_TIME_MS = 10000;
+    const MIN_WIT_DISPLAY_TIME_MS = 5000;
+    useEffect(() => {
+        // Always clear on re-run
+        const clearTimers = () => {
+            if (tipIntervalRef.current) {
+                clearInterval(tipIntervalRef.current);
+                tipIntervalRef.current = null;
+            }
+            if (wittyIntervalRef.current) {
+                clearInterval(wittyIntervalRef.current);
+                wittyIntervalRef.current = null;
+            }
+        };
+        clearTimers();
+        if (shouldShowFocusHint || isWaiting) {
+            // These are handled by the return value directly for immediate feedback
+            return clearTimers;
+        }
+        if (!isActive || (!showTips && !showWit)) {
+            return clearTimers;
+        }
+        const wittyPhrasesList = customPhrases && customPhrases.length > 0
+            ? customPhrases
+            : WITTY_LOADING_PHRASES;
+        const setRandomTip = (force = false) => {
+            if (!showTips) {
+                setCurrentTipState(undefined);
+                lastSelectedTipRef.current = undefined;
+                return;
+            }
+            const now = Date.now();
+            if (!force &&
+                now - lastTipChangeTimeRef.current < MIN_TIP_DISPLAY_TIME_MS &&
+                lastSelectedTipRef.current) {
+                setCurrentTipState(lastSelectedTipRef.current);
+                return;
+            }
+            const filteredTips = maxLength !== undefined
+                ? INFORMATIVE_TIPS.filter((p) => p.length <= maxLength)
+                : INFORMATIVE_TIPS;
+            if (filteredTips.length > 0) {
+                // codeql[js/insecure-randomness] false positive: used for non-sensitive UI flavor text (tips)
+                const selected = filteredTips[Math.floor(Math.random() * filteredTips.length)];
+                setCurrentTipState(selected);
+                lastSelectedTipRef.current = selected;
+                lastTipChangeTimeRef.current = now;
+            }
+        };
+        const setRandomWitty = (force = false) => {
+            if (!showWit) {
+                setCurrentWittyPhraseState(undefined);
+                lastSelectedWittyPhraseRef.current = undefined;
+                return;
+            }
+            const now = Date.now();
+            if (!force &&
+                now - lastWittyChangeTimeRef.current < MIN_WIT_DISPLAY_TIME_MS &&
+                lastSelectedWittyPhraseRef.current) {
+                setCurrentWittyPhraseState(lastSelectedWittyPhraseRef.current);
+                return;
+            }
+            const filteredWitty = maxLength !== undefined
+                ? wittyPhrasesList.filter((p) => p.length <= maxLength)
+                : wittyPhrasesList;
+            if (filteredWitty.length > 0) {
+                // codeql[js/insecure-randomness] false positive: used for non-sensitive UI flavor text (witty phrases)
+                const selected = filteredWitty[Math.floor(Math.random() * filteredWitty.length)];
+                setCurrentWittyPhraseState(selected);
+                lastSelectedWittyPhraseRef.current = selected;
+                lastWittyChangeTimeRef.current = now;
+            }
+        };
+        // Select initial random phrases or resume previous ones
+        setRandomTip(false);
+        setRandomWitty(false);
+        if (showTips) {
+            tipIntervalRef.current = setInterval(() => {
+                setRandomTip(true);
+            }, PHRASE_CHANGE_INTERVAL_MS);
+        }
+        if (showWit) {
+            wittyIntervalRef.current = setInterval(() => {
+                setRandomWitty(true);
+            }, WITTY_PHRASE_CHANGE_INTERVAL_MS);
+        }
+        return clearTimers;
+    }, [
+        isActive,
+        isWaiting,
+        shouldShowFocusHint,
+        showTips,
+        showWit,
+        customPhrases,
+        maxLength,
+    ]);
+    let currentTip = undefined;
+    let currentWittyPhrase = undefined;
+    if (shouldShowFocusHint) {
+        currentTip = INTERACTIVE_SHELL_WAITING_PHRASE;
+    }
+    else if (isWaiting) {
+        currentTip = 'Waiting for user confirmation...';
+    }
+    else if (isActive) {
+        currentTip = currentTipState;
+        currentWittyPhrase = currentWittyPhraseState;
+    }
+    return { currentTip, currentWittyPhrase };
+};

package/dist/ui/hooks/usePrivacySettings.js

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useCallback } from 'react';
+import { UserTierId, getCodeAssistServer, debugLogger, } from '@google/gemini-cli-core';
+export const usePrivacySettings = (config) => {
+    const [privacyState, setPrivacyState] = useState({
+        isLoading: true,
+    });
+    useEffect(() => {
+        const fetchInitialState = async () => {
+            setPrivacyState({
+                isLoading: true,
+            });
+            try {
+                const server = getCodeAssistServerOrFail(config);
+                const tier = server.userTier;
+                if (tier === undefined) {
+                    throw new Error('Could not determine user tier.');
+                }
+                if (tier !== UserTierId.FREE) {
+                    // We don't need to fetch opt-out info since non-free tier
+                    // data gathering is already worked out some other way.
+                    setPrivacyState({
+                        isLoading: false,
+                        isFreeTier: false,
+                    });
+                    return;
+                }
+                const optIn = await getRemoteDataCollectionOptIn(server);
+                setPrivacyState({
+                    isLoading: false,
+                    isFreeTier: true,
+                    dataCollectionOptIn: optIn,
+                });
+            }
+            catch (e) {
+                setPrivacyState({
+                    isLoading: false,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        fetchInitialState();
+    }, [config]);
+    const updateDataCollectionOptIn = useCallback(async (optIn) => {
+        try {
+            const server = getCodeAssistServerOrFail(config);
+            const updatedOptIn = await setRemoteDataCollectionOptIn(server, optIn);
+            setPrivacyState({
+                isLoading: false,
+                isFreeTier: true,
+                dataCollectionOptIn: updatedOptIn,
+            });
+        }
+        catch (e) {
+            setPrivacyState({
+                isLoading: false,
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }, [config]);
+    return {
+        privacyState,
+        updateDataCollectionOptIn,
+    };
+};
+function getCodeAssistServerOrFail(config) {
+    const server = getCodeAssistServer(config);
+    if (server === undefined) {
+        throw new Error('Oauth not being used');
+    }
+    else if (server.projectId === undefined) {
+        throw new Error('CodeAssist server is missing a project ID');
+    }
+    return server;
+}
+async function getRemoteDataCollectionOptIn(server) {
+    try {
+        const resp = await server.getCodeAssistGlobalUserSetting();
+        if (resp.freeTierDataCollectionOptin === undefined) {
+            debugLogger.warn('Warning: Code Assist API did not return freeTierDataCollectionOptin. Defaulting to true.');
+        }
+        return resp.freeTierDataCollectionOptin ?? true;
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'response' in error) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            const gaxiosError = error;
+            if (gaxiosError.response?.status === 404) {
+                return true;
+            }
+        }
+        throw error;
+    }
+}
+async function setRemoteDataCollectionOptIn(server, optIn) {
+    const resp = await server.setCodeAssistGlobalUserSetting({
+        cloudaicompanionProject: server.projectId,
+        freeTierDataCollectionOptin: optIn,
+    });
+    if (resp.freeTierDataCollectionOptin === undefined) {
+        debugLogger.warn(`Warning: Code Assist API did not return freeTierDataCollectionOptin. Defaulting to ${optIn}.`);
+    }
+    return resp.freeTierDataCollectionOptin ?? optIn;
+}

package/dist/ui/hooks/usePromptCompletion.js

@@ -0,0 +1,168 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useCallback, useRef, useEffect, useMemo } from 'react';
+import { debugLogger, getResponseText, LlmRole, } from '@google/gemini-cli-core';
+import { isSlashCommand } from '../utils/commandUtils.js';
+export const PROMPT_COMPLETION_MIN_LENGTH = 5;
+export const PROMPT_COMPLETION_DEBOUNCE_MS = 250;
+export function usePromptCompletion({ buffer, config, }) {
+    const [ghostText, setGhostText] = useState('');
+    const [isLoadingGhostText, setIsLoadingGhostText] = useState(false);
+    const abortControllerRef = useRef(null);
+    const [justSelectedSuggestion, setJustSelectedSuggestion] = useState(false);
+    const lastSelectedTextRef = useRef('');
+    const lastRequestedTextRef = useRef('');
+    const isPromptCompletionEnabled = false;
+    const clearGhostText = useCallback(() => {
+        setGhostText('');
+        setIsLoadingGhostText(false);
+    }, []);
+    const acceptGhostText = useCallback(() => {
+        if (ghostText && ghostText.length > buffer.text.length) {
+            buffer.setText(ghostText);
+            setGhostText('');
+            setJustSelectedSuggestion(true);
+            lastSelectedTextRef.current = ghostText;
+        }
+    }, [ghostText, buffer]);
+    const markSuggestionSelected = useCallback((selectedText) => {
+        setJustSelectedSuggestion(true);
+        lastSelectedTextRef.current = selectedText;
+    }, []);
+    const generatePromptSuggestions = useCallback(async () => {
+        const trimmedText = buffer.text.trim();
+        const geminiClient = config?.getGeminiClient();
+        if (trimmedText === lastRequestedTextRef.current) {
+            return;
+        }
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        if (trimmedText.length < PROMPT_COMPLETION_MIN_LENGTH ||
+            !geminiClient ||
+            isSlashCommand(trimmedText) ||
+            trimmedText.includes('@') ||
+            !isPromptCompletionEnabled) {
+            clearGhostText();
+            lastRequestedTextRef.current = '';
+            return;
+        }
+        lastRequestedTextRef.current = trimmedText;
+        setIsLoadingGhostText(true);
+        abortControllerRef.current = new AbortController();
+        const signal = abortControllerRef.current.signal;
+        try {
+            const contents = [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            text: `You are a professional prompt engineering assistant. Complete the user's partial prompt with expert precision and clarity. User's input: "${trimmedText}" Continue this prompt by adding specific, actionable details that align with the user's intent. Focus on: clear, precise language; structured requirements; professional terminology; measurable outcomes. Length Guidelines: Keep suggestions concise (ideally 10-20 characters); prioritize brevity while maintaining clarity; use essential keywords only; avoid redundant phrases. Start your response with the exact user text ("${trimmedText}") followed by your completion. Provide practical, implementation-focused suggestions rather than creative interpretations. Format: Plain text only. Single completion. Match the user's language. Emphasize conciseness over elaboration.`,
+                        },
+                    ],
+                },
+            ];
+            const response = await geminiClient.generateContent({ model: 'prompt-completion' }, contents, signal, LlmRole.UTILITY_AUTOCOMPLETE);
+            if (signal.aborted) {
+                return;
+            }
+            if (response) {
+                const responseText = getResponseText(response);
+                if (responseText) {
+                    const suggestionText = responseText.trim();
+                    if (suggestionText.length > 0 &&
+                        suggestionText.startsWith(trimmedText)) {
+                        setGhostText(suggestionText);
+                    }
+                    else {
+                        clearGhostText();
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (!(signal.aborted ||
+                (error instanceof Error && error.name === 'AbortError'))) {
+                debugLogger.warn(`[WARN] prompt completion failed: : (${error instanceof Error ? error.message : String(error)})`);
+            }
+            clearGhostText();
+        }
+        finally {
+            if (!signal.aborted) {
+                setIsLoadingGhostText(false);
+            }
+        }
+    }, [buffer.text, config, clearGhostText, isPromptCompletionEnabled]);
+    const isCursorAtEnd = useCallback(() => {
+        const [cursorRow, cursorCol] = buffer.cursor;
+        const totalLines = buffer.lines.length;
+        if (cursorRow !== totalLines - 1) {
+            return false;
+        }
+        const lastLine = buffer.lines[cursorRow] || '';
+        return cursorCol === lastLine.length;
+    }, [buffer.cursor, buffer.lines]);
+    const handlePromptCompletion = useCallback(() => {
+        if (!isCursorAtEnd()) {
+            clearGhostText();
+            return;
+        }
+        const trimmedText = buffer.text.trim();
+        if (justSelectedSuggestion && trimmedText === lastSelectedTextRef.current) {
+            return;
+        }
+        if (trimmedText !== lastSelectedTextRef.current) {
+            setJustSelectedSuggestion(false);
+            lastSelectedTextRef.current = '';
+        }
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        generatePromptSuggestions();
+    }, [
+        buffer.text,
+        generatePromptSuggestions,
+        justSelectedSuggestion,
+        isCursorAtEnd,
+        clearGhostText,
+    ]);
+    // Debounce prompt completion
+    useEffect(() => {
+        const timeoutId = setTimeout(handlePromptCompletion, PROMPT_COMPLETION_DEBOUNCE_MS);
+        return () => clearTimeout(timeoutId);
+    }, [buffer.text, buffer.cursor, handlePromptCompletion]);
+    // Ghost text validation - clear if it doesn't match current text or cursor not at end
+    useEffect(() => {
+        const currentText = buffer.text.trim();
+        if (ghostText && !isCursorAtEnd()) {
+            clearGhostText();
+            return;
+        }
+        if (ghostText &&
+            currentText.length > 0 &&
+            !ghostText.startsWith(currentText)) {
+            clearGhostText();
+        }
+    }, [buffer.text, buffer.cursor, ghostText, clearGhostText, isCursorAtEnd]);
+    // Cleanup on unmount
+    useEffect(() => () => abortControllerRef.current?.abort(), []);
+    const isActive = useMemo(() => {
+        if (!isPromptCompletionEnabled)
+            return false;
+        if (!isCursorAtEnd())
+            return false;
+        const trimmedText = buffer.text.trim();
+        return (trimmedText.length >= PROMPT_COMPLETION_MIN_LENGTH &&
+            !isSlashCommand(trimmedText) &&
+            !trimmedText.includes('@'));
+    }, [buffer.text, isPromptCompletionEnabled, isCursorAtEnd]);
+    return {
+        text: ghostText,
+        isLoading: isLoadingGhostText,
+        isActive,
+        accept: acceptGhostText,
+        clear: clearGhostText,
+        markSelected: markSuggestionSelected,
+    };
+}

package/dist/ui/hooks/useQuotaAndFallback.js

@@ -0,0 +1,220 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthType, TerminalQuotaError, ModelNotFoundError, VALID_GEMINI_MODELS, isProModel, isOverageEligibleModel, getDisplayString, } from '@google/gemini-cli-core';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { MessageType } from '../types.js';
+import { handleCreditsFlow } from './creditsFlowHandler.js';
+export function useQuotaAndFallback({ config, historyManager, userTier, paidTier, settings, setModelSwitchedFromQuotaError, onShowAuthSelection, errorVerbosity = 'full', }) {
+    const [proQuotaRequest, setProQuotaRequest] = useState(null);
+    const [validationRequest, setValidationRequest] = useState(null);
+    // G1 AI Credits dialog states
+    const [overageMenuRequest, setOverageMenuRequest] = useState(null);
+    const [emptyWalletRequest, setEmptyWalletRequest] = useState(null);
+    const isDialogPending = useRef(false);
+    const isValidationPending = useRef(false);
+    // Set up Flash fallback handler
+    useEffect(() => {
+        const fallbackHandler = async (failedModel, fallbackModel, error) => {
+            const contentGeneratorConfig = config.getContentGeneratorConfig();
+            let message;
+            let isTerminalQuotaError = false;
+            let isModelNotFoundError = false;
+            const usageLimitReachedModel = isProModel(failedModel)
+                ? 'all Pro models'
+                : failedModel;
+            if (error instanceof TerminalQuotaError) {
+                isTerminalQuotaError = true;
+                const isInsufficientCredits = error.isInsufficientCredits;
+                // G1 Credits Flow: Only apply if user has a tier that supports credits
+                // (paidTier?.availableCredits indicates the user is a G1 subscriber)
+                // Skip if the error explicitly says they have insufficient credits (e.g. they
+                // just exhausted them or zero balance cache is delayed).
+                if (!isInsufficientCredits &&
+                    paidTier?.availableCredits &&
+                    isOverageEligibleModel(failedModel)) {
+                    const resetTime = error.retryDelayMs
+                        ? getResetTimeMessage(error.retryDelayMs)
+                        : undefined;
+                    const overageStrategy = config.getBillingSettings().overageStrategy;
+                    const creditsResult = await handleCreditsFlow({
+                        config,
+                        paidTier,
+                        overageStrategy,
+                        failedModel,
+                        fallbackModel,
+                        usageLimitReachedModel,
+                        resetTime,
+                        historyManager,
+                        setModelSwitchedFromQuotaError,
+                        isDialogPending,
+                        setOverageMenuRequest,
+                        setEmptyWalletRequest,
+                    });
+                    if (creditsResult)
+                        return creditsResult;
+                }
+                // Default: Show existing ProQuotaDialog (for overageStrategy: 'never' or non-G1 users)
+                const messageLines = [
+                    `Usage limit reached for ${usageLimitReachedModel}.`,
+                    error.retryDelayMs
+                        ? `Access resets at ${getResetTimeMessage(error.retryDelayMs)}.`
+                        : null,
+                    `/stats model for usage details`,
+                    `/model to switch models.`,
+                    contentGeneratorConfig?.authType === AuthType.LOGIN_WITH_GOOGLE
+                        ? `/auth to switch to API key.`
+                        : null,
+                ].filter(Boolean);
+                message = messageLines.join('\n');
+            }
+            else if (error instanceof ModelNotFoundError) {
+                isModelNotFoundError = true;
+                if (VALID_GEMINI_MODELS.has(failedModel)) {
+                    const messageLines = [
+                        `It seems like you don't have access to ${getDisplayString(failedModel)}.`,
+                        `Your admin might have disabled the access. Contact them to enable the Preview Release Channel.`,
+                    ];
+                    message = messageLines.join('\n');
+                }
+                else {
+                    const messageLines = [
+                        `Model "${failedModel}" was not found or is invalid.`,
+                        `/model to switch models.`,
+                    ];
+                    message = messageLines.join('\n');
+                }
+            }
+            else {
+                const messageLines = [
+                    `We are currently experiencing high demand.`,
+                    'We apologize and appreciate your patience.',
+                    '/model to switch models.',
+                ];
+                message = messageLines.join('\n');
+            }
+            // In low verbosity mode, auto-retry transient capacity failures
+            // without interrupting with a dialog.
+            if (errorVerbosity === 'low' &&
+                !isTerminalQuotaError &&
+                !isModelNotFoundError) {
+                return 'retry_once';
+            }
+            setModelSwitchedFromQuotaError(true);
+            config.setQuotaErrorOccurred(true);
+            if (isDialogPending.current) {
+                return 'stop'; // A dialog is already active, so just stop this request.
+            }
+            isDialogPending.current = true;
+            const intent = await new Promise((resolve) => {
+                setProQuotaRequest({
+                    failedModel,
+                    fallbackModel,
+                    resolve,
+                    message,
+                    isTerminalQuotaError,
+                    isModelNotFoundError,
+                    authType: contentGeneratorConfig?.authType,
+                });
+            });
+            return intent;
+        };
+        config.setFallbackModelHandler(fallbackHandler);
+    }, [
+        config,
+        historyManager,
+        userTier,
+        paidTier,
+        settings,
+        setModelSwitchedFromQuotaError,
+        onShowAuthSelection,
+        errorVerbosity,
+    ]);
+    // Set up validation handler for 403 VALIDATION_REQUIRED errors
+    useEffect(() => {
+        const validationHandler = async (validationLink, validationDescription, learnMoreUrl) => {
+            if (isValidationPending.current) {
+                return 'cancel'; // A validation dialog is already active
+            }
+            isValidationPending.current = true;
+            const intent = await new Promise((resolve) => {
+                // Call setValidationRequest directly - same pattern as proQuotaRequest
+                setValidationRequest({
+                    validationLink,
+                    validationDescription,
+                    learnMoreUrl,
+                    resolve,
+                });
+            });
+            return intent;
+        };
+        config.setValidationHandler(validationHandler);
+    }, [config]);
+    const handleProQuotaChoice = useCallback((choice) => {
+        if (!proQuotaRequest)
+            return;
+        const intent = choice;
+        proQuotaRequest.resolve(intent);
+        setProQuotaRequest(null);
+        isDialogPending.current = false; // Reset the flag here
+        if (choice === 'retry_always' || choice === 'retry_once') {
+            // Reset quota error flags to allow the agent loop to continue.
+            setModelSwitchedFromQuotaError(false);
+            config.setQuotaErrorOccurred(false);
+            if (choice === 'retry_always') {
+                historyManager.addItem({
+                    type: MessageType.INFO,
+                    text: `Switched to fallback model ${proQuotaRequest.fallbackModel}`,
+                }, Date.now());
+            }
+        }
+    }, [proQuotaRequest, historyManager, config, setModelSwitchedFromQuotaError]);
+    const handleValidationChoice = useCallback((choice) => {
+        // Guard against double-execution (e.g. rapid clicks) and stale requests
+        if (!isValidationPending.current || !validationRequest)
+            return;
+        // Immediately clear the flag to prevent any subsequent calls from passing the guard
+        isValidationPending.current = false;
+        validationRequest.resolve(choice);
+        setValidationRequest(null);
+        if (choice === 'change_auth' || choice === 'cancel') {
+            onShowAuthSelection();
+        }
+    }, [validationRequest, onShowAuthSelection]);
+    // Handler for overage menu dialog (G1 AI Credits flow)
+    const handleOverageMenuChoice = useCallback((choice) => {
+        if (!overageMenuRequest)
+            return;
+        overageMenuRequest.resolve(choice);
+        // State will be cleared by the effect callback after the promise resolves
+    }, [overageMenuRequest]);
+    // Handler for empty wallet dialog (G1 AI Credits flow)
+    const handleEmptyWalletChoice = useCallback((choice) => {
+        if (!emptyWalletRequest)
+            return;
+        emptyWalletRequest.resolve(choice);
+        // State will be cleared by the effect callback after the promise resolves
+    }, [emptyWalletRequest]);
+    return {
+        proQuotaRequest,
+        handleProQuotaChoice,
+        validationRequest,
+        handleValidationChoice,
+        // G1 AI Credits
+        overageMenuRequest,
+        handleOverageMenuChoice,
+        emptyWalletRequest,
+        handleEmptyWalletChoice,
+    };
+}
+function getResetTimeMessage(delayMs) {
+    const resetDate = new Date(Date.now() + delayMs);
+    const timeFormatter = new Intl.DateTimeFormat('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        timeZoneName: 'short',
+    });
+    return timeFormatter.format(resetDate);
+}

package/dist/ui/hooks/useRegistrySearch.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useRef } from 'react';
+import { useSearchBuffer } from './useSearchBuffer.js';
+export function useRegistrySearch(props) {
+    const { items, initialQuery = '', onSearch } = props;
+    const [searchQuery, setSearchQuery] = useState(initialQuery);
+    const isFirstRender = useRef(true);
+    const onSearchRef = useRef(onSearch);
+    onSearchRef.current = onSearch;
+    useEffect(() => {
+        if (isFirstRender.current) {
+            isFirstRender.current = false;
+            return;
+        }
+        onSearchRef.current?.(searchQuery);
+    }, [searchQuery]);
+    const searchBuffer = useSearchBuffer({
+        initialText: searchQuery,
+        onChange: setSearchQuery,
+    });
+    const maxLabelWidth = 0;
+    const filteredItems = items;
+    return {
+        filteredItems,
+        searchBuffer,
+        searchQuery,
+        setSearchQuery,
+        maxLabelWidth,
+    };
+}