@garrix82/reactgenie-lib 1.3.0

package/dist/speech-recognition/speech-recognition-mlx.js

@@ -0,0 +1,393 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.MLXSpeechRecognizer = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
+var _logger = _interopRequireDefault(require("../logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * MLX Whisper-based Speech Recognition using a local FastAPI server.
+ * Simplified version with manual start/stop control.
+ */
+
+const MLXSpeechRecognizer = ({
+  shouldListen,
+  speechStatusCallback,
+  speechResultCallback,
+  language = 'en',
+  onError,
+  baseUrl = 'http://127.0.0.1:8000',
+  mode,
+  modelName = 'large-v3-turbo',
+  minAudioSize = 1000
+}) => {
+  const [isRecording, setIsRecording] = (0, _react.useState)(false);
+  const mediaRecorderRef = (0, _react.useRef)(null);
+  const audioChunksRef = (0, _react.useRef)([]);
+  const streamRef = (0, _react.useRef)(null);
+  const abortControllerRef = (0, _react.useRef)(null);
+  const startTimeRef = (0, _react.useRef)(0);
+  // Prevent concurrent uploads / duplicate calls
+  const processingRef = (0, _react.useRef)(false);
+  // Track last sent transcript for finalization
+  const lastSentTranscriptRef = (0, _react.useRef)('');
+
+  /**
+   * Start recording audio from microphone.
+   */
+  const startRecording = (0, _react.useCallback)(async () => {
+    try {
+      _logger.default.debug('Starting MLX Whisper recording...');
+      _logger.default.debug(`shouldListen=${shouldListen}, isRecording=${isRecording}, processing=${processingRef.current}`);
+
+      // Browser-specific audio constraints
+      const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+      _logger.default.debug(`Browser detection: Safari = ${isSafari}`);
+      const stream = await navigator.mediaDevices.getUserMedia({
+        audio: isSafari ? {
+          // Safari prefers simpler constraints
+          echoCancellation: false,
+          noiseSuppression: false,
+          autoGainControl: false
+        } : {
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true,
+          sampleRate: 16000
+        }
+      });
+      _logger.default.debug(`Audio stream tracks: ${stream.getAudioTracks().length}`);
+      stream.getAudioTracks().forEach((track, index) => {
+        _logger.default.debug(`Track ${index}: ${track.label}, enabled: ${track.enabled}, readyState: ${track.readyState}`);
+      });
+      streamRef.current = stream;
+      audioChunksRef.current = [];
+
+      // Create MediaRecorder with supported format
+      const mimeType = getSupportedMimeType();
+      _logger.default.debug(`Using MIME type: ${mimeType}`);
+
+      // Try creating MediaRecorder with minimal options first
+      let mediaRecorder;
+      try {
+        mediaRecorder = new MediaRecorder(stream, {
+          mimeType
+        });
+        _logger.default.debug('MediaRecorder created with minimal options');
+      } catch (error) {
+        _logger.default.warn('MediaRecorder constructor failed with minimal options, trying fallback:', error);
+        // Fallback without mimeType
+        mediaRecorder = new MediaRecorder(stream);
+        _logger.default.debug('MediaRecorder created with fallback options');
+      }
+      mediaRecorderRef.current = mediaRecorder;
+
+      // Handle audio data
+      mediaRecorder.ondataavailable = event => {
+        if (event.data.size > 0) {
+          audioChunksRef.current.push(event.data);
+          _logger.default.debug(`Audio chunk: ${event.data.size} bytes`);
+        } else {
+          _logger.default.debug('ondataavailable with empty chunk');
+        }
+      };
+
+      // Handle start
+      mediaRecorder.onstart = () => {
+        _logger.default.debug('MediaRecorder started, state:', mediaRecorder.state);
+      };
+
+      // Handle recording stop
+      mediaRecorder.onstop = async () => {
+        _logger.default.debug('Recording stopped, processing audio...');
+        setIsRecording(false);
+
+        // Clean up stream (close mic immediately)
+        if (streamRef.current) {
+          streamRef.current.getTracks().forEach(track => track.stop());
+          streamRef.current = null;
+        }
+        _logger.default.info('🛑 MLX Whisper recording stopped');
+        _logger.default.debug(`Collected ${audioChunksRef.current.length} audio chunks`);
+        await processAudioChunks();
+      };
+
+      // Handle errors
+      mediaRecorder.onerror = event => {
+        _logger.default.error('MediaRecorder error:', event);
+        setIsRecording(false);
+        const error = new Error('Recording failed');
+        if (onError) onError(error);
+        speechStatusCallback(false, '');
+      };
+
+      // Start recording with a small timeslice to ensure data collection
+      mediaRecorder.start(100); // Collect data every 100ms
+      _logger.default.debug('MediaRecorder.start() called');
+      startTimeRef.current = Date.now();
+      setIsRecording(true);
+      speechStatusCallback(true, '');
+      _logger.default.info('🎤 MLX Whisper recording started');
+    } catch (error) {
+      _logger.default.error('Failed to start recording:', error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (onError) onError(err);
+      speechStatusCallback(false, '');
+    }
+  }, [speechStatusCallback, onError]);
+
+  /**
+   * Stop recording and process audio.
+   */
+  const stopRecording = (0, _react.useCallback)(() => {
+    const elapsed = Date.now() - startTimeRef.current;
+    const minDuration = 1000; // Minimum 1 second recording
+
+    if (elapsed < minDuration) {
+      // Schedule stop after minimum duration
+      const delay = minDuration - elapsed;
+      setTimeout(() => {
+        if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {
+          try {
+            // Flush any pending data
+            mediaRecorderRef.current.requestData?.();
+          } catch (e) {}
+          mediaRecorderRef.current.stop();
+        }
+      }, delay);
+      _logger.default.debug(`Recording too short (${elapsed}ms), delaying stop by ${delay}ms`);
+    } else {
+      // Stop immediately if minimum duration met
+      if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {
+        try {
+          mediaRecorderRef.current.requestData?.();
+        } catch (e) {}
+        mediaRecorderRef.current.stop();
+      }
+    }
+
+    // Note: setIsRecording(false) moved to onstop handler
+  }, []);
+
+  /**
+   * Process collected audio chunks and send to server.
+   */
+  const processAudioChunks = (0, _react.useCallback)(async () => {
+    if (audioChunksRef.current.length === 0) {
+      _logger.default.warn('No audio chunks to process');
+      speechStatusCallback(false, '');
+      return;
+    }
+
+    // Prevent duplicate uploads
+    if (processingRef.current) {
+      _logger.default.warn('Already processing an utterance, skipping duplicate upload');
+      return;
+    }
+    processingRef.current = true;
+    // Give feedback to UI that we are uploading/transcribing
+    try {
+      // indicate remote processing started (no fake interim text)
+      speechStatusCallback(true, '');
+      // Create audio blob
+      const mimeType = getSupportedMimeType();
+      const audioBlob = new Blob(audioChunksRef.current, {
+        type: mimeType
+      });
+      _logger.default.debug(`Audio blob size: ${audioBlob.size} bytes`);
+      if (audioBlob.size < minAudioSize) {
+        _logger.default.warn(`Audio too short (${audioBlob.size} < ${minAudioSize} bytes), skipping`);
+        speechStatusCallback(false, '');
+        speechResultCallback('');
+        return;
+      }
+
+      // Create file for upload
+      const extension = getFileExtension(mimeType);
+      const audioFile = new File([audioBlob], `audio.${extension}`, {
+        type: mimeType
+      });
+
+      // Use single REST endpoint for oneshot and SSE
+      const endpoint = `${baseUrl}/v1/audio/transcriptions`;
+
+      // Prepare request
+      abortControllerRef.current = new AbortController();
+      const formData = new FormData();
+      formData.append('file', audioFile);
+      formData.append('model', modelName);
+      formData.append('response_format', 'json');
+      if (language) formData.append('language', language);
+      if (mode === 'oneshot') {
+        formData.append('stream', 'false');
+      } else {
+        formData.append('stream', 'true');
+      }
+      _logger.default.info(`📤 Sending ${audioBlob.size} bytes to ${endpoint}`);
+      _logger.default.info(`🗣️ Mode: ${mode}, Model: ${modelName}, endpoint: ${endpoint}`);
+
+      // Send to server
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        body: formData,
+        signal: abortControllerRef.current.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Server error: ${response.status}`);
+      }
+
+      // Handle response
+      if (mode === 'oneshot') {
+        const result = await response.json();
+        const transcript = result?.text?.trim() || '';
+        _logger.default.debug('Received transcription response:', result);
+        _logger.default.debug(`Transcription text: "${transcript}"`);
+        // Deliver transcript first, then signal end so ModalityProvider processes it once
+        lastSentTranscriptRef.current = transcript;
+        speechResultCallback(transcript);
+        speechStatusCallback(false, '');
+      } else {
+        // Handle streaming response (SSE)
+        await handleStreamingResponse(response);
+      }
+    } catch (error) {
+      _logger.default.error('Transcription error:', error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (onError) onError(err);
+      speechStatusCallback(false, '');
+      speechResultCallback('');
+    } finally {
+      audioChunksRef.current = [];
+      if (abortControllerRef.current) {
+        abortControllerRef.current = null;
+      }
+      processingRef.current = false;
+    }
+  }, [speechStatusCallback, speechResultCallback, baseUrl, mode, modelName, language, minAudioSize, onError]);
+
+  /**
+   * Handle streaming transcription response.
+   */
+  const handleStreamingResponse = (0, _react.useCallback)(async response => {
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error('No response reader');
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let lastTranscript = '';
+    let sawDone = false;
+    try {
+      let done = false;
+      while (!done) {
+        const result = await reader.read();
+        done = result.done;
+        if (done) break;
+        buffer += decoder.decode(result.value, {
+          stream: true
+        });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6).trim();
+            if (data === '[DONE]') {
+              sawDone = true;
+              break;
+            }
+            try {
+              const parsedResult = JSON.parse(data);
+              const transcript = parsedResult?.text?.trim();
+              if (transcript) {
+                _logger.default.info(`📝 Streaming: "${transcript}"`);
+                lastTranscript = transcript;
+                // deliver partial to UI immediately
+                speechResultCallback(transcript);
+              }
+            } catch (e) {
+              // Ignore parse errors
+            }
+          }
+        }
+        if (sawDone) break;
+      }
+    } finally {
+      // Small delay to ensure UI has applied last partial
+      try {
+        await new Promise(res => setTimeout(res, 60));
+      } catch (e) {}
+      if (lastTranscript) {
+        _logger.default.debug(`Final streaming transcript before end: "${lastTranscript}"`);
+        try {
+          speechResultCallback(lastTranscript);
+        } catch (e) {}
+      }
+
+      // Signal stream end so ModalityProvider triggers the Genie interpreter once
+      try {
+        speechStatusCallback(false, '');
+      } catch (e) {}
+      reader.releaseLock();
+    }
+  }, [speechStatusCallback, speechResultCallback]);
+
+  /**
+   * React to shouldListen changes.
+   */
+  (0, _react.useEffect)(() => {
+    _logger.default.debug(`shouldListen prop changed: ${shouldListen}`);
+    // Avoid starting a new recording while previous utterance is processing
+    if (shouldListen && !isRecording && !processingRef.current) {
+      startRecording();
+    } else if (!shouldListen && isRecording) {
+      stopRecording();
+    }
+  }, [shouldListen, isRecording, startRecording, stopRecording]);
+
+  /**
+   * Cleanup on unmount.
+   */
+  (0, _react.useEffect)(() => {
+    return () => {
+      if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {
+        mediaRecorderRef.current.stop();
+      }
+      if (streamRef.current) {
+        streamRef.current.getTracks().forEach(track => track.stop());
+      }
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+  return /*#__PURE__*/_react.default.createElement(_reactNative.View, null);
+};
+
+/**
+ * Get supported MIME type for MediaRecorder.
+ */
+exports.MLXSpeechRecognizer = MLXSpeechRecognizer;
+function getSupportedMimeType() {
+  const types = ['audio/webm', 'audio/mp4', 'audio/wav', 'audio/ogg'];
+  for (const type of types) {
+    if (MediaRecorder.isTypeSupported(type)) {
+      return type;
+    }
+  }
+  return 'audio/webm';
+}
+
+/**
+ * Get file extension for MIME type.
+ */
+function getFileExtension(mimeType) {
+  if (mimeType.includes('webm')) return 'webm';
+  if (mimeType.includes('mp4')) return 'mp4';
+  if (mimeType.includes('wav')) return 'wav';
+  if (mimeType.includes('ogg')) return 'ogg';
+  return 'webm';
+}
+var _default = exports.default = MLXSpeechRecognizer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_reactNative","_logger","_interopRequireDefault","e","__esModule","default","t","WeakMap","r","n","o","i","f","__proto__","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","MLXSpeechRecognizer","shouldListen","speechStatusCallback","speechResultCallback","language","onError","baseUrl","mode","modelName","minAudioSize","isRecording","setIsRecording","useState","mediaRecorderRef","useRef","audioChunksRef","streamRef","abortControllerRef","startTimeRef","processingRef","lastSentTranscriptRef","startRecording","useCallback","logger","debug","current","isSafari","test","navigator","userAgent","stream","mediaDevices","getUserMedia","audio","echoCancellation","noiseSuppression","autoGainControl","sampleRate","getAudioTracks","length","forEach","track","index","label","enabled","readyState","mimeType","getSupportedMimeType","mediaRecorder","MediaRecorder","error","warn","ondataavailable","event","data","size","push","onstart","state","onstop","getTracks","stop","info","processAudioChunks","onerror","Error","start","Date","now","err","String","stopRecording","elapsed","minDuration","delay","setTimeout","requestData","audioBlob","Blob","type","extension","getFileExtension","audioFile","File","endpoint","AbortController","formData","FormData","append","response","fetch","method","body","signal","ok","status","result","json","transcript","text","trim","handleStreamingResponse","reader","getReader","decoder","TextDecoder","buffer","lastTranscript","sawDone","done","read","decode","value","lines","split","pop","line","startsWith","slice","parsedResult","JSON","parse","Promise","res","releaseLock","useEffect","abort","createElement","View","exports","types","isTypeSupported","includes","_default"],"sources":["../../src/speech-recognition/speech-recognition-mlx.tsx"],"sourcesContent":["/**\n * MLX Whisper-based Speech Recognition using a local FastAPI server.\n * Simplified version with manual start/stop control.\n */\n\nimport React, { useState, useRef, useCallback, useEffect } from 'react';\nimport { View } from 'react-native';\nimport logger from '../logger';\n\nexport type LocalWhisperMode = 'oneshot' | 'sse' | 'realtime';\n\nexport interface MLXSpeechRecognizerProps {\n  shouldListen: boolean;\n  speechStatusCallback: (status: boolean, transcript: string) => void;\n  speechResultCallback: (result: string) => void;\n  language?: string;\n  onError?: (error: Error) => void;\n  baseUrl?: string;\n  mode?: LocalWhisperMode;\n  modelName?: string;\n  minAudioSize?: number;\n}\n\nexport const MLXSpeechRecognizer: React.FC<MLXSpeechRecognizerProps> = ({\n  shouldListen,\n  speechStatusCallback,\n  speechResultCallback,\n  language = 'en',\n  onError,\n  baseUrl = 'http://127.0.0.1:8000',\n  mode,\n  modelName = 'large-v3-turbo',\n  minAudioSize = 1000,\n}) => {\n  const [isRecording, setIsRecording] = useState(false);\n  const mediaRecorderRef = useRef<MediaRecorder | null>(null);\n  const audioChunksRef = useRef<Blob[]>([]);\n  const streamRef = useRef<MediaStream | null>(null);\n  const abortControllerRef = useRef<AbortController | null>(null);\n  const startTimeRef = useRef<number>(0);\n  // Prevent concurrent uploads / duplicate calls\n  const processingRef = useRef<boolean>(false);\n  // Track last sent transcript for finalization\n  const lastSentTranscriptRef = useRef<string>('');\n\n  /**\n   * Start recording audio from microphone.\n   */\n  const startRecording = useCallback(async () => {\n    try {\n      logger.debug('Starting MLX Whisper recording...');\n      logger.debug(`shouldListen=${shouldListen}, isRecording=${isRecording}, processing=${processingRef.current}`);\n\n      // Browser-specific audio constraints\n      const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);\n      logger.debug(`Browser detection: Safari = ${isSafari}`);\n\n      const stream = await navigator.mediaDevices.getUserMedia({\n        audio: isSafari ? {\n          // Safari prefers simpler constraints\n          echoCancellation: false,\n          noiseSuppression: false,\n          autoGainControl: false,\n        } : {\n          echoCancellation: true,\n          noiseSuppression: true,\n          autoGainControl: true,\n          sampleRate: 16000,\n        },\n      });\n\n      logger.debug(`Audio stream tracks: ${stream.getAudioTracks().length}`);\n      stream.getAudioTracks().forEach((track, index) => {\n        logger.debug(`Track ${index}: ${track.label}, enabled: ${track.enabled}, readyState: ${track.readyState}`);\n      });\n\n      streamRef.current = stream;\n      audioChunksRef.current = [];\n\n      // Create MediaRecorder with supported format\n      const mimeType = getSupportedMimeType();\n      logger.debug(`Using MIME type: ${mimeType}`);\n\n      // Try creating MediaRecorder with minimal options first\n      let mediaRecorder: MediaRecorder;\n      try {\n        mediaRecorder = new MediaRecorder(stream, { mimeType });\n        logger.debug('MediaRecorder created with minimal options');\n      } catch (error) {\n        logger.warn('MediaRecorder constructor failed with minimal options, trying fallback:', error);\n        // Fallback without mimeType\n        mediaRecorder = new MediaRecorder(stream);\n        logger.debug('MediaRecorder created with fallback options');\n      }\n\n      mediaRecorderRef.current = mediaRecorder;\n\n      // Handle audio data\n      mediaRecorder.ondataavailable = (event: BlobEvent) => {\n        if (event.data.size > 0) {\n          audioChunksRef.current.push(event.data);\n          logger.debug(`Audio chunk: ${event.data.size} bytes`);\n        } else {\n          logger.debug('ondataavailable with empty chunk');\n        }\n      };\n\n      // Handle start\n      mediaRecorder.onstart = () => {\n        logger.debug('MediaRecorder started, state:', mediaRecorder.state);\n      };\n\n      // Handle recording stop\n      mediaRecorder.onstop = async () => {\n        logger.debug('Recording stopped, processing audio...');\n        setIsRecording(false);\n\n        // Clean up stream (close mic immediately)\n        if (streamRef.current) {\n          streamRef.current.getTracks().forEach(track => track.stop());\n          streamRef.current = null;\n        }\n\n        logger.info('🛑 MLX Whisper recording stopped');\n        logger.debug(`Collected ${audioChunksRef.current.length} audio chunks`);\n        await processAudioChunks();\n      };\n\n      // Handle errors\n      mediaRecorder.onerror = (event: Event) => {\n        logger.error('MediaRecorder error:', event);\n        setIsRecording(false);\n        const error = new Error('Recording failed');\n        if (onError) onError(error);\n        speechStatusCallback(false, '');\n      };\n\n      // Start recording with a small timeslice to ensure data collection\n      mediaRecorder.start(100); // Collect data every 100ms\n      logger.debug('MediaRecorder.start() called');\n\n      startTimeRef.current = Date.now();\n      setIsRecording(true);\n      speechStatusCallback(true, '');\n      logger.info('🎤 MLX Whisper recording started');\n\n    } catch (error) {\n      logger.error('Failed to start recording:', error);\n      const err = error instanceof Error ? error : new Error(String(error));\n      if (onError) onError(err);\n      speechStatusCallback(false, '');\n    }\n  }, [speechStatusCallback, onError]);\n\n  /**\n   * Stop recording and process audio.\n   */\n  const stopRecording = useCallback(() => {\n    const elapsed = Date.now() - startTimeRef.current;\n    const minDuration = 1000; // Minimum 1 second recording\n\n    if (elapsed < minDuration) {\n      // Schedule stop after minimum duration\n      const delay = minDuration - elapsed;\n      setTimeout(() => {\n        if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {\n          try {\n            // Flush any pending data\n            (mediaRecorderRef.current as any).requestData?.();\n          } catch (e) {}\n          mediaRecorderRef.current.stop();\n        }\n      }, delay);\n      logger.debug(`Recording too short (${elapsed}ms), delaying stop by ${delay}ms`);\n    } else {\n      // Stop immediately if minimum duration met\n      if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {\n        try { (mediaRecorderRef.current as any).requestData?.(); } catch (e) {}\n        mediaRecorderRef.current.stop();\n      }\n    }\n\n    // Note: setIsRecording(false) moved to onstop handler\n  }, []);\n\n  /**\n   * Process collected audio chunks and send to server.\n   */\n  const processAudioChunks = useCallback(async () => {\n    if (audioChunksRef.current.length === 0) {\n      logger.warn('No audio chunks to process');\n      speechStatusCallback(false, '');\n      return;\n    }\n\n    // Prevent duplicate uploads\n    if (processingRef.current) {\n      logger.warn('Already processing an utterance, skipping duplicate upload');\n      return;\n    }\n\n    processingRef.current = true;\n    // Give feedback to UI that we are uploading/transcribing\n    try {\n      // indicate remote processing started (no fake interim text)\n      speechStatusCallback(true, '');\n      // Create audio blob\n      const mimeType = getSupportedMimeType();\n      const audioBlob = new Blob(audioChunksRef.current, { type: mimeType });\n\n      logger.debug(`Audio blob size: ${audioBlob.size} bytes`);\n\n      if (audioBlob.size < minAudioSize) {\n        logger.warn(`Audio too short (${audioBlob.size} < ${minAudioSize} bytes), skipping`);\n        speechStatusCallback(false, '');\n        speechResultCallback('');\n        return;\n      }\n\n      // Create file for upload\n      const extension = getFileExtension(mimeType);\n      const audioFile = new File([audioBlob], `audio.${extension}`, { type: mimeType });\n\n      // Use single REST endpoint for oneshot and SSE\n      const endpoint = `${baseUrl}/v1/audio/transcriptions`;\n\n      // Prepare request\n      abortControllerRef.current = new AbortController();\n      const formData = new FormData();\n      formData.append('file', audioFile);\n      formData.append('model', modelName);\n      formData.append('response_format', 'json');\n      if (language) formData.append('language', language);\n\n      if (mode === 'oneshot') {\n        formData.append('stream', 'false');\n      } else {\n        formData.append('stream', 'true');\n      }\n\n      logger.info(`📤 Sending ${audioBlob.size} bytes to ${endpoint}`);\n      logger.info(`🗣️ Mode: ${mode}, Model: ${modelName}, endpoint: ${endpoint}`);\n\n      // Send to server\n      const response = await fetch(endpoint, {\n        method: 'POST',\n        body: formData,\n        signal: abortControllerRef.current.signal,\n      });\n\n      if (!response.ok) {\n        throw new Error(`Server error: ${response.status}`);\n      }\n\n      // Handle response\n      if (mode === 'oneshot') {\n        const result = await response.json();\n        const transcript = result?.text?.trim() || '';\n        logger.debug('Received transcription response:', result);\n        logger.debug(`Transcription text: \"${transcript}\"`);\n        // Deliver transcript first, then signal end so ModalityProvider processes it once\n        lastSentTranscriptRef.current = transcript;\n        speechResultCallback(transcript);\n        speechStatusCallback(false, '');\n      } else {\n        // Handle streaming response (SSE)\n        await handleStreamingResponse(response);\n      }\n\n    } catch (error) {\n      logger.error('Transcription error:', error);\n      const err = error instanceof Error ? error : new Error(String(error));\n      if (onError) onError(err);\n      speechStatusCallback(false, '');\n      speechResultCallback('');\n    } finally {\n      audioChunksRef.current = [];\n      if (abortControllerRef.current) {\n        abortControllerRef.current = null;\n      }\n      processingRef.current = false;\n    }\n  }, [speechStatusCallback, speechResultCallback, baseUrl, mode, modelName, language, minAudioSize, onError]);\n\n  /**\n   * Handle streaming transcription response.\n   */\n  const handleStreamingResponse = useCallback(async (response: Response) => {\n    const reader = response.body?.getReader();\n    if (!reader) throw new Error('No response reader');\n\n    const decoder = new TextDecoder();\n    let buffer = '';\n    let lastTranscript = '';\n    let sawDone = false;\n\n    try {\n      let done = false;\n      while (!done) {\n        const result = await reader.read();\n        done = result.done;\n\n        if (done) break;\n\n        buffer += decoder.decode(result.value, { stream: true });\n        const lines = buffer.split('\\n');\n        buffer = lines.pop() || '';\n\n        for (const line of lines) {\n          if (line.startsWith('data: ')) {\n            const data = line.slice(6).trim();\n            if (data === '[DONE]') {\n              sawDone = true;\n              break;\n            }\n\n            try {\n              const parsedResult = JSON.parse(data);\n              const transcript = parsedResult?.text?.trim();\n              if (transcript) {\n                logger.info(`📝 Streaming: \"${transcript}\"`);\n                lastTranscript = transcript;\n                // deliver partial to UI immediately\n                speechResultCallback(transcript);\n              }\n            } catch (e) {\n              // Ignore parse errors\n            }\n          }\n        }\n\n        if (sawDone) break;\n      }\n    } finally {\n      // Small delay to ensure UI has applied last partial\n      try { await new Promise((res) => setTimeout(res, 60)); } catch (e) {}\n\n      if (lastTranscript) {\n        logger.debug(`Final streaming transcript before end: \"${lastTranscript}\"`);\n        try { speechResultCallback(lastTranscript); } catch (e) {}\n      }\n\n      // Signal stream end so ModalityProvider triggers the Genie interpreter once\n      try { speechStatusCallback(false, ''); } catch (e) {}\n\n      reader.releaseLock();\n    }\n  }, [speechStatusCallback, speechResultCallback]);\n\n  /**\n   * React to shouldListen changes.\n   */\n  useEffect(() => {\n    logger.debug(`shouldListen prop changed: ${shouldListen}`);\n    // Avoid starting a new recording while previous utterance is processing\n    if (shouldListen && !isRecording && !processingRef.current) {\n      startRecording();\n    } else if (!shouldListen && isRecording) {\n      stopRecording();\n    }\n  }, [shouldListen, isRecording, startRecording, stopRecording]);\n\n  /**\n   * Cleanup on unmount.\n   */\n  useEffect(() => {\n    return () => {\n      if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {\n        mediaRecorderRef.current.stop();\n      }\n      if (streamRef.current) {\n        streamRef.current.getTracks().forEach(track => track.stop());\n      }\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n      }\n    };\n  }, []);\n\n  return <View />;\n};\n\n/**\n * Get supported MIME type for MediaRecorder.\n */\nfunction getSupportedMimeType(): string {\n  const types = ['audio/webm', 'audio/mp4', 'audio/wav', 'audio/ogg'];\n\n  for (const type of types) {\n    if (MediaRecorder.isTypeSupported(type)) {\n      return type;\n    }\n  }\n\n  return 'audio/webm';\n}\n\n/**\n * Get file extension for MIME type.\n */\nfunction getFileExtension(mimeType: string): string {\n  if (mimeType.includes('webm')) return 'webm';\n  if (mimeType.includes('mp4')) return 'mp4';\n  if (mimeType.includes('wav')) return 'wav';\n  if (mimeType.includes('ogg')) return 'ogg';\n  return 'webm';\n}\n\nexport default MLXSpeechRecognizer;\n"],"mappings":"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","ignoreList":[]}

package/dist/speech-recognition/speech-recognition-native.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export interface NativeSpeechRecognizerProps {
+    shouldListen: boolean;
+    speechStatusCallback: (status: boolean, transcript: string) => void;
+    speechResultCallback: (result: string) => void;
+    speechTranslationCallback?: (translation: string) => void;
+    clientSecret: string;
+    groqApiBaseUrl?: string;
+    groqTranscriptionEndpoint?: string;
+    stream?: boolean;
+    language?: string;
+    onError?: (error: Error) => void;
+    minAudioSize?: number;
+}
+export declare const NativeSpeechRecognizer: React.FC<NativeSpeechRecognizerProps>;
+export declare function isNativeSpeechAvailable(): boolean;
+export declare function getNativeSpeechCapabilities(): {
+    available: boolean;
+    platform: "ios" | "android" | "windows" | "macos" | "web";
+    supportsVAD: boolean;
+    supportsAudioLevels: boolean;
+    requiresExpoAudio: boolean;
+    backend: string;
+};