Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

3.0 KB
Raw Blame
import { useCallback, useRef } from "react";
import type { ChatPersistence } from "./useChatPersistence";
import type { ChatStreaming, SendToAIOptions } from "./useChatStreaming";
import type { Message } from "./types";

interface PersistedMessageContext {
  conversationId: number;
  text: string;
  isFirstMessage: boolean;
}

interface UseChatMessageSenderOptions {
  conversationId: number | null;
  persistence: ChatPersistence;
  streaming: Pick<ChatStreaming, "sendToAI">;
  createConversation: (text: string) => Promise<number>;
  onMessagePersisted?: (context: PersistedMessageContext) => void | Promise<void>;
  onSendingChange?: (sending: boolean) => void;
}

export interface MessageSubmissionLock {
  run: (operation: () => Promise<void>) => Promise<boolean>;
}

export function createMessageSubmissionLock(): MessageSubmissionLock {
  let active = false;

  return {
    async run(operation: () => Promise<void>): Promise<boolean> {
      if (active) return false;
      active = true;
      try {
        await operation();
        return true;
      } finally {
        active = false;
      }
    },
  };
}

export function useChatMessageSender({
  conversationId,
  persistence,
  streaming,
  createConversation,
  onMessagePersisted,
  onSendingChange,
}: UseChatMessageSenderOptions): (text: string, options?: SendToAIOptions) => Promise<boolean> {
  const submissionLockRef = useRef<MessageSubmissionLock | null>(null);
  if (submissionLockRef.current === null) {
    submissionLockRef.current = createMessageSubmissionLock();
  }

  return useCallback(
    async (text: string, options?: SendToAIOptions) => {
      const version = persistence.getSessionVersion?.();
      const isCurrent = () => version === persistence.getSessionVersion?.();
      let submitted = false;
      const accepted = await submissionLockRef.current!.run(async () => {
        onSendingChange?.(true);
        try {
          const convId = conversationId ?? (await createConversation(text));
          if (!isCurrent()) return;
          const previousMessages = persistence.messages;
          const userMessage: Message = {
            id: crypto.randomUUID(),
            role: "user",
            content: text,
            isStreaming: false,
          };

          persistence.setMessages((messages) => [...messages, userMessage]);
          await persistence.saveUserMessage(text);
          if (!isCurrent()) return;
          await onMessagePersisted?.({
            conversationId: convId,
            text,
            isFirstMessage: previousMessages.length === 0,
          });
          if (!isCurrent()) return;
          submitted = true;
          await streaming.sendToAI(text, [...previousMessages, userMessage], options);
        } catch (error) {
          if (isCurrent()) throw error;
        } finally {
          onSendingChange?.(false);
        }
      });
      return accepted && submitted;
    },
    [
      conversationId,
      createConversation,
      onMessagePersisted,
      onSendingChange,
      persistence,
      streaming,
    ]
  );
}