@datalayer/agent-runtimes 1.3.62 → 1.3.64

package/lib/specs/voices.js

@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The licences the register allows anywhere, the browser included. */
+export const SPEECH_ALLOWED_LICENCES = [
+    'MIT',
+    'Apache-2.0',
+    'BSD-2-Clause',
+    'BSD-3-Clause',
+    '0BSD',
+    'ISC',
+    'CC0-1.0',
+    'CC-BY-4.0',
+];
+export const VOICE_CATALOGUE = {
+    'kokoro-af-heart': {
+        id: 'kokoro-af-heart',
+        version: '0.0.1',
+        name: 'Heart',
+        description: "A warm American English voice, Kokoro's best graded (A).",
+        engine: 'kokoro',
+        model: 'kokoro-82m',
+        voice: 'af_heart',
+        languages: ['en-US'],
+        where: ['server'],
+        licence: {
+            weights: 'Apache-2.0',
+        },
+        attribution: '',
+        watermark: false,
+        sample: 'Hello. I read the answers aloud, sentence by sentence, as they are written.',
+    },
+    'kokoro-bf-emma': {
+        id: 'kokoro-bf-emma',
+        version: '0.0.1',
+        name: 'Emma',
+        description: 'A clear British English voice.',
+        engine: 'kokoro',
+        model: 'kokoro-82m',
+        voice: 'bf_emma',
+        languages: ['en-GB'],
+        where: ['server'],
+        licence: {
+            weights: 'Apache-2.0',
+        },
+        attribution: '',
+        watermark: false,
+        sample: 'Hello. I read the answers aloud, sentence by sentence, as they are written.',
+    },
+    'kokoro-ff-siwis': {
+        id: 'kokoro-ff-siwis',
+        version: '0.0.1',
+        name: 'Siwis',
+        description: "A French voice, Kokoro's only one, trained on the SIWIS French Speech Synthesis Database, whose licence asks for its attribution.",
+        engine: 'kokoro',
+        model: 'kokoro-82m',
+        voice: 'ff_siwis',
+        languages: ['fr-FR'],
+        where: ['server'],
+        licence: {
+            weights: 'Apache-2.0',
+            dataset: 'CC-BY-4.0',
+        },
+        attribution: 'Trained on the SIWIS French Speech Synthesis Database, by Pierre-Edouard Honnet, Alexandros Lazaridis, Philip N. Garner and Junichi Yamagishi (Idiap Research Institute), under CC BY 4.0.',
+        watermark: false,
+        sample: "Bonjour. Je lis les réponses à voix haute, phrase par phrase, à mesure qu'elles s'écrivent.",
+    },
+};
+export const SPEECH_MODEL_CATALOGUE = {
+    'kokoro-82m': {
+        id: 'kokoro-82m',
+        version: '0.0.1',
+        name: 'Kokoro 82M',
+        task: 'tts',
+        engine: 'kokoro-onnx',
+        dtype: 'fp32',
+        languages: ['en', 'fr', 'es', 'it', 'pt', 'hi', 'ja', 'zh'],
+        where: ['server'],
+        streaming: false,
+        licence: {
+            weights: 'Apache-2.0',
+            code: 'MIT',
+        },
+        attribution: '',
+        upstream: 'https://huggingface.co/hexgrad/Kokoro-82M',
+        revision: 'model-files-v1.0',
+        files: [
+            {
+                path: 'kokoro-v1.0.onnx',
+                sha256: '7d5df8ecf7d4b1878015a32686053fd0eebe2bc377234608764cc0ef3636a6c5',
+                size: 325532387,
+            },
+            {
+                path: 'voices-v1.0.bin',
+                sha256: 'bca610b8308e8d99f32e6fe4197e7ec01679264efed0cac9140fe9c29f1fbf7d',
+                size: 28214398,
+            },
+        ],
+    },
+    'moonshine-base-en': {
+        id: 'moonshine-base-en',
+        version: '0.0.1',
+        name: 'Moonshine Base (English)',
+        task: 'stt',
+        engine: 'transformers.js',
+        dtype: 'q8',
+        languages: ['en'],
+        where: ['device'],
+        streaming: false,
+        licence: {
+            weights: 'MIT',
+            code: 'MIT',
+        },
+        attribution: '',
+        upstream: 'https://huggingface.co/UsefulSensors/moonshine-base',
+        revision: 'b1e9b6aae3c3c7298f10c3798393fdf38e8fbbad',
+        files: [
+            {
+                path: 'config.json',
+                sha256: 'fab7241d1e9fc6c2370c4c6dfb5da79bb54d67ed9ab6b507ac51d29d2abe01d1',
+                size: 922,
+            },
+            {
+                path: 'generation_config.json',
+                sha256: 'f9b3f711b57be7def2e50a8942f64f36ee0a55fad5b84ff93a687b6c5bcc1d44',
+                size: 147,
+            },
+            {
+                path: 'preprocessor_config.json',
+                sha256: 'fa43a7017ef85cd1d0fba0d9aae77c8adb16990ae6f11115631f41ec5d8aa679',
+                size: 128,
+            },
+            {
+                path: 'special_tokens_map.json',
+                sha256: 'ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356',
+                size: 3,
+            },
+            {
+                path: 'tokenizer.json',
+                sha256: '7b913404bdd039af4756783218af4440bc07fb7d6d8258d677e34f95b3ec416f',
+                size: 3761754,
+            },
+            {
+                path: 'tokenizer_config.json',
+                sha256: 'edaee394565d428ea98a663ae7209cdcfeefc5585c42d7a570ff7c986df2cd15',
+                size: 135735,
+            },
+            {
+                path: 'onnx/encoder_model_quantized.onnx',
+                sha256: '1dd9ab0a7f987113d30affcba5a068d11c8f90fa0223caa3e491ade431ad9751',
+                size: 20513063,
+            },
+            {
+                path: 'onnx/decoder_model_merged_quantized.onnx',
+                sha256: 'cc9f3cd6698a369c6008b41aa60aa3fb3322e7f03c9bdf19d8e6b7200afca4f3',
+                size: 42498870,
+            },
+        ],
+    },
+    'moonshine-tiny-en': {
+        id: 'moonshine-tiny-en',
+        version: '0.0.1',
+        name: 'Moonshine Tiny (English)',
+        task: 'stt',
+        engine: 'transformers.js',
+        dtype: 'q8',
+        languages: ['en'],
+        where: ['device'],
+        streaming: false,
+        licence: {
+            weights: 'MIT',
+            code: 'MIT',
+        },
+        attribution: '',
+        upstream: 'https://huggingface.co/UsefulSensors/moonshine-tiny',
+        revision: 'a6da1241cd305dcd64eab1edbd615f2bb9aabb95',
+        files: [
+            {
+                path: 'config.json',
+                sha256: '558e1e02069137c796ace1e50c48d8fe451f04a295929138e6bea885517f0edb',
+                size: 921,
+            },
+            {
+                path: 'generation_config.json',
+                sha256: 'f9b3f711b57be7def2e50a8942f64f36ee0a55fad5b84ff93a687b6c5bcc1d44',
+                size: 147,
+            },
+            {
+                path: 'preprocessor_config.json',
+                sha256: 'fa43a7017ef85cd1d0fba0d9aae77c8adb16990ae6f11115631f41ec5d8aa679',
+                size: 128,
+            },
+            {
+                path: 'special_tokens_map.json',
+                sha256: 'ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356',
+                size: 3,
+            },
+            {
+                path: 'tokenizer.json',
+                sha256: '7b913404bdd039af4756783218af4440bc07fb7d6d8258d677e34f95b3ec416f',
+                size: 3761754,
+            },
+            {
+                path: 'tokenizer_config.json',
+                sha256: 'edaee394565d428ea98a663ae7209cdcfeefc5585c42d7a570ff7c986df2cd15',
+                size: 135735,
+            },
+            {
+                path: 'onnx/encoder_model_quantized.onnx',
+                sha256: 'c6fc4b7bc5af75c0591fd157a1f3829b533d18e9769a888fd95a62e470dd4f4a',
+                size: 7937661,
+            },
+            {
+                path: 'onnx/decoder_model_merged_quantized.onnx',
+                sha256: 'eed87831c3a6103534aae7d47a5d485025c659a1323901513961c39fe8a1a367',
+                size: 20243286,
+            },
+        ],
+    },
+    'silero-vad': {
+        id: 'silero-vad',
+        version: '0.0.1',
+        name: 'Silero VAD',
+        task: 'vad',
+        engine: 'vad-web',
+        dtype: 'fp32',
+        languages: [],
+        where: ['device'],
+        streaming: true,
+        licence: {
+            weights: 'MIT',
+            code: 'ISC',
+        },
+        attribution: '',
+        upstream: 'https://github.com/snakers4/silero-vad',
+        revision: '0.0.31',
+        files: [
+            {
+                path: 'silero_vad_legacy.onnx',
+                sha256: 'a35ebf52fd3ce5f1469b2a36158dba761bc47b973ea3382b3186ca15b1f5af28',
+                size: 1807522,
+            },
+        ],
+    },
+    'whisper-base': {
+        id: 'whisper-base',
+        version: '0.0.1',
+        name: 'Whisper Base',
+        task: 'stt',
+        engine: 'transformers.js',
+        dtype: 'q8',
+        languages: ['en', 'fr'],
+        where: ['device'],
+        streaming: false,
+        licence: {
+            weights: 'MIT',
+            code: 'MIT',
+        },
+        attribution: '',
+        upstream: 'https://huggingface.co/openai/whisper-base',
+        revision: '1846881b6b3a3024392c1eea3ad983695bc23925',
+        files: [
+            {
+                path: 'config.json',
+                sha256: 'f4d0608f7d918166da7edb3e188de5ef1bfe70d9802e785d271fd88111e9cf4b',
+                size: 2243,
+            },
+            {
+                path: 'generation_config.json',
+                sha256: '61070cf8de25b1e9256e8e102ded49d8d24a8369ed36ef84fdf21549e68125a0',
+                size: 3832,
+            },
+            {
+                path: 'preprocessor_config.json',
+                sha256: 'a6a76d28c93edb273669eb9e0b0636a2bddbb1272c3261e47b7ca6dfdbac1b8d',
+                size: 339,
+            },
+            {
+                path: 'special_tokens_map.json',
+                sha256: 'e67ae3a0aaa99abcd9f187138e12db1f65c16a14761c50ef10eef2c174a7a691',
+                size: 2194,
+            },
+            {
+                path: 'tokenizer.json',
+                sha256: '27fc476bfe7f17299480be2273fc0608e4d5a99aba2ab5dec5374b4482d1a566',
+                size: 2480466,
+            },
+            {
+                path: 'tokenizer_config.json',
+                sha256: '2e036e4dbacfdeb7242c7d4ec4149f4a16e86026048f94d1637e3a8ee9c6a573',
+                size: 282682,
+            },
+            {
+                path: 'added_tokens.json',
+                sha256: '9715fd2243b6f06a5858b5e32950d2853f73dd5bc201aafcf76f5082a2d8acd1',
+                size: 34604,
+            },
+            {
+                path: 'normalizer.json',
+                sha256: 'bf1c507dc8724ca9cf9903640dacfb69dae2f00edee4f21ceba106a7392f26dd',
+                size: 52666,
+            },
+            {
+                path: 'vocab.json',
+                sha256: '50d6a919f0a0601d56a04eb583c780d18553aa388254ba3158eb6a00f13e2c1a',
+                size: 1036584,
+            },
+            {
+                path: 'onnx/encoder_model_quantized.onnx',
+                sha256: '5862993336bf33acd23736071aae2b32261d3b1b2f37780194460d4ef974dd46',
+                size: 23201314,
+            },
+            {
+                path: 'onnx/decoder_model_merged_quantized.onnx',
+                sha256: 'fa3ef9902734ce5ae6f9ef2bdb2ba9a6c4b5785b09f4f420ce036573dc9d090b',
+                size: 53693315,
+            },
+        ],
+    },
+};
+/** Whether a voice speaks a language: `fr` and `fr-FR` are spoken by a `fr-FR` voice. */
+export function voiceSpeaks(voice, language) {
+    return voice.languages.some(own => own === language || own.split('-')[0] === language);
+}
+/** The voice a language is spoken with when none is said: the first that speaks it. */
+export function voiceFor(language) {
+    const voices = Object.values(VOICE_CATALOGUE);
+    return (voices.find(voice => voice.languages.includes(language)) ??
+        voices.find(voice => voiceSpeaks(voice, language.split('-')[0])));
+}
+/**
+ * The speech-to-text model for a language, on the device: Moonshine where it
+ * hears it, Whisper otherwise (VOICE.md decision 3).
+ */
+export function transcriberFor(language) {
+    const base = language.split('-')[0];
+    const hearing = Object.values(SPEECH_MODEL_CATALOGUE).filter(model => model.task === 'stt' &&
+        model.where.includes('device') &&
+        model.languages.includes(base));
+    return (hearing.find(model => model.id === 'moonshine-tiny-en') ??
+        hearing.find(model => model.id.startsWith('moonshine-')) ??
+        hearing[0]);
+}

package/lib/types/agents.d.ts

@@ -3,7 +3,7 @@
  */
 import type { Agentspec } from './agentspecs';
 import type { AgentConnection } from './connection';
-export type AgentLibrary = 'pydantic-ai' | 'langchain' | 'google-adk';
+export type AgentLibrary = 'pydantic-ai' | 'langchain';
 /**
  * Unified agent status covering runtime lifecycle and UI lifecycle.
  */

package/lib/types/agentspecs.d.ts

@@ -450,6 +450,20 @@ export interface AppSurfaceSpec {
     composedBy: string;
     composedAt: string;
 }
+/**
+ * An application's voice (VOICE.md VO-41), off unless said: whether a person
+ * may talk to it, whether its answers are heard, with which voice of the
+ * catalogue (`specs/voices`), in which language (BCP 47) and where its
+ * speech runs.
+ */
+export interface AppVoiceSpec {
+    enabled: boolean;
+    input: 'off' | 'push_to_talk' | 'hands_free';
+    output: 'off' | 'on_request' | 'always';
+    voice: string;
+    language: string;
+    where: 'auto' | 'device' | 'server';
+}
 /** What the user of an application sees. */
 export interface AppInterfaceSpec {
     layout: AppLayout;
@@ -465,6 +479,8 @@ export interface AppInterfaceSpec {
      * Said, it wins over the one the person chose in their settings.
      */
     assistant?: AppAssistantCharacter;
+    /** Its voice: off unless said (VO-41); absent from a spec made before voice. */
+    voice?: AppVoiceSpec;
 }
 export interface AppTestCaseSpec {
     ask: string;

package/lib/types/chat.d.ts

@@ -29,6 +29,7 @@ import type { FrontendToolDefinition } from './tools';
 import type { PoweredByTagProps } from '../chat/display/PoweredByTag';
 import type { EphemeralRuntimeOverride } from '../chat/notebook/EphemeralNotebook';
 import type { EphemeralDocumentCollaboration } from '../chat/document/EphemeralDocument';
+import type { ChatVoice } from '../voice';
 /**
  * Context passed to tool-call pre-hooks.
  * Fires when a tool call starts executing (backend or frontend).
@@ -976,6 +977,16 @@ export interface ChatBaseProps {
      * with *Approve* and *Deny* (T-23).
      */
     trailingContent?: ReactNode;
+    /**
+     * Its voice (VOICE.md V1): a microphone in the composer, push-to-talk,
+     * what is said heard on the device and put in the composer — or sent, with
+     * *Send what I say* — marked as spoken (VO-27).
+     */
+    voice?: ChatVoice;
+    /** The agent is speaking: the composer offers *Stop speaking* (`Esc`). */
+    voiceSpeaking?: boolean;
+    /** Stops the agent's voice: the composer's *Stop speaking*, and the microphone opening (VO-13). */
+    onStopSpeaking?: () => void;
     /**
      * Show the information icon in the header.
      * When clicked, fires onInformationClick.

package/lib/voice/VoiceInput.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Push-to-talk in the composer (VOICE.md VO-10, VO-61, VO-62, VO-65 to VO-68).
+ *
+ * The microphone button: pressed and held, or clicked to start and clicked
+ * to stop; `Ctrl`+`Space` held does the same, and `Esc` cancels. While it
+ * listens the button says *Listening* and a meter shows the level (still,
+ * and said in words, for a reader who asks for reduced motion). Released,
+ * what was said is heard on the device and given to `onTranscript`: put in
+ * the composer, or sent at once when *Send what I say* is on. The first time,
+ * one sentence says where the audio goes before the browser asks.
+ *
+ * @module voice/VoiceInput
+ */
+import type { JSX } from 'react';
+import type { DeviceHearing } from './hearing';
+import type { Transcript } from './types';
+/** What the microphone is doing, said in words (VO-67, VO-68). */
+export type ListeningState = 'idle' | 'asking' | 'loading' | 'listening' | 'hearing';
+export interface VoiceInputProps {
+    hearing: DeviceHearing;
+    /** The language listened to, BCP 47. */
+    language: string;
+    /** What was said, once heard. */
+    onTranscript: (transcript: Transcript) => void;
+    /** The microphone opens: the agent stops speaking (VO-13). */
+    onListen?: () => void;
+    /** Whose consent is remembered: the application's id. */
+    consentKey: string;
+    disabled?: boolean;
+    /** The agent is speaking: offer to stop it. */
+    speaking?: boolean;
+    onStopSpeaking?: () => void;
+}
+export declare function VoiceInput({ hearing, language, onTranscript, onListen, consentKey, disabled, speaking, onStopSpeaking, }: VoiceInputProps): JSX.Element;
+export default VoiceInput;

package/lib/voice/VoiceInput.js

@@ -0,0 +1,233 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Button, IconButton, Text, Tooltip } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { MicrophoneIcon } from '@datalayer/icons-react';
+import { MuteIcon } from '@primer/octicons-react';
+import { MicrophoneRefused, openMicrophone } from './capture';
+import { CONSENT_SENTENCE, consent, consented } from './consent';
+const WORDS = {
+    idle: '',
+    asking: '',
+    loading: 'Getting ready to listen…',
+    listening: 'Listening… let go to stop, Esc to cancel',
+    hearing: 'Hearing what you said…',
+};
+/** A press shorter than this is a click: it starts, and the next click stops. */
+const CLICK_MS = 300;
+function prefersStill() {
+    return (typeof window !== 'undefined' &&
+        !!window.matchMedia?.('(prefers-reduced-motion: reduce)').matches);
+}
+export function VoiceInput({ hearing, language, onTranscript, onListen, consentKey, disabled = false, speaking = false, onStopSpeaking, }) {
+    const [state, setState] = useState('idle');
+    const [said, setSaid] = useState('');
+    const [problem, setProblem] = useState();
+    const [progress, setProgress] = useState();
+    const capture = useRef(undefined);
+    const pressedAt = useRef(0);
+    const stopOnRelease = useRef(false);
+    const meter = useRef(null);
+    const stateRef = useRef(state);
+    stateRef.current = state;
+    const start = useCallback(async () => {
+        if (disabled || stateRef.current !== 'idle') {
+            return;
+        }
+        if (!consented(consentKey)) {
+            setState('asking');
+            return;
+        }
+        setProblem(undefined);
+        onListen?.();
+        try {
+            setState('loading');
+            // The models load once, on first use, with their progress shown.
+            await hearing.ready(language, (loaded, total) => setProgress(total ? Math.round((loaded / total) * 100) : undefined));
+            setProgress(undefined);
+            if (stateRef.current !== 'loading') {
+                return;
+            }
+            capture.current = await openMicrophone();
+            setState('listening');
+            setSaid('Listening');
+        }
+        catch (error) {
+            setState('idle');
+            setProgress(undefined);
+            setProblem(error instanceof MicrophoneRefused || error instanceof Error
+                ? error.message
+                : 'The microphone could not be opened.');
+        }
+    }, [consentKey, disabled, hearing, language, onListen]);
+    const stop = useCallback(async () => {
+        const open = capture.current;
+        capture.current = undefined;
+        if (!open) {
+            if (stateRef.current === 'loading') {
+                setState('idle');
+            }
+            return;
+        }
+        setState('hearing');
+        try {
+            const audio = await open.stop();
+            const transcript = await hearing.hear(audio, language);
+            setState('idle');
+            if (!transcript) {
+                setSaid('Nothing was heard.');
+                return;
+            }
+            setSaid(`Heard: ${transcript.text}`);
+            onTranscript(transcript);
+        }
+        catch (error) {
+            setState('idle');
+            setProblem(error instanceof Error
+                ? error.message
+                : 'What you said could not be heard.');
+        }
+    }, [hearing, language, onTranscript]);
+    const cancel = useCallback(() => {
+        capture.current?.cancel();
+        capture.current = undefined;
+        if (stateRef.current !== 'idle') {
+            setState('idle');
+            setSaid('Cancelled.');
+        }
+    }, []);
+    // The key: Ctrl+Space held listens; Esc cancels, or stops the voice.
+    useEffect(() => {
+        const down = (event) => {
+            if (event.code === 'Space' && event.ctrlKey && !event.repeat) {
+                event.preventDefault();
+                pressedAt.current = Date.now();
+                void start();
+            }
+            else if (event.key === 'Escape') {
+                if (stateRef.current !== 'idle') {
+                    cancel();
+                }
+                else if (speaking) {
+                    onStopSpeaking?.();
+                }
+            }
+        };
+        const up = (event) => {
+            if (event.code === 'Space' || event.key === 'Control') {
+                if (stateRef.current === 'listening' ||
+                    stateRef.current === 'loading') {
+                    void stop();
+                }
+            }
+        };
+        // A hidden tab closes the microphone (VO-62).
+        const hidden = () => {
+            if (document.hidden) {
+                cancel();
+            }
+        };
+        window.addEventListener('keydown', down);
+        window.addEventListener('keyup', up);
+        document.addEventListener('visibilitychange', hidden);
+        return () => {
+            window.removeEventListener('keydown', down);
+            window.removeEventListener('keyup', up);
+            document.removeEventListener('visibilitychange', hidden);
+        };
+    }, [cancel, onStopSpeaking, speaking, start, stop]);
+    // The level meter, moving while it listens — still under reduced motion.
+    useEffect(() => {
+        if (state !== 'listening' || prefersStill()) {
+            return;
+        }
+        let frame = 0;
+        const draw = () => {
+            const level = capture.current?.level() ?? 0;
+            if (meter.current) {
+                meter.current.style.transform = `scaleX(${Math.max(0.04, level)})`;
+            }
+            frame = requestAnimationFrame(draw);
+        };
+        frame = requestAnimationFrame(draw);
+        return () => cancelAnimationFrame(frame);
+    }, [state]);
+    // Never left open behind the page.
+    useEffect(() => () => capture.current?.cancel(), []);
+    const listening = state === 'listening';
+    const label = listening
+        ? 'Listening — let go to stop'
+        : 'Hold to talk (Ctrl+Space)';
+    return (_jsxs(Box, { "data-voice-input": state, sx: {
+            display: 'inline-flex',
+            alignItems: 'center',
+            gap: 1,
+            position: 'relative',
+        }, children: [speaking && onStopSpeaking && (_jsx(Tooltip, { text: "Stop speaking (Esc)", direction: "n", children: _jsx(IconButton, { icon: MuteIcon, "aria-label": "Stop speaking", size: "small", variant: "invisible", "data-voice-stop": "", onClick: onStopSpeaking }) })), listening && (_jsx(Box, { "aria-hidden": "true", sx: {
+                    width: 40,
+                    height: 4,
+                    borderRadius: 2,
+                    bg: 'neutral.muted',
+                    overflow: 'hidden',
+                }, children: _jsx(Box, { ref: meter, sx: {
+                        width: '100%',
+                        height: '100%',
+                        bg: 'danger.emphasis',
+                        transformOrigin: 'left',
+                        transform: prefersStill() ? 'scaleX(1)' : 'scaleX(0.04)',
+                    } }) })), (state === 'loading' || state === 'hearing') && (_jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, "data-voice-progress": "", children: state === 'loading' && progress !== undefined ? `${progress}%` : '…' })), _jsx(Tooltip, { text: label, direction: "n", children: _jsx(IconButton, { icon: () => _jsx(MicrophoneIcon, { size: 16 }), "aria-label": label, "aria-pressed": listening, size: "small", variant: listening ? 'danger' : 'invisible', disabled: disabled || state === 'hearing', "data-voice-mic": "", onPointerDown: event => {
+                        if (event.button !== 0) {
+                            return;
+                        }
+                        pressedAt.current = Date.now();
+                        // A second press of click-to-talk stops at its release.
+                        stopOnRelease.current = stateRef.current === 'listening';
+                        if (stateRef.current === 'idle') {
+                            void start();
+                        }
+                    }, onPointerUp: () => {
+                        // Held: letting go stops. A click: it goes on until the next one.
+                        if (stopOnRelease.current ||
+                            Date.now() - pressedAt.current >= CLICK_MS) {
+                            stopOnRelease.current = false;
+                            void stop();
+                        }
+                    }, onKeyDown: event => {
+                        // Enter or Space on the focused button toggles, for the keyboard (VO-66).
+                        if (event.key === 'Enter' || event.key === ' ') {
+                            event.preventDefault();
+                            if (stateRef.current === 'listening') {
+                                void stop();
+                            }
+                            else {
+                                void start();
+                            }
+                        }
+                    } }) }), state === 'asking' && (_jsxs(Box, { role: "dialog", "aria-label": "Talk instead of typing", "data-voice-consent": "", sx: {
+                    position: 'absolute',
+                    bottom: '100%',
+                    right: 0,
+                    mb: 2,
+                    width: 280,
+                    p: 3,
+                    bg: 'canvas.overlay',
+                    border: '1px solid',
+                    borderColor: 'border.default',
+                    borderRadius: 2,
+                    boxShadow: 'shadow.large',
+                    zIndex: 10,
+                }, children: [_jsx(Text, { as: "p", sx: { fontSize: 1, mb: 2 }, children: CONSENT_SENTENCE }), _jsxs(Box, { sx: { display: 'flex', gap: 2, justifyContent: 'flex-end' }, children: [_jsx(Button, { size: "small", onClick: () => setState('idle'), children: "Not now" }), _jsx(Button, { size: "small", variant: "primary", "data-voice-consent-yes": "", onClick: () => {
+                                    consent(consentKey);
+                                    // Asked, and said yes: listen now, without another press.
+                                    stateRef.current = 'idle';
+                                    setState('idle');
+                                    void start();
+                                }, children: "Use the microphone" })] })] })), _jsx(Box, { as: "span", role: "status", "aria-live": "polite", sx: {
+                    position: 'absolute',
+                    width: 1,
+                    height: 1,
+                    overflow: 'hidden',
+                    clip: 'rect(0 0 0 0)',
+                }, children: WORDS[state] || said }), problem && (_jsx(Text, { role: "alert", sx: { fontSize: 0, color: 'danger.fg', maxWidth: 220 }, "data-voice-problem": "", children: problem }))] }));
+}
+export default VoiceInput;