@quantum-ai/gemini-cli 0.45.8 → 0.45.10

package/dist/ui/hooks/useTips.js

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useEffect, useState } from 'react';
+import { persistentState } from '../../utils/persistentState.js';
+export function useTips() {
+    const [tipsCount] = useState(() => persistentState.get('tipsShown') ?? 0);
+    const showTips = tipsCount < 10;
+    useEffect(() => {
+        if (showTips) {
+            persistentState.set('tipsShown', tipsCount + 1);
+        }
+    }, [tipsCount, showTips]);
+    return { showTips };
+}

package/dist/ui/hooks/useToolScheduler.js

@@ -0,0 +1,212 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MessageBusType, ROOT_SCHEDULER_ID, Scheduler, CoreToolCallStatus, AGENT_TOOL_NAME, } from '@google/gemini-cli-core';
+import { useCallback, useState, useMemo, useEffect, useRef } from 'react';
+/**
+ * Modern tool scheduler hook using the event-driven Core Scheduler.
+ */
+export function useToolScheduler(onComplete, config, getPreferredEditor) {
+    // State stores tool calls organized by their originating schedulerId
+    const [toolCallsMap, setToolCallsMap] = useState({});
+    const [lastToolOutputTime, setLastToolOutputTime] = useState(0);
+    const [subagentHistoryMap, setSubagentHistoryMap] = useState({});
+    const messageBus = useMemo(() => config.getMessageBus(), [config]);
+    const onCompleteRef = useRef(onComplete);
+    useEffect(() => {
+        onCompleteRef.current = onComplete;
+    }, [onComplete]);
+    const getPreferredEditorRef = useRef(getPreferredEditor);
+    useEffect(() => {
+        getPreferredEditorRef.current = getPreferredEditor;
+    }, [getPreferredEditor]);
+    const scheduler = useMemo(() => new Scheduler({
+        context: config,
+        messageBus,
+        getPreferredEditor: () => getPreferredEditorRef.current(),
+        schedulerId: ROOT_SCHEDULER_ID,
+    }), [config, messageBus]);
+    useEffect(() => () => scheduler.dispose(), [scheduler]);
+    const internalAdaptToolCalls = useCallback((coreCalls, prevTracked) => adaptToolCalls(coreCalls, prevTracked), []);
+    useEffect(() => {
+        const handler = (event) => {
+            const isRoot = event.schedulerId === ROOT_SCHEDULER_ID;
+            // Update output timer for UI spinners (Side Effect)
+            const hasExecuting = event.toolCalls.some((tc) => tc.status === CoreToolCallStatus.Executing ||
+                ((tc.status === CoreToolCallStatus.Success ||
+                    tc.status === CoreToolCallStatus.Error) &&
+                    'tailToolCallRequest' in tc &&
+                    tc.tailToolCallRequest != null));
+            if (hasExecuting) {
+                setLastToolOutputTime(Date.now());
+            }
+            setToolCallsMap((prev) => {
+                const prevCalls = prev[event.schedulerId] ?? [];
+                const prevCallIds = new Set(prevCalls.map((tc) => tc.request.callId));
+                // For non-root schedulers, we only show tool calls that:
+                // 1. Are currently awaiting approval.
+                // 2. Were previously shown (e.g., they are now executing or completed).
+                // This prevents "thinking" tools (reads/searches) from flickering in the UI
+                // unless they specifically required user interaction.
+                const filteredToolCalls = isRoot
+                    ? event.toolCalls
+                    : event.toolCalls.filter((tc) => tc.status === CoreToolCallStatus.AwaitingApproval ||
+                        prevCallIds.has(tc.request.callId));
+                // If this is a subagent and we have no tools to show and weren't showing any,
+                // we can skip the update entirely to avoid unnecessary re-renders.
+                if (!isRoot &&
+                    filteredToolCalls.length === 0 &&
+                    prevCalls.length === 0) {
+                    return prev;
+                }
+                const adapted = internalAdaptToolCalls(filteredToolCalls, prevCalls);
+                return {
+                    ...prev,
+                    [event.schedulerId]: adapted,
+                };
+            });
+        };
+        messageBus.subscribe(MessageBusType.TOOL_CALLS_UPDATE, handler);
+        return () => {
+            messageBus.unsubscribe(MessageBusType.TOOL_CALLS_UPDATE, handler);
+        };
+    }, [messageBus, internalAdaptToolCalls]);
+    useEffect(() => {
+        const handler = (event) => {
+            setSubagentHistoryMap((prev) => {
+                const history = prev[event.subagentName] ?? [];
+                const index = history.findIndex((item) => item.id === event.activity.id);
+                const nextHistory = [...history];
+                if (index >= 0) {
+                    nextHistory[index] = event.activity;
+                }
+                else {
+                    nextHistory.push(event.activity);
+                }
+                return {
+                    ...prev,
+                    [event.subagentName]: nextHistory,
+                };
+            });
+        };
+        messageBus.subscribe(MessageBusType.SUBAGENT_ACTIVITY, handler);
+        return () => {
+            messageBus.unsubscribe(MessageBusType.SUBAGENT_ACTIVITY, handler);
+        };
+    }, [messageBus]);
+    const schedule = useCallback(async (request, signal) => {
+        // Clear state for new run
+        setToolCallsMap({});
+        setSubagentHistoryMap({});
+        // 1. Await Core Scheduler directly
+        const results = await scheduler.schedule(request, signal);
+        // 2. Trigger legacy reinjection logic (useGeminiStream loop)
+        // Since this hook instance owns the "root" scheduler, we always trigger
+        // onComplete when it finishes its batch.
+        await onCompleteRef.current(results);
+        return results;
+    }, [scheduler]);
+    const cancelAll = useCallback((_signal) => {
+        scheduler.cancelAll();
+    }, [scheduler]);
+    const markToolsAsSubmitted = useCallback((callIdsToMark) => {
+        setToolCallsMap((prevMap) => {
+            const nextMap = { ...prevMap };
+            for (const [sid, calls] of Object.entries(nextMap)) {
+                nextMap[sid] = calls.map((tc) => callIdsToMark.includes(tc.request.callId)
+                    ? { ...tc, responseSubmittedToGemini: true }
+                    : tc);
+            }
+            return nextMap;
+        });
+    }, []);
+    // Flatten the map for the UI components that expect a single list of tools.
+    const toolCalls = useMemo(() => {
+        const flattened = Object.values(toolCallsMap).flat();
+        return flattened.map((tc) => {
+            let subagentName = tc.request.name;
+            if (tc.request.name === AGENT_TOOL_NAME) {
+                const argsObj = tc.request.args;
+                let parsedArgs = argsObj;
+                if (typeof argsObj === 'string') {
+                    try {
+                        parsedArgs = JSON.parse(argsObj);
+                    }
+                    catch {
+                        parsedArgs = null;
+                    }
+                }
+                if (typeof parsedArgs === 'object' && parsedArgs !== null) {
+                    for (const [key, value] of Object.entries(parsedArgs)) {
+                        if (key === 'agent_name' && typeof value === 'string') {
+                            subagentName = value;
+                            break;
+                        }
+                    }
+                }
+            }
+            return {
+                ...tc,
+                subagentHistory: subagentHistoryMap[subagentName] ?? tc.subagentHistory,
+            };
+        });
+    }, [toolCallsMap, subagentHistoryMap]);
+    // Provide a setter that maintains compatibility with legacy [].
+    const setToolCallsForDisplay = useCallback((action) => {
+        setToolCallsMap((prev) => {
+            const currentFlattened = Object.values(prev).flat();
+            const nextFlattened = typeof action === 'function' ? action(currentFlattened) : action;
+            if (nextFlattened.length === 0) {
+                return {};
+            }
+            // Re-group by schedulerId to preserve multi-scheduler state
+            const nextMap = {};
+            for (const call of nextFlattened) {
+                // All tool calls should have a schedulerId from the core.
+                // Default to ROOT_SCHEDULER_ID as a safeguard.
+                const sid = call.schedulerId ?? ROOT_SCHEDULER_ID;
+                if (!nextMap[sid]) {
+                    nextMap[sid] = [];
+                }
+                nextMap[sid].push(call);
+            }
+            return nextMap;
+        });
+    }, []);
+    return [
+        toolCalls,
+        schedule,
+        markToolsAsSubmitted,
+        setToolCallsForDisplay,
+        cancelAll,
+        lastToolOutputTime,
+        scheduler,
+    ];
+}
+/**
+ * ADAPTER: Merges UI metadata (submitted flag).
+ */
+function adaptToolCalls(coreCalls, prevTracked) {
+    const prevMap = new Map(prevTracked.map((t) => [t.request.callId, t]));
+    return coreCalls.map((coreCall) => {
+        const prev = prevMap.get(coreCall.request.callId);
+        const responseSubmittedToGemini = prev?.responseSubmittedToGemini ?? false;
+        let status = coreCall.status;
+        // If a tool call has completed but scheduled a tail call, it is in a transitional
+        // state. Force the UI to render it as "executing".
+        if ((status === CoreToolCallStatus.Success ||
+            status === CoreToolCallStatus.Error) &&
+            'tailToolCallRequest' in coreCall &&
+            coreCall.tailToolCallRequest != null) {
+            status = CoreToolCallStatus.Executing;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        return {
+            ...coreCall,
+            status,
+            responseSubmittedToGemini,
+        };
+    });
+}

package/dist/ui/hooks/useTurnActivityMonitor.js

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useEffect, useRef, useMemo } from 'react';
+import { StreamingState } from '../types.js';
+import { hasRedirection, } from '@google/gemini-cli-core';
+/**
+ * Monitors the activity of a Gemini turn to detect when a new operation starts
+ * and whether it involves shell redirections that should suppress inactivity prompts.
+ */
+export const useTurnActivityMonitor = (streamingState, activePtyId, pendingToolCalls = []) => {
+    const [operationStartTime, setOperationStartTime] = useState(0);
+    // Reset operation start time whenever a new operation begins.
+    // We consider an operation to have started when we enter Responding state,
+    // OR when the active PTY changes (meaning a new command started within the turn).
+    const prevPtyIdRef = useRef(undefined);
+    const prevStreamingStateRef = useRef(undefined);
+    useEffect(() => {
+        const isNowResponding = streamingState === StreamingState.Responding;
+        const wasResponding = prevStreamingStateRef.current === StreamingState.Responding;
+        const ptyChanged = activePtyId !== prevPtyIdRef.current;
+        if (isNowResponding && (!wasResponding || ptyChanged)) {
+            setOperationStartTime(Date.now());
+        }
+        else if (!isNowResponding && wasResponding) {
+            setOperationStartTime(0);
+        }
+        prevPtyIdRef.current = activePtyId;
+        prevStreamingStateRef.current = streamingState;
+    }, [streamingState, activePtyId]);
+    // Detect redirection in the current query or tool calls.
+    // We derive this directly during render to ensure it's accurate from the first frame.
+    const isRedirectionActive = useMemo(() => 
+    // Check active tool calls for run_shell_command
+    pendingToolCalls.some((tc) => {
+        if (tc.request.name !== 'run_shell_command')
+            return false;
+        const command = tc.request.args?.command || '';
+        return hasRedirection(command);
+    }), [pendingToolCalls]);
+    return {
+        operationStartTime,
+        isRedirectionActive,
+    };
+};

package/dist/ui/hooks/useVisibilityToggle.js

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { persistentState } from '../../utils/persistentState.js';
+export const APPROVAL_MODE_REVEAL_DURATION_MS = 1200;
+const FOCUS_UI_ENABLED_STATE_KEY = 'focusUiEnabled';
+export function useVisibilityToggle() {
+    const [focusUiEnabledByDefault] = useState(() => persistentState.get(FOCUS_UI_ENABLED_STATE_KEY) === true);
+    const [cleanUiDetailsVisible, setCleanUiDetailsVisibleState] = useState(!focusUiEnabledByDefault);
+    const modeRevealTimeoutRef = useRef(null);
+    const cleanUiDetailsPinnedRef = useRef(!focusUiEnabledByDefault);
+    const clearModeRevealTimeout = useCallback(() => {
+        if (modeRevealTimeoutRef.current) {
+            clearTimeout(modeRevealTimeoutRef.current);
+            modeRevealTimeoutRef.current = null;
+        }
+    }, []);
+    const persistFocusUiPreference = useCallback((isFullUiVisible) => {
+        persistentState.set(FOCUS_UI_ENABLED_STATE_KEY, !isFullUiVisible);
+    }, []);
+    const setCleanUiDetailsVisible = useCallback((visible) => {
+        clearModeRevealTimeout();
+        cleanUiDetailsPinnedRef.current = visible;
+        setCleanUiDetailsVisibleState(visible);
+        persistFocusUiPreference(visible);
+    }, [clearModeRevealTimeout, persistFocusUiPreference]);
+    const toggleCleanUiDetailsVisible = useCallback(() => {
+        clearModeRevealTimeout();
+        setCleanUiDetailsVisibleState((visible) => {
+            const nextVisible = !visible;
+            cleanUiDetailsPinnedRef.current = nextVisible;
+            persistFocusUiPreference(nextVisible);
+            return nextVisible;
+        });
+    }, [clearModeRevealTimeout, persistFocusUiPreference]);
+    const revealCleanUiDetailsTemporarily = useCallback((durationMs = APPROVAL_MODE_REVEAL_DURATION_MS) => {
+        if (cleanUiDetailsPinnedRef.current) {
+            return;
+        }
+        clearModeRevealTimeout();
+        setCleanUiDetailsVisibleState(true);
+        modeRevealTimeoutRef.current = setTimeout(() => {
+            if (!cleanUiDetailsPinnedRef.current) {
+                setCleanUiDetailsVisibleState(false);
+            }
+            modeRevealTimeoutRef.current = null;
+        }, durationMs);
+    }, [clearModeRevealTimeout]);
+    useEffect(() => () => clearModeRevealTimeout(), [clearModeRevealTimeout]);
+    return {
+        cleanUiDetailsVisible,
+        setCleanUiDetailsVisible,
+        toggleCleanUiDetailsVisible,
+        revealCleanUiDetailsTemporarily,
+    };
+}

package/dist/ui/hooks/useVoiceMode.js

@@ -0,0 +1,338 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { AudioRecorder, TranscriptionFactory, debugLogger, } from '@google/gemini-cli-core';
+import { Command } from '../key/keyMatchers.js';
+const HOLD_DELAY_MS = 600;
+const RELEASE_DELAY_MS = 300;
+export function useVoiceMode({ buffer, config, settings, setQueueErrorMessage, isVoiceModeEnabled, setVoiceModeEnabled, keyMatchers, }) {
+    const [isRecording, setIsRecording] = useState(false);
+    const [isConnecting, setIsConnecting] = useState(false);
+    const liveTranscriptionRef = useRef('');
+    const stopRequestedRef = useRef(false);
+    const isRecordingRef = useRef(false);
+    const lastFailureTimeRef = useRef(0);
+    const recordingInProgressRef = useRef(false);
+    const voiceTimeoutRef = useRef(null);
+    const recorderRef = useRef(null);
+    const transcriptionServiceRef = useRef(null);
+    const turnBaselineRef = useRef(null);
+    const turnBaselineCursorOffsetRef = useRef(0);
+    const pttStateRef = useRef('idle');
+    const pttTimerRef = useRef(null);
+    const disconnectTimerRef = useRef(null);
+    const bufferRef = useRef(buffer);
+    bufferRef.current = buffer;
+    const stopVoiceRecording = useCallback(() => {
+        if (stopRequestedRef.current)
+            return;
+        debugLogger.debug('[Voice] Stop requested');
+        stopRequestedRef.current = true;
+        setIsRecording(false);
+        isRecordingRef.current = false;
+        setIsConnecting(false);
+        if (recorderRef.current) {
+            recorderRef.current.stop();
+            recorderRef.current = null;
+        }
+        const serviceToDisconnect = transcriptionServiceRef.current;
+        if (serviceToDisconnect) {
+            const gracePeriodMs = settings.experimental.voice.stopGracePeriodMs;
+            debugLogger.debug(`[Voice] Draining transcription for ${gracePeriodMs}ms`);
+            if (disconnectTimerRef.current)
+                clearTimeout(disconnectTimerRef.current);
+            disconnectTimerRef.current = setTimeout(() => {
+                debugLogger.debug('[Voice] Grace period ended, disconnecting service');
+                serviceToDisconnect.disconnect();
+                if (transcriptionServiceRef.current === serviceToDisconnect) {
+                    transcriptionServiceRef.current = null;
+                }
+                disconnectTimerRef.current = null;
+                liveTranscriptionRef.current = '';
+            }, gracePeriodMs);
+        }
+        else {
+            liveTranscriptionRef.current = '';
+        }
+        pttStateRef.current = 'idle';
+    }, [settings.experimental.voice]);
+    const startVoiceRecording = useCallback(() => {
+        if (isRecordingRef.current ||
+            Date.now() - lastFailureTimeRef.current < 2000) {
+            return;
+        }
+        if (disconnectTimerRef.current) {
+            clearTimeout(disconnectTimerRef.current);
+            disconnectTimerRef.current = null;
+        }
+        recordingInProgressRef.current = true;
+        turnBaselineRef.current = bufferRef.current.text;
+        turnBaselineCursorOffsetRef.current = bufferRef.current.getOffset();
+        setIsConnecting(true);
+        setIsRecording(true);
+        isRecordingRef.current = true;
+        liveTranscriptionRef.current = '';
+        stopRequestedRef.current = false;
+        const apiKey = config.getContentGeneratorConfig()?.apiKey ||
+            process.env['GEMINI_API_KEY'] ||
+            '';
+        const startAsync = async () => {
+            // If there's an active draining service, disconnect it immediately
+            // before starting a new one to prevent orphaned event collisions.
+            if (disconnectTimerRef.current) {
+                clearTimeout(disconnectTimerRef.current);
+                disconnectTimerRef.current = null;
+            }
+            if (transcriptionServiceRef.current) {
+                transcriptionServiceRef.current.disconnect();
+                transcriptionServiceRef.current = null;
+            }
+            const cleanupIfStopped = () => {
+                if (stopRequestedRef.current) {
+                    if (recorderRef.current) {
+                        recorderRef.current.stop();
+                        recorderRef.current = null;
+                    }
+                    if (transcriptionServiceRef.current) {
+                        transcriptionServiceRef.current.disconnect();
+                        transcriptionServiceRef.current = null;
+                    }
+                    setIsRecording(false);
+                    isRecordingRef.current = false;
+                    setIsConnecting(false);
+                    recordingInProgressRef.current = false;
+                    return true;
+                }
+                return false;
+            };
+            if (cleanupIfStopped())
+                return;
+            const voiceBackend = settings.experimental.voice?.backend ?? 'gemini-live';
+            if (!apiKey && voiceBackend === 'gemini-live') {
+                setQueueErrorMessage('Cloud voice mode requires a GEMINI_API_KEY. Please set it in your environment or ~/.gemini/.env.');
+                setIsRecording(false);
+                isRecordingRef.current = false;
+                setIsConnecting(false);
+                recordingInProgressRef.current = false;
+                lastFailureTimeRef.current = Date.now();
+                return;
+            }
+            if (voiceBackend === 'gemini-live') {
+                recorderRef.current = new AudioRecorder();
+            }
+            const currentService = TranscriptionFactory.createProvider(settings.experimental.voice, apiKey);
+            transcriptionServiceRef.current = currentService;
+            currentService.on('transcription', (text) => {
+                if (transcriptionServiceRef.current !== currentService &&
+                    stopRequestedRef.current) {
+                    // If this is an orphaned service that was replaced by a new session, ignore its events
+                    return;
+                }
+                if (text) {
+                    const baseline = turnBaselineRef.current ?? '';
+                    const insertOffset = turnBaselineCursorOffsetRef.current;
+                    const textBefore = baseline.slice(0, insertOffset);
+                    const textAfter = baseline.slice(insertOffset);
+                    const prefix = textBefore.length > 0 && !/\s$/.test(textBefore)
+                        ? textBefore + ' '
+                        : textBefore;
+                    const suffix = text.length > 0 && textAfter.length > 0 && !/^\s/.test(textAfter)
+                        ? ' '
+                        : '';
+                    const newTotalText = prefix + text + suffix + textAfter;
+                    bufferRef.current.setText(newTotalText, prefix.length + text.length);
+                }
+                liveTranscriptionRef.current = text;
+            });
+            currentService.on('turnComplete', () => {
+                if (transcriptionServiceRef.current !== currentService &&
+                    stopRequestedRef.current)
+                    return;
+                // Advance the baseline so subsequent turns append after this turn's text
+                turnBaselineRef.current = bufferRef.current.text;
+                turnBaselineCursorOffsetRef.current = bufferRef.current.getOffset();
+                liveTranscriptionRef.current = '';
+            });
+            currentService.on('error', (err) => {
+                if (transcriptionServiceRef.current !== currentService)
+                    return;
+                debugLogger.error('[Voice] Transcription error:', err);
+                lastFailureTimeRef.current = Date.now();
+                recordingInProgressRef.current = false;
+            });
+            currentService.on('close', () => {
+                if (transcriptionServiceRef.current !== currentService)
+                    return;
+                if (!stopRequestedRef.current) {
+                    setIsRecording(false);
+                    isRecordingRef.current = false;
+                    setIsConnecting(false);
+                    recordingInProgressRef.current = false;
+                    lastFailureTimeRef.current = Date.now();
+                }
+            });
+            try {
+                await currentService.connect();
+                if (cleanupIfStopped())
+                    return;
+                await recorderRef.current?.start();
+                if (cleanupIfStopped())
+                    return;
+                setIsConnecting(false);
+                const currentVoiceBackend = settings.experimental.voice?.backend ?? 'gemini-live';
+                recorderRef.current?.on('data', (chunk) => {
+                    if (currentVoiceBackend === 'gemini-live') {
+                        currentService.sendAudioChunk(chunk);
+                    }
+                });
+                recorderRef.current?.on('error', (err) => {
+                    debugLogger.error('[Voice] Recorder error:', err);
+                    stopVoiceRecording();
+                    lastFailureTimeRef.current = Date.now();
+                });
+            }
+            catch (err) {
+                if (transcriptionServiceRef.current !== currentService)
+                    return;
+                const message = err instanceof Error ? err.message : String(err);
+                setQueueErrorMessage(`Voice mode failure: ${message}`);
+                setIsRecording(false);
+                isRecordingRef.current = false;
+                setIsConnecting(false);
+                recordingInProgressRef.current = false;
+                lastFailureTimeRef.current = Date.now();
+                if (recorderRef.current) {
+                    recorderRef.current.stop();
+                    recorderRef.current = null;
+                }
+                if (transcriptionServiceRef.current) {
+                    transcriptionServiceRef.current.disconnect();
+                    transcriptionServiceRef.current = null;
+                }
+            }
+        };
+        void startAsync();
+    }, [
+        config,
+        settings.experimental.voice,
+        setQueueErrorMessage,
+        stopVoiceRecording,
+    ]);
+    useEffect(() => () => {
+        if (voiceTimeoutRef.current)
+            clearTimeout(voiceTimeoutRef.current);
+        if (recorderRef.current) {
+            recorderRef.current.stop();
+            recorderRef.current = null;
+        }
+        if (transcriptionServiceRef.current) {
+            transcriptionServiceRef.current.disconnect();
+            transcriptionServiceRef.current = null;
+        }
+        if (pttTimerRef.current)
+            clearTimeout(pttTimerRef.current);
+        if (disconnectTimerRef.current)
+            clearTimeout(disconnectTimerRef.current);
+    }, []);
+    const handleVoiceInput = useCallback((key) => {
+        const activeRecording = isRecording || isRecordingRef.current;
+        if (activeRecording) {
+            const activationMode = settings.experimental.voice?.activationMode ?? 'push-to-talk';
+            if (keyMatchers[Command.ESCAPE](key)) {
+                stopVoiceRecording();
+                return true;
+            }
+            if (keyMatchers[Command.VOICE_MODE_PTT](key)) {
+                if (activationMode === 'push-to-talk') {
+                    if (pttTimerRef.current) {
+                        clearTimeout(pttTimerRef.current);
+                    }
+                    pttTimerRef.current = setTimeout(() => {
+                        stopVoiceRecording();
+                        pttTimerRef.current = null;
+                    }, RELEASE_DELAY_MS);
+                    return true;
+                }
+                else {
+                    stopVoiceRecording();
+                    return true;
+                }
+            }
+            return true;
+        }
+        if (isVoiceModeEnabled) {
+            const activationMode = settings.experimental.voice?.activationMode ?? 'push-to-talk';
+            if (keyMatchers[Command.ESCAPE](key) && buffer.text === '') {
+                setVoiceModeEnabled(false);
+                return true;
+            }
+            if (keyMatchers[Command.VOICE_MODE_PTT](key)) {
+                if (key.name === 'space' &&
+                    !key.ctrl &&
+                    !key.alt &&
+                    !key.shift &&
+                    !key.cmd) {
+                    if (activationMode === 'toggle') {
+                        startVoiceRecording();
+                        return true;
+                    }
+                    else {
+                        if (pttStateRef.current === 'idle') {
+                            buffer.insert(' ');
+                            pttStateRef.current = 'possible-hold';
+                            if (pttTimerRef.current)
+                                clearTimeout(pttTimerRef.current);
+                            pttTimerRef.current = setTimeout(() => {
+                                pttStateRef.current = 'idle';
+                                pttTimerRef.current = null;
+                            }, HOLD_DELAY_MS);
+                            return true;
+                        }
+                        else if (pttStateRef.current === 'possible-hold') {
+                            if (pttTimerRef.current)
+                                clearTimeout(pttTimerRef.current);
+                            buffer.backspace();
+                            pttStateRef.current = 'recording';
+                            startVoiceRecording();
+                            pttTimerRef.current = setTimeout(() => {
+                                stopVoiceRecording();
+                                pttTimerRef.current = null;
+                            }, RELEASE_DELAY_MS);
+                            return true;
+                        }
+                    }
+                }
+            }
+            if (pttStateRef.current === 'possible-hold') {
+                pttStateRef.current = 'idle';
+                if (pttTimerRef.current) {
+                    clearTimeout(pttTimerRef.current);
+                    pttTimerRef.current = null;
+                }
+            }
+        }
+        return false;
+    }, [
+        isRecording,
+        isVoiceModeEnabled,
+        settings.experimental.voice,
+        keyMatchers,
+        stopVoiceRecording,
+        startVoiceRecording,
+        buffer,
+        setVoiceModeEnabled,
+    ]);
+    return {
+        isRecording,
+        isConnecting,
+        startVoiceRecording,
+        stopVoiceRecording,
+        handleVoiceInput,
+        resetTurnBaseline: () => {
+            turnBaselineRef.current = null;
+        },
+    };
+}