@alia.onl/sdk 7.2.8 → 8.0.0

package/src/index.ts

@@ -64,24 +64,10 @@ export type {
 export { Button, buttonVariants, buttonTextVariants } from './components/ui/button';
 export type { ButtonProps } from './components/ui/button';
 export { Text, TextClassContext } from './components/ui/text';
-export { ChatTextInput } from './components/ui/chat-text-input';
 export { cn, formatFileSize } from './lib/utils';
 export { getToolLabel, getToolActiveLabel, getResearchActiveLabel } from './lib/tool-registry';
 export { getTextFromContent, getImagesFromContent } from './lib/content-utils';
 
-// ── PromptInput ──
-export { PromptInput } from './components/ui/prompt-input/prompt-input';
-export type { PromptInputProps } from './components/ui/prompt-input/prompt-input';
-export { usePromptInput, useIsFullscreen, PromptInputContext } from './components/ui/prompt-input/context';
-export type { Attachment, Completion, PromptInputContextType } from './components/ui/prompt-input/context';
-export { PromptInputTextarea } from './components/ui/prompt-input/textarea';
-export { PromptInputActions } from './components/ui/prompt-input/actions';
-export { PromptInputSubmitButton } from './components/ui/prompt-input/submit-button';
-export { PromptInputMicButton } from './components/ui/prompt-input/mic-button';
-export { PromptInputAddMenu } from './components/ui/prompt-input/add-menu';
-export { PromptInputAttachments } from './components/ui/prompt-input/attachments';
-export { PromptInputAutocomplete } from './components/ui/prompt-input/autocomplete';
-
 // ── Picker hooks ──
 export { useImagePicker } from './hooks/useImagePicker';
 export type { ImagePickerAsset } from './hooks/useImagePicker';

package/src/lib/audio-level.ts

@@ -2,8 +2,9 @@
  * How audio becomes the ambient field's 0..1 level — one curve, one pair of
  * time constants, for every source that drives it.
  *
- * Dictation got here first and is the reference: the recorder reports dBFS,
- * `useSpeechToText` normalises it against a -60 floor, and `useAmbientWave`
+ * Dictation got here first and is the reference: the microphone's level is
+ * taken as dBFS (on web, from an analyser beside the recognizer —
+ * `speech-recognition.ts`), normalised against a -60 floor, and `useAmbientWave`
  * smooths it with a fast attack and a slow decay before it reaches
  * `AmbientField`. That is the behaviour people like, so it is the behaviour
  * everything else adopts rather than re-invents — including "read aloud", which

package/src/lib/chat-transport.ts

@@ -18,6 +18,15 @@ export interface AliaChatRequest {
   readonly url: string;
   readonly model: string;
   readonly messages: ReadonlyArray<{ readonly role: string; readonly content: string }>;
+  /**
+   * `'voice'` asks for an answer meant to be heard: short, conversational, no
+   * formatting (the API layers its voice response profile over the turn's
+   * prompt). Omitted for ordinary text chat, which sends exactly what it
+   * always sent.
+   */
+  readonly responseMode?: 'voice';
+  /** The agent whose thread this turn belongs to, when there is one. */
+  readonly agentId?: string;
 }
 
 /**
@@ -42,6 +51,8 @@ export async function streamAliaChat(
       model: request.model,
       messages: request.messages,
       stream: true,
+      ...(request.responseMode === undefined ? {} : { responseMode: request.responseMode }),
+      ...(request.agentId === undefined ? {} : { agentId: request.agentId }),
     }),
     signal,
   });

package/src/lib/speech-language.ts

@@ -0,0 +1,20 @@
+/**
+ * The language to recognize when the caller names none.
+ *
+ * The browser's own language on web; the runtime's resolved locale on native
+ * (Hermes implements `Intl`); `en-US` when neither answers. An app should pass
+ * its UI locale instead — the Alia app does — because a person who chose
+ * Spanish in the app expects to be understood in Spanish whatever the device
+ * is set to.
+ */
+export function defaultSpeechLanguage(): string {
+  const browser = globalThis.navigator?.language;
+  if (typeof browser === 'string' && browser !== '') return browser;
+  try {
+    const resolved = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (resolved) return resolved;
+  } catch {
+    // No Intl on this runtime.
+  }
+  return 'en-US';
+}

package/src/lib/speech-messages.ts

@@ -0,0 +1,31 @@
+import type { SpeechRecognitionFailure } from './speech-recognition-types';
+
+/**
+ * The copy a person sees when listening fails — the same sentences dictation
+ * and voice mode used when they recorded through `expo-audio` and LiveKit, so
+ * moving recognition onto the device did not change what an error says.
+ *
+ * `null` for the failures that are not errors: `aborted` is a stop the caller
+ * asked for, and `no-speech` is a silence the caller recovers from.
+ */
+export function speechFailureMessage(failure: SpeechRecognitionFailure): string | null {
+  switch (failure.code) {
+    case 'aborted':
+    case 'no-speech':
+      return null;
+    case 'unsupported':
+      return 'Speech recognition is not available on this device or browser';
+    case 'not-allowed':
+      return 'Microphone permission required';
+    case 'audio-capture':
+      return failure.detail === 'NotReadableError' || failure.detail === 'TrackStartError'
+        ? 'Microphone is in use by another application'
+        : 'No microphone found — check your input devices';
+    case 'network':
+      return 'Speech recognition needs a network connection';
+    case 'language-not-supported':
+      return 'Speech recognition does not support this language';
+    case 'other':
+      return 'Speech recognition failed';
+  }
+}

package/src/lib/speech-recognition-types.ts

@@ -0,0 +1,75 @@
+/**
+ * The one shape on-device speech recognition has in this package.
+ *
+ * Two engines sit behind it and neither leaks through: the browser's Web
+ * Speech API (`speech-recognition.ts`, picked by web bundlers and by tests) and
+ * `expo-speech-recognition` on iOS and Android (`speech-recognition.native.ts`,
+ * picked by Metro's platform resolution). Dictation and the voice loop are
+ * written against this file only, so the audio never leaves the device through
+ * Alia — there is no transcription endpoint, and nothing here posts audio
+ * anywhere. Whether the ENGINE uses a network service is the platform's
+ * business and is stated in `docs/voice.mdx`.
+ */
+
+/** Why a recognition session failed, in the vocabulary both engines share. */
+export type SpeechRecognitionFailureCode =
+  /** Microphone or speech-recognition permission was refused. */
+  | 'not-allowed'
+  /** No microphone, or it could not be opened. */
+  | 'audio-capture'
+  /** The engine needed the network and could not reach it. */
+  | 'network'
+  /** The engine does not recognize this language. */
+  | 'language-not-supported'
+  /** Nothing was said before the engine gave up. Recoverable: start again. */
+  | 'no-speech'
+  /** The session was aborted on purpose. Never an error to report. */
+  | 'aborted'
+  /** Recognition is not available on this device or in this browser. */
+  | 'unsupported'
+  /** Anything else — the engine was busy, interrupted, or said nothing useful. */
+  | 'other';
+
+export interface SpeechRecognitionFailure {
+  readonly code: SpeechRecognitionFailureCode;
+  /** The engine's own words, for logs. Never shown as-is. */
+  readonly detail?: string;
+}
+
+export interface SpeechRecognitionHandlers {
+  /**
+   * The whole of what this session has heard so far, and whether the engine
+   * considers it settled. It is the FULL transcript each time, never a delta:
+   * both engines revise earlier words as more audio arrives.
+   */
+  onResult(result: { transcript: string; isFinal: boolean }): void;
+  /** Input level, 0..1, on the same scale as dictation's metering. */
+  onLevel?(level: number): void;
+  onError(failure: SpeechRecognitionFailure): void;
+  /** The session is over, whichever way it ended. Always the last call. */
+  onEnd(): void;
+}
+
+export interface SpeechRecognitionOptions {
+  /** BCP-47 tag, e.g. `es-ES`. */
+  readonly lang: string;
+  /**
+   * Remove the device's own playback from what the microphone hears, where the
+   * platform can (iOS voice processing). Voice mode listens while it speaks,
+   * so without this it can hear itself.
+   */
+  readonly echoCancellation?: boolean;
+}
+
+export interface SpeechRecognitionSession {
+  /** Stop listening and deliver a final result, then `onEnd`. */
+  stop(): void;
+  /** Stop listening and discard; `onEnd` still follows. */
+  abort(): void;
+}
+
+/** Map a raw 0..1-ish reading to the field's level, clamped. */
+export function clampLevel(level: number): number {
+  if (!Number.isFinite(level)) return 0;
+  return Math.min(1, Math.max(0, level));
+}

package/src/lib/speech-recognition.native.ts

@@ -0,0 +1,171 @@
+/**
+ * On-device speech recognition for iOS and Android, through
+ * `expo-speech-recognition` (Apple's Speech framework, Android's
+ * `SpeechRecognizer`). Metro picks this file over `speech-recognition.ts` on
+ * native; the contract is `speech-recognition-types.ts`.
+ *
+ * `expo-speech-recognition` is a peer of the SDK and a native module: an app
+ * must depend on it (the root entry's dictation reaches this file) and list its
+ * config plugin (which writes `NSSpeechRecognitionUsageDescription`,
+ * `NSMicrophoneUsageDescription` and Android's `RECORD_AUDIO` plus the
+ * recognizer-package visibility query), then ship a new native build.
+ *
+ * The module is a process-wide singleton — one recognition at a time — so the
+ * hooks never start a session before the previous one has reported `onEnd`. A
+ * late `end` from an aborted session would otherwise land on its successor's
+ * listeners.
+ */
+
+import type { ExpoSpeechRecognitionErrorCode, ExpoSpeechRecognitionModule as NativeModule } from 'expo-speech-recognition';
+import {
+  clampLevel,
+  type SpeechRecognitionFailure,
+  type SpeechRecognitionFailureCode,
+  type SpeechRecognitionHandlers,
+  type SpeechRecognitionOptions,
+  type SpeechRecognitionSession,
+} from './speech-recognition-types';
+
+type SpeechModule = typeof NativeModule;
+
+let loaded: SpeechModule | null | undefined;
+
+/**
+ * The native module, loaded on first use — never at import.
+ *
+ * `expo-speech-recognition` calls `requireNativeModule` when it is imported,
+ * which THROWS in a binary built before the module was added (an older dev
+ * client, Expo Go). This file is reachable from the SDK's root entry through
+ * dictation, so a top-level import would take the whole app down in such a
+ * build over a feature nobody had touched yet. Loaded here, the same build
+ * answers "not available" and everything else keeps working.
+ */
+function speechModule(): SpeechModule | null {
+  if (loaded !== undefined) return loaded;
+  try {
+    loaded = (require('expo-speech-recognition') as typeof import('expo-speech-recognition'))
+      .ExpoSpeechRecognitionModule;
+  } catch {
+    loaded = null;
+  }
+  return loaded;
+}
+
+export function isSpeechRecognitionAvailable(): boolean {
+  try {
+    return speechModule()?.isRecognitionAvailable() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+export async function requestSpeechRecognitionPermission(): Promise<SpeechRecognitionFailure | null> {
+  const module = speechModule();
+  if (module === null || !isSpeechRecognitionAvailable()) return { code: 'unsupported' };
+  try {
+    const permission = await module.requestPermissionsAsync();
+    return permission.granted ? null : { code: 'not-allowed', detail: permission.status };
+  } catch (error: unknown) {
+    return { code: 'other', detail: error instanceof Error ? error.message : 'permission request failed' };
+  }
+}
+
+function failureOf(error: ExpoSpeechRecognitionErrorCode): SpeechRecognitionFailureCode {
+  switch (error) {
+    case 'not-allowed':
+    case 'service-not-allowed':
+      return 'not-allowed';
+    case 'audio-capture':
+      return 'audio-capture';
+    case 'network':
+      return 'network';
+    case 'language-not-supported':
+      return 'language-not-supported';
+    case 'no-speech':
+    case 'speech-timeout':
+      return 'no-speech';
+    case 'aborted':
+      return 'aborted';
+    default:
+      return 'other';
+  }
+}
+
+/** `volumechange` is -2..10, and anything below 0 is inaudible. */
+const VOLUME_CEILING = 10;
+
+export function startSpeechRecognition(
+  options: SpeechRecognitionOptions,
+  handlers: SpeechRecognitionHandlers,
+): SpeechRecognitionSession {
+  const module = speechModule();
+  if (module === null) {
+    handlers.onError({ code: 'unsupported' });
+    handlers.onEnd();
+    return { stop: () => undefined, abort: () => undefined };
+  }
+  const ExpoSpeechRecognitionModule = module;
+  let ended = false;
+  /**
+   * Finals already delivered. Android's continuous mode starts a new segment
+   * after every final result, so the utterance is the settled segments plus
+   * whatever is still in flight; iOS only finalizes on stop and always sends
+   * the whole transcript, so this stays empty there.
+   */
+  let settled = '';
+
+  const subscriptions = [
+    ExpoSpeechRecognitionModule.addListener('result', (event) => {
+      if (ended) return;
+      const current = event.results[0]?.transcript ?? '';
+      const transcript = `${settled} ${current}`.replace(/\s+/g, ' ').trim();
+      if (event.isFinal) settled = transcript;
+      handlers.onResult({ transcript, isFinal: event.isFinal });
+    }),
+    ExpoSpeechRecognitionModule.addListener('error', (event) => {
+      if (ended) return;
+      const code = failureOf(event.error);
+      if (code === 'aborted') return;
+      handlers.onError({ code, detail: event.message });
+    }),
+    ExpoSpeechRecognitionModule.addListener('end', () => finish()),
+    ExpoSpeechRecognitionModule.addListener('volumechange', (event) => {
+      if (ended) return;
+      handlers.onLevel?.(clampLevel(event.value / VOLUME_CEILING));
+    }),
+  ];
+
+  function finish(): void {
+    if (ended) return;
+    ended = true;
+    for (const subscription of subscriptions) subscription.remove();
+    handlers.onLevel?.(0);
+    handlers.onEnd();
+  }
+
+  try {
+    ExpoSpeechRecognitionModule.start({
+      lang: options.lang,
+      interimResults: true,
+      continuous: true,
+      addsPunctuation: true,
+      maxAlternatives: 1,
+      volumeChangeEventOptions: { enabled: handlers.onLevel !== undefined, intervalMillis: 100 },
+      ...(options.echoCancellation ? { iosVoiceProcessingEnabled: true } : {}),
+    });
+  } catch (error: unknown) {
+    if (!ended) handlers.onError({ code: 'other', detail: error instanceof Error ? error.message : 'start failed' });
+    finish();
+  }
+
+  return {
+    stop() {
+      if (ended) return;
+      ExpoSpeechRecognitionModule.stop();
+    },
+    abort() {
+      if (ended) return;
+      ExpoSpeechRecognitionModule.abort();
+    },
+  };
+}

package/src/lib/speech-recognition.ts

@@ -0,0 +1,279 @@
+/**
+ * On-device speech recognition for the web: the browser's Web Speech API.
+ *
+ * Metro resolves `speech-recognition.native.ts` on iOS and Android, so this
+ * file is what a web bundle — and every test — gets. See
+ * `speech-recognition-types.ts` for the contract both implement.
+ *
+ * ## Why a microphone stream is opened beside the recognizer
+ *
+ * The Web Speech API reports words, not sound: there is no level event, and a
+ * refused or missing microphone surfaces as a bare `not-allowed` or
+ * `audio-capture` with nothing to tell "blocked" from "busy". Opening the
+ * microphone first with `getUserMedia` answers both. It is where the browser
+ * asks for permission (once — the recognizer shares the origin's grant), its
+ * DOMException names say exactly what is wrong, and an `AnalyserNode` on the
+ * stream is the honest level the dictation trace and the voice field move to.
+ * The stream is never recorded or sent anywhere.
+ *
+ * ## Support
+ *
+ * Chromium browsers and Safari implement it (Chrome as `webkitSpeechRecognition`
+ * and through a Google speech service; Safari through Apple's). Firefox does
+ * not, and `isSpeechRecognitionAvailable()` says so before anything asks for a
+ * microphone.
+ */
+
+import { levelFromDbfs } from './audio-level';
+import type {
+  SpeechRecognitionFailure,
+  SpeechRecognitionFailureCode,
+  SpeechRecognitionHandlers,
+  SpeechRecognitionOptions,
+  SpeechRecognitionSession,
+} from './speech-recognition-types';
+
+// ── The slice of the Web Speech API this uses ──
+// Declared here rather than taken from lib.dom: TypeScript's DOM library does
+// not ship the prefixed constructor, and the unprefixed one is not everywhere.
+
+interface WebSpeechAlternative { readonly transcript: string }
+interface WebSpeechResult { readonly isFinal: boolean; readonly length: number; readonly [index: number]: WebSpeechAlternative }
+interface WebSpeechResultList { readonly length: number; readonly [index: number]: WebSpeechResult }
+interface WebSpeechResultEvent { readonly results: WebSpeechResultList }
+interface WebSpeechErrorEvent { readonly error: string; readonly message?: string }
+
+interface WebSpeechRecognition {
+  lang: string;
+  continuous: boolean;
+  interimResults: boolean;
+  maxAlternatives: number;
+  onresult: ((event: WebSpeechResultEvent) => void) | null;
+  onerror: ((event: WebSpeechErrorEvent) => void) | null;
+  onend: (() => void) | null;
+  start(): void;
+  stop(): void;
+  abort(): void;
+}
+
+type WebSpeechRecognitionConstructor = new () => WebSpeechRecognition;
+
+function recognitionConstructor(): WebSpeechRecognitionConstructor | null {
+  const scope = globalThis as unknown as {
+    SpeechRecognition?: WebSpeechRecognitionConstructor;
+    webkitSpeechRecognition?: WebSpeechRecognitionConstructor;
+  };
+  return scope.SpeechRecognition ?? scope.webkitSpeechRecognition ?? null;
+}
+
+/** Whether this browser can recognize speech at all. Firefox cannot. */
+export function isSpeechRecognitionAvailable(): boolean {
+  return recognitionConstructor() !== null;
+}
+
+/**
+ * Ask for the microphone before a session needs it.
+ *
+ * The browser asks once per origin; `startSpeechRecognition` opens the stream
+ * itself, so this is only for callers that want the answer up front (voice mode
+ * does, so a refusal ends the call before it starts rather than on the first
+ * word).
+ */
+export async function requestSpeechRecognitionPermission(): Promise<SpeechRecognitionFailure | null> {
+  if (!isSpeechRecognitionAvailable()) return { code: 'unsupported' };
+  const media = globalThis.navigator?.mediaDevices;
+  if (media?.getUserMedia === undefined) return null;
+  try {
+    const stream = await media.getUserMedia({ audio: true });
+    for (const track of stream.getTracks()) track.stop();
+    return null;
+  } catch (error: unknown) {
+    return mediaFailure(error);
+  }
+}
+
+function domErrorName(error: unknown): string {
+  // A DOMException is not always `instanceof Error`, so read `.name` off the object.
+  if (typeof error === 'object' && error !== null && 'name' in error && typeof error.name === 'string') {
+    return error.name;
+  }
+  return '';
+}
+
+function mediaFailure(error: unknown): SpeechRecognitionFailure {
+  const name = domErrorName(error);
+  switch (name) {
+    case 'NotAllowedError':
+    case 'PermissionDeniedError':
+    case 'SecurityError':
+      return { code: 'not-allowed', detail: name };
+    case 'NotFoundError':
+    case 'DevicesNotFoundError':
+    case 'OverconstrainedError':
+    case 'NotReadableError':
+    case 'TrackStartError':
+      return { code: 'audio-capture', detail: name };
+    default:
+      return { code: 'other', detail: name || 'getUserMedia failed' };
+  }
+}
+
+function recognitionFailure(event: WebSpeechErrorEvent): SpeechRecognitionFailure {
+  const map: Record<string, SpeechRecognitionFailureCode> = {
+    'not-allowed': 'not-allowed',
+    'service-not-allowed': 'not-allowed',
+    'audio-capture': 'audio-capture',
+    network: 'network',
+    'language-not-supported': 'language-not-supported',
+    'no-speech': 'no-speech',
+    aborted: 'aborted',
+  };
+  return { code: map[event.error] ?? 'other', detail: event.error };
+}
+
+/** Everything heard so far, as one string: Chrome segments carry their own leading spaces. */
+function transcriptOf(results: WebSpeechResultList): { transcript: string; isFinal: boolean } {
+  let transcript = '';
+  let isFinal = results.length > 0;
+  for (let index = 0; index < results.length; index += 1) {
+    const result = results[index];
+    if (result === undefined) continue;
+    transcript += result[0]?.transcript ?? '';
+    if (!result.isFinal) isFinal = false;
+  }
+  return { transcript: transcript.replace(/\s+/g, ' ').trim(), isFinal };
+}
+
+const LEVEL_INTERVAL_MS = 100;
+
+/** An analyser on the microphone, polled on a clock. Returns its teardown. */
+function meterStream(stream: MediaStream, onLevel: (level: number) => void): () => void {
+  const AudioContextCtor = (globalThis as unknown as { AudioContext?: typeof AudioContext }).AudioContext;
+  if (AudioContextCtor === undefined) return () => undefined;
+  let context: AudioContext;
+  try {
+    context = new AudioContextCtor();
+  } catch {
+    return () => undefined;
+  }
+  if (context.state === 'suspended') context.resume().catch(() => undefined);
+  const analyser = context.createAnalyser();
+  analyser.fftSize = 512;
+  context.createMediaStreamSource(stream).connect(analyser);
+  const buffer = new Float32Array(analyser.fftSize);
+  const timer = setInterval(() => {
+    analyser.getFloatTimeDomainData(buffer);
+    let sum = 0;
+    for (let index = 0; index < buffer.length; index += 1) sum += buffer[index] * buffer[index];
+    const rms = Math.sqrt(sum / buffer.length);
+    onLevel(rms > 0 ? levelFromDbfs(20 * Math.log10(rms)) : 0);
+  }, LEVEL_INTERVAL_MS);
+  return () => {
+    clearInterval(timer);
+    context.close().catch(() => undefined);
+  };
+}
+
+/**
+ * Listen until stopped.
+ *
+ * Continuous with interim results: the caller decides when an utterance is
+ * over (voice mode on a silence timer, dictation on the stop button), because
+ * the browser's own end-of-speech detection cuts people off mid-thought.
+ */
+export function startSpeechRecognition(
+  options: SpeechRecognitionOptions,
+  handlers: SpeechRecognitionHandlers,
+): SpeechRecognitionSession {
+  let recognition: WebSpeechRecognition | null = null;
+  let stream: MediaStream | null = null;
+  let stopMeter: (() => void) | null = null;
+  let ended = false;
+  let stopRequested: 'stop' | 'abort' | null = null;
+
+  const release = (): void => {
+    stopMeter?.();
+    stopMeter = null;
+    if (stream !== null) for (const track of stream.getTracks()) track.stop();
+    stream = null;
+  };
+
+  const finish = (): void => {
+    if (ended) return;
+    ended = true;
+    release();
+    handlers.onLevel?.(0);
+    handlers.onEnd();
+  };
+
+  const fail = (failure: SpeechRecognitionFailure): void => {
+    if (ended) return;
+    handlers.onError(failure);
+    finish();
+  };
+
+  void (async () => {
+    const Recognition = recognitionConstructor();
+    if (Recognition === null) {
+      fail({ code: 'unsupported' });
+      return;
+    }
+
+    const media = globalThis.navigator?.mediaDevices;
+    if (media?.getUserMedia !== undefined) {
+      try {
+        stream = await media.getUserMedia({
+          audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true },
+        });
+      } catch (error: unknown) {
+        fail(mediaFailure(error));
+        return;
+      }
+      if (stopRequested !== null) {
+        finish();
+        return;
+      }
+      if (handlers.onLevel !== undefined) stopMeter = meterStream(stream, handlers.onLevel);
+    }
+
+    const instance = new Recognition();
+    recognition = instance;
+    instance.lang = options.lang;
+    instance.continuous = true;
+    instance.interimResults = true;
+    instance.maxAlternatives = 1;
+    instance.onresult = (event) => {
+      if (ended) return;
+      handlers.onResult(transcriptOf(event.results));
+    };
+    instance.onerror = (event) => {
+      if (ended) return;
+      const failure = recognitionFailure(event);
+      if (failure.code === 'aborted') return;
+      handlers.onError(failure);
+    };
+    instance.onend = finish;
+    try {
+      instance.start();
+    } catch (error: unknown) {
+      fail({ code: 'other', detail: domErrorName(error) || 'start failed' });
+      return;
+    }
+    if (stopRequested === 'stop') instance.stop();
+    if (stopRequested === 'abort') instance.abort();
+  })();
+
+  return {
+    stop() {
+      if (ended) return;
+      stopRequested = 'stop';
+      recognition?.stop();
+    },
+    abort() {
+      if (ended) return;
+      stopRequested = 'abort';
+      if (recognition === null) return;
+      recognition.abort();
+    },
+  };
+}