Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

4.1 KB
Raw Blame
import {
  DICTATION_UNAVAILABLE,
  VOICE_DICTATION_LIMITS,
  createDictationSession,
  dictationControlStatus,
  dictationUnavailableReason,
  type DictationDependencies,
  type DictationDraft,
  type DictationIdentity,
  type DictationTranscriptionCapability,
} from "@akeru/client-runtime/dictation";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";

import type { DictationControlsProps } from "../components/DictationControls";
import { startExpoDictationCapture } from "./expoDictationCapture";

type ComposerDictationSession = ReturnType<typeof createDictationSession>;

export interface ComposerDictationBinding {
  readonly identity: DictationIdentity;
  readonly connected: boolean;
  readonly callActive: boolean;
  readonly captureAvailable?: boolean;
  readonly captureReason?: string | null;
  readonly transcribe?: DictationDependencies["transcribe"] | null;
  /** Omit when the caller only knows transcription is wired; failures still surface after release. */
  readonly transcription?: DictationTranscriptionCapability;
  readonly getDraft: () => DictationDraft;
  readonly applyDraft: (draft: DictationDraft) => void;
  readonly createSession?: (
    dependencies: Omit<DictationDependencies, "capture">,
  ) => ComposerDictationSession;
}

function nativeSession(dependencies: Omit<DictationDependencies, "capture">) {
  return createDictationSession(
    { ...dependencies, capture: startExpoDictationCapture },
    VOICE_DICTATION_LIMITS,
  );
}

export function useComposerDictation(
  input: ComposerDictationBinding,
): DictationControlsProps & { readonly errorMessage: string | null } {
  const getDraft = useRef(input.getDraft);
  getDraft.current = input.getDraft;
  const applyDraft = useRef(input.applyDraft);
  applyDraft.current = input.applyDraft;
  const transcribe = useRef(input.transcribe);
  transcribe.current = input.transcribe;

  const unavailableReason = dictationUnavailableReason({
    callActive: input.callActive,
    connected: input.connected,
    captureAvailable: input.captureAvailable ?? true,
    captureReason: input.captureReason ?? null,
    transcriptionAvailable: input.transcription?.available ?? true,
    transcriptionReason:
      input.transcription && !input.transcription.available ? input.transcription.reason : null,
  });

  const session = useMemo(
    () =>
      (input.createSession ?? nativeSession)({
        schedule: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
        // SAFETY: The session returns the exact handle allocated by this schedule callback.
        cancelSchedule: (timer) => globalThis.clearTimeout(timer as ReturnType<typeof setTimeout>),
        transcribe: (request) => {
          const operation = transcribe.current;

          if (!operation) {
            return Promise.reject(new Error(DICTATION_UNAVAILABLE.transcription));
          }

          return operation(request);
        },
        updateDraft: (update) => applyDraft.current(update(getDraft.current())),
      }),
    [input.createSession],
  );

  const [status, setStatus] = useState(() => dictationControlStatus(session.status));
  useEffect(
    () => session.subscribe(() => setStatus(dictationControlStatus(session.status))),
    [session],
  );
  useEffect(() => {
    session.updateContext(input.identity, input.connected && !input.callActive);
  }, [input.callActive, input.connected, input.identity, session]);
  useEffect(() => () => session.dispose(), [session]);

  const onStart = useCallback(() => {
    if (unavailableReason) return;

    return session.start(getDraft.current());
  }, [session, unavailableReason]);

  const onRelease = useCallback(() => {
    return session.finish();
  }, [session]);

  const onCancel = useCallback(() => {
    session.cancel();
  }, [session]);

  return {
    status,
    unavailableReason,
    errorMessage: status === "failed" ? describeDictationFailure(session.error) : null,
    onStart,
    onRelease,
    onCancel,
  };
}

function describeDictationFailure(cause: unknown): string {
  if (cause instanceof Error && cause.message.trim()) return cause.message;

  return "Dictation failed.";
}