@garrix82/reactgenie-lib 1.3.0

package/dist/speech-recognition/__tests__/speech-recognition-groq-transport.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/speech-recognition/__tests__/speech-recognition-openai-native.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/speech-recognition/__tests__/speech-recognition-openai.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/speech-recognition/__tests__/speech-recognition-unified.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,21 @@
+import React from 'react';
+export interface GroqSpeechRecognizerProps {
+    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 GroqSpeechRecognizer: React.FC<GroqSpeechRecognizerProps>;
+export declare function isGroqSpeechAvailable(): boolean;
+export declare function getGroqSpeechCapabilities(): {
+    available: boolean;
+    supportedMimeTypes: string[];
+    platform: "ios" | "android" | "windows" | "macos" | "web";
+};

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

@@ -0,0 +1,409 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GroqSpeechRecognizer = void 0;
+exports.getGroqSpeechCapabilities = getGroqSpeechCapabilities;
+exports.isGroqSpeechAvailable = isGroqSpeechAvailable;
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
+var _logger = require("../logger");
+var _groqTranscription = require("./utils/groq-transcription");
+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); }
+/**
+ * Groq-based Speech Recognition using Whisper API
+ * Provides real-time streaming transcription with interim results
+ * Streams audio chunks to Groq as they accumulate, displaying interim transcripts
+ */
+
+/**
+ * Groq-based speech recognizer using Whisper-large-v3 model
+ * Supports real-time streaming and batch transcription
+ */
+const GroqSpeechRecognizer = ({
+  shouldListen,
+  speechStatusCallback,
+  speechResultCallback,
+  speechTranslationCallback,
+  clientSecret,
+  groqApiBaseUrl,
+  groqTranscriptionEndpoint,
+  stream = true,
+  language = 'en',
+  onError,
+  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 startTimeRef = (0, _react.useRef)(0);
+  const lastMimeTypeRef = (0, _react.useRef)('audio/webm');
+
+  // Real-time streaming state
+  const streamAbortRef = (0, _react.useRef)(null);
+  const transcriptionStateRef = (0, _react.useRef)({
+    isStreaming: false,
+    lastSendTime: 0,
+    lastInterim: ''
+  });
+  const finalTranscriptRef = (0, _react.useRef)('');
+  const MIN_CHUNK_SIZE = 500; // bytes (before first send)
+  const SEND_INTERVAL = 1000; // ms (debounce interval)
+
+  /**
+   * Start audio recording (matching MLX approach)
+   */
+  const startRecording = (0, _react.useCallback)(async () => {
+    try {
+      _logger.logger.debug('Starting Groq recording...');
+
+      // Browser-specific audio constraints
+      const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+      _logger.logger.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.logger.debug(`Audio stream tracks: ${stream.getAudioTracks().length}`);
+      stream.getAudioTracks().forEach((track, index) => {
+        _logger.logger.debug(`Track ${index}: ${track.label}, enabled: ${track.enabled}, readyState: ${track.readyState}`);
+      });
+      streamRef.current = stream;
+      audioChunksRef.current = [];
+      finalTranscriptRef.current = '';
+
+      // Create MediaRecorder with supported format
+      const mimeType = getSupportedMimeType();
+      _logger.logger.debug(`Using MIME type: ${mimeType}`);
+      lastMimeTypeRef.current = mimeType;
+
+      // Try creating MediaRecorder with minimal options first
+      let mediaRecorder;
+      try {
+        mediaRecorder = new MediaRecorder(stream, {
+          mimeType
+        });
+        _logger.logger.debug('MediaRecorder created with minimal options');
+      } catch (error) {
+        _logger.logger.warn('MediaRecorder constructor failed with minimal options, trying fallback:', error);
+        // Fallback without mimeType
+        mediaRecorder = new MediaRecorder(stream);
+        _logger.logger.debug('MediaRecorder created with fallback options');
+      }
+      mediaRecorderRef.current = mediaRecorder;
+
+      // Handle audio data - trigger streaming checks
+      mediaRecorder.ondataavailable = event => {
+        if (event.data.size > 0) {
+          audioChunksRef.current.push(event.data);
+          _logger.logger.debug(`Audio chunk: ${event.data.size} bytes (total: ${audioChunksRef.current.length} chunks)`);
+          // Check if we should stream
+          checkAndStreamAudio();
+        }
+      };
+
+      // Handle start
+      mediaRecorder.onstart = () => {
+        _logger.logger.debug('MediaRecorder started, state:', mediaRecorder.state);
+      };
+
+      // Handle recording stop
+      mediaRecorder.onstop = async () => {
+        _logger.logger.debug('Recording stopped, cleaning up stream...');
+        setIsRecording(false);
+
+        // Cancel active stream
+        if (streamAbortRef.current) {
+          streamAbortRef.current.abort();
+          streamAbortRef.current = null;
+        }
+
+        // Clean up stream (close mic immediately)
+        if (streamRef.current) {
+          streamRef.current.getTracks().forEach(track => track.stop());
+          streamRef.current = null;
+        }
+        _logger.logger.info('🛑 Groq recording stopped');
+        const finalTranscript = (finalTranscriptRef.current || transcriptionStateRef.current.lastInterim || '').trim();
+        let parseTranscript = finalTranscript;
+        try {
+          if (audioChunksRef.current.length > 0 && language && !language.startsWith('en')) {
+            const mimeType = lastMimeTypeRef.current || getSupportedMimeType();
+            const audioBlob = new Blob(audioChunksRef.current, {
+              type: mimeType
+            });
+            if (audioBlob.size > 0) {
+              const translated = await (0, _groqTranscription.translateGroqAudio)({
+                apiKey: clientSecret,
+                audioBlob,
+                mimeType,
+                language,
+                endpoint: resolveGroqTranslationEndpoint(groqApiBaseUrl, groqTranscriptionEndpoint)
+              });
+              if (translated) {
+                if (speechTranslationCallback) {
+                  speechTranslationCallback(translated);
+                }
+                parseTranscript = translated;
+              }
+            }
+          }
+        } catch (error) {
+          _logger.logger.warn('Groq translation failed:', error);
+        } finally {
+          audioChunksRef.current = [];
+        }
+
+        // Stream will naturally end, just signal end of recording
+        speechStatusCallback(false, '');
+        if (parseTranscript) {
+          speechResultCallback(parseTranscript);
+        }
+      };
+
+      // Handle errors
+      mediaRecorder.onerror = event => {
+        _logger.logger.error('MediaRecorder error:', event);
+        setIsRecording(false);
+        const error = new Error('Recording failed');
+        if (onError) onError(error);
+        speechStatusCallback(false, '');
+      };
+
+      // Start recording with 100ms timeslice (matching MLX)
+      mediaRecorder.start(100);
+      _logger.logger.debug('MediaRecorder.start(100) called');
+      startTimeRef.current = Date.now();
+      setIsRecording(true);
+      // Don't send empty interim on start - wait for actual transcripts
+      // speechStatusCallback(true, '');
+      _logger.logger.info('🎤 Groq recording started');
+    } catch (error) {
+      _logger.logger.error('Failed to start recording:', error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (onError) onError(err);
+      speechStatusCallback(false, '');
+    }
+  }, [speechStatusCallback, speechResultCallback, speechTranslationCallback, clientSecret, groqApiBaseUrl, groqTranscriptionEndpoint, language, onError]);
+
+  /**
+   * Stop audio recording
+   */
+  const stopRecording = (0, _react.useCallback)(() => {
+    _logger.logger.debug('Stop recording called');
+
+    // Stop all audio tracks immediately
+    if (streamRef.current) {
+      streamRef.current.getTracks().forEach(track => {
+        track.stop();
+      });
+      streamRef.current = null;
+    }
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {
+      mediaRecorderRef.current.stop();
+    }
+  }, []);
+
+  /**
+   * Stream audio to Groq and handle SSE responses
+   * Sends accumulated chunks and streams interim transcripts
+   */
+  const streamAudio = (0, _react.useCallback)(async audioBlob => {
+    if (transcriptionStateRef.current.isStreaming) {
+      _logger.logger.warn('Already streaming, skipping');
+      return;
+    }
+    transcriptionStateRef.current.isStreaming = true;
+    transcriptionStateRef.current.lastSendTime = Date.now();
+    try {
+      const mimeType = getSupportedMimeType();
+      _logger.logger.info(`📤 Streaming ${audioBlob.size} bytes to Groq (interim mode)...`);
+      streamAbortRef.current = new AbortController();
+      const state = transcriptionStateRef.current;
+      await (0, _groqTranscription.streamGroqTranscription)({
+        apiKey: clientSecret,
+        audioBlob,
+        mimeType,
+        language,
+        responseFormat: 'verbose_json',
+        stream,
+        endpoint: resolveGroqTranscriptionEndpoint(groqApiBaseUrl, groqTranscriptionEndpoint),
+        signal: streamAbortRef.current.signal,
+        onInterim: interimText => {
+          if (!interimText || interimText === state.lastInterim) return;
+          state.lastInterim = interimText;
+          finalTranscriptRef.current = interimText;
+          _logger.logger.info(`📝 Interim: "${interimText}"`);
+          speechStatusCallback(true, interimText);
+        }
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name !== 'AbortError') {
+        _logger.logger.error('❌ Stream error:', error);
+        if (onError) onError(error);
+      }
+    } finally {
+      transcriptionStateRef.current.isStreaming = false;
+    }
+  }, [clientSecret, groqApiBaseUrl, groqTranscriptionEndpoint, language, onError, stream]);
+
+  /**
+   * Check if audio threshold met and stream to Groq
+   * Implements debounced streaming with minimum chunk size
+   */
+  const checkAndStreamAudio = (0, _react.useCallback)(() => {
+    const mimeType = getSupportedMimeType();
+    const audioBlob = new Blob(audioChunksRef.current, {
+      type: mimeType
+    });
+    const now = Date.now();
+    const state = transcriptionStateRef.current;
+
+    // Check: minimum chunk size reached?
+    if (audioBlob.size < MIN_CHUNK_SIZE) {
+      return;
+    }
+
+    // Check: already streaming?
+    if (state.isStreaming) {
+      return;
+    }
+
+    // Check: debounce interval respected?
+    if (now - state.lastSendTime < SEND_INTERVAL) {
+      return;
+    }
+
+    // All checks passed - start streaming
+    streamAudio(audioBlob);
+  }, [streamAudio]);
+
+  // SSE handling moved to shared helper (groq-transcription.ts)
+
+  /**
+   * Process collected audio chunks and send to Groq for transcription (matching MLX)
+   * CRITICAL: Guard with processingRef to prevent duplicate uploads
+   */
+  const processAudioChunks = (0, _react.useCallback)(async () => {
+    if (audioChunksRef.current.length === 0) {
+      _logger.logger.warn('No audio chunks to process');
+      return;
+    }
+
+    // In streaming mode, audio already processed via stream
+    _logger.logger.info('✅ Streaming completed');
+    audioChunksRef.current = [];
+  }, []);
+
+  /**
+   * Handle shouldListen prop changes
+   */
+  (0, _react.useEffect)(() => {
+    _logger.logger.debug(`shouldListen changed: ${shouldListen}, isRecording: ${isRecording}`);
+    if (shouldListen && !isRecording) {
+      _logger.logger.debug('✅ Starting recording');
+      startRecording();
+    } else if (!shouldListen && isRecording) {
+      _logger.logger.debug('❌ Stopping recording');
+      stopRecording();
+    }
+  }, [shouldListen, isRecording, startRecording, stopRecording]);
+
+  /**
+   * Cleanup on unmount
+   */
+  (0, _react.useEffect)(() => {
+    return () => {
+      if (streamAbortRef.current) {
+        streamAbortRef.current.abort();
+      }
+      if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {
+        mediaRecorderRef.current.stop();
+      }
+      if (streamRef.current) {
+        streamRef.current.getTracks().forEach(track => track.stop());
+      }
+    };
+  }, []);
+  return /*#__PURE__*/_react.default.createElement(_reactNative.View, null);
+};
+
+/**
+ * Get supported MIME type for MediaRecorder
+ */
+exports.GroqSpeechRecognizer = GroqSpeechRecognizer;
+function getSupportedMimeType() {
+  const types = ['audio/webm;codecs=opus', 'audio/webm', 'audio/ogg;codecs=opus', 'audio/mp4', 'audio/wav'];
+  for (const type of types) {
+    if (MediaRecorder.isTypeSupported(type)) {
+      return type;
+    }
+  }
+
+  // Fallback
+  return 'audio/webm';
+}
+function resolveGroqTranscriptionEndpoint(baseUrl, overrideEndpoint) {
+  if (overrideEndpoint) return overrideEndpoint;
+  if (!baseUrl) return undefined;
+  const trimmed = baseUrl.replace(/\/+$/, '');
+  if (trimmed.endsWith('/openai/v1')) {
+    return `${trimmed}/audio/transcriptions`;
+  }
+  return `${trimmed}/openai/v1/audio/transcriptions`;
+}
+function resolveGroqTranslationEndpoint(baseUrl, overrideEndpoint) {
+  if (overrideEndpoint) {
+    return overrideEndpoint.includes('/audio/transcriptions') ? overrideEndpoint.replace('/audio/transcriptions', '/audio/translations') : overrideEndpoint;
+  }
+  if (!baseUrl) return undefined;
+  const trimmed = baseUrl.replace(/\/+$/, '');
+  if (trimmed.endsWith('/openai/v1')) {
+    return `${trimmed}/audio/translations`;
+  }
+  return `${trimmed}/openai/v1/audio/translations`;
+}
+
+/**
+ * Get file extension from MIME type
+ */
+/**
+ * Check if Groq speech recognition is available
+ */
+function isGroqSpeechAvailable() {
+  // Check if running in browser
+  if (typeof window === 'undefined') {
+    return false;
+  }
+
+  // Check for required APIs
+  const hasMediaDevices = navigator?.mediaDevices?.getUserMedia !== undefined;
+  const hasMediaRecorder = typeof MediaRecorder !== 'undefined';
+  return hasMediaDevices && hasMediaRecorder;
+}
+
+/**
+ * Get browser capabilities for Groq speech
+ */
+function getGroqSpeechCapabilities() {
+  return {
+    available: isGroqSpeechAvailable(),
+    supportedMimeTypes: ['audio/webm;codecs=opus', 'audio/webm', 'audio/ogg;codecs=opus', 'audio/mp4', 'audio/wav'].filter(type => {
+      if (typeof MediaRecorder === 'undefined') return false;
+      return MediaRecorder.isTypeSupported(type);
+    }),
+    platform: _reactNative.Platform.OS
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_reactNative","_logger","_groqTranscription","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","GroqSpeechRecognizer","shouldListen","speechStatusCallback","speechResultCallback","speechTranslationCallback","clientSecret","groqApiBaseUrl","groqTranscriptionEndpoint","stream","language","onError","minAudioSize","isRecording","setIsRecording","useState","mediaRecorderRef","useRef","audioChunksRef","streamRef","startTimeRef","lastMimeTypeRef","streamAbortRef","transcriptionStateRef","isStreaming","lastSendTime","lastInterim","finalTranscriptRef","MIN_CHUNK_SIZE","SEND_INTERVAL","startRecording","useCallback","logger","debug","isSafari","test","navigator","userAgent","mediaDevices","getUserMedia","audio","echoCancellation","noiseSuppression","autoGainControl","sampleRate","getAudioTracks","length","forEach","track","index","label","enabled","readyState","current","mimeType","getSupportedMimeType","mediaRecorder","MediaRecorder","error","warn","ondataavailable","event","data","size","push","checkAndStreamAudio","onstart","state","onstop","abort","getTracks","stop","info","finalTranscript","trim","parseTranscript","startsWith","audioBlob","Blob","type","translated","translateGroqAudio","apiKey","endpoint","resolveGroqTranslationEndpoint","onerror","Error","start","Date","now","err","String","stopRecording","streamAudio","AbortController","streamGroqTranscription","responseFormat","resolveGroqTranscriptionEndpoint","signal","onInterim","interimText","name","processAudioChunks","useEffect","createElement","View","exports","types","isTypeSupported","baseUrl","overrideEndpoint","undefined","trimmed","replace","endsWith","includes","isGroqSpeechAvailable","window","hasMediaDevices","hasMediaRecorder","getGroqSpeechCapabilities","available","supportedMimeTypes","filter","platform","Platform","OS"],"sources":["../../src/speech-recognition/speech-recognition-groq.tsx"],"sourcesContent":["/**\n * Groq-based Speech Recognition using Whisper API\n * Provides real-time streaming transcription with interim results\n * Streams audio chunks to Groq as they accumulate, displaying interim transcripts\n */\n\nimport React, { useEffect, useState, useRef, useCallback } from 'react';\nimport { View, Platform } from 'react-native';\nimport { logger } from '../logger';\nimport { streamGroqTranscription, translateGroqAudio } from './utils/groq-transcription';\n\nexport interface GroqSpeechRecognizerProps {\n  shouldListen: boolean;\n  speechStatusCallback: (status: boolean, transcript: string) => void;\n  speechResultCallback: (result: string) => void;\n  speechTranslationCallback?: (translation: string) => void;\n  clientSecret: string;\n  groqApiBaseUrl?: string;\n  groqTranscriptionEndpoint?: string;\n  stream?: boolean;\n  language?: string;\n  onError?: (error: Error) => void;\n  minAudioSize?: number; // Minimum audio size in bytes (default 1000)\n}\n\n/**\n * Groq-based speech recognizer using Whisper-large-v3 model\n * Supports real-time streaming and batch transcription\n */\nexport const GroqSpeechRecognizer: React.FC<GroqSpeechRecognizerProps> = ({\n  shouldListen,\n  speechStatusCallback,\n  speechResultCallback,\n  speechTranslationCallback,\n  clientSecret,\n  groqApiBaseUrl,\n  groqTranscriptionEndpoint,\n  stream = true,\n  language = 'en',\n  onError,\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 startTimeRef = useRef<number>(0);\n  const lastMimeTypeRef = useRef<string>('audio/webm');\n  \n  // Real-time streaming state\n  const streamAbortRef = useRef<AbortController | null>(null);\n  const transcriptionStateRef = useRef({\n    isStreaming: false,\n    lastSendTime: 0,\n    lastInterim: '',\n  });\n  const finalTranscriptRef = useRef<string>('');\n  const MIN_CHUNK_SIZE = 500; // bytes (before first send)\n  const SEND_INTERVAL = 1000; // ms (debounce interval)\n\n  /**\n   * Start audio recording (matching MLX approach)\n   */\n  const startRecording = useCallback(async () => {\n    try {\n      logger.debug('Starting Groq recording...');\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      finalTranscriptRef.current = '';\n\n      // Create MediaRecorder with supported format\n      const mimeType = getSupportedMimeType();\n      logger.debug(`Using MIME type: ${mimeType}`);\n      lastMimeTypeRef.current = 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 - trigger streaming checks\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 (total: ${audioChunksRef.current.length} chunks)`);\n          // Check if we should stream\n          checkAndStreamAudio();\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, cleaning up stream...');\n        setIsRecording(false);\n        \n        // Cancel active stream\n        if (streamAbortRef.current) {\n          streamAbortRef.current.abort();\n          streamAbortRef.current = null;\n        }\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('🛑 Groq recording stopped');\n\n        const finalTranscript = (\n          finalTranscriptRef.current ||\n          transcriptionStateRef.current.lastInterim ||\n          ''\n        ).trim();\n        let parseTranscript = finalTranscript;\n\n        try {\n          if (\n            audioChunksRef.current.length > 0 &&\n            language &&\n            !language.startsWith('en')\n          ) {\n            const mimeType = lastMimeTypeRef.current || getSupportedMimeType();\n            const audioBlob = new Blob(audioChunksRef.current, { type: mimeType });\n            if (audioBlob.size > 0) {\n              const translated = await translateGroqAudio({\n                apiKey: clientSecret,\n                audioBlob,\n                mimeType,\n                language,\n                endpoint: resolveGroqTranslationEndpoint(\n                  groqApiBaseUrl,\n                  groqTranscriptionEndpoint,\n                ),\n              });\n              if (translated) {\n                if (speechTranslationCallback) {\n                  speechTranslationCallback(translated);\n                }\n                parseTranscript = translated;\n              }\n            }\n          }\n        } catch (error) {\n          logger.warn('Groq translation failed:', error);\n        } finally {\n          audioChunksRef.current = [];\n        }\n\n        // Stream will naturally end, just signal end of recording\n        speechStatusCallback(false, '');\n        if (parseTranscript) {\n          speechResultCallback(parseTranscript);\n        }\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 100ms timeslice (matching MLX)\n      mediaRecorder.start(100);\n      logger.debug('MediaRecorder.start(100) called');\n\n      startTimeRef.current = Date.now();\n      setIsRecording(true);\n      // Don't send empty interim on start - wait for actual transcripts\n      // speechStatusCallback(true, '');\n      logger.info('🎤 Groq recording started');\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  }, [\n    speechStatusCallback,\n    speechResultCallback,\n    speechTranslationCallback,\n    clientSecret,\n    groqApiBaseUrl,\n    groqTranscriptionEndpoint,\n    language,\n    onError,\n  ]);\n\n  /**\n   * Stop audio recording\n   */\n  const stopRecording = useCallback(() => {\n    logger.debug('Stop recording called');\n    \n    // Stop all audio tracks immediately\n    if (streamRef.current) {\n      streamRef.current.getTracks().forEach((track) => {\n        track.stop();\n      });\n      streamRef.current = null;\n    }\n    \n    if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {\n      mediaRecorderRef.current.stop();\n    }\n  }, []);\n\n  /**\n   * Stream audio to Groq and handle SSE responses\n   * Sends accumulated chunks and streams interim transcripts\n   */\n  const streamAudio = useCallback(async (audioBlob: Blob) => {\n    if (transcriptionStateRef.current.isStreaming) {\n      logger.warn('Already streaming, skipping');\n      return;\n    }\n\n    transcriptionStateRef.current.isStreaming = true;\n    transcriptionStateRef.current.lastSendTime = Date.now();\n\n    try {\n      const mimeType = getSupportedMimeType();\n      logger.info(`📤 Streaming ${audioBlob.size} bytes to Groq (interim mode)...`);\n\n      streamAbortRef.current = new AbortController();\n      const state = transcriptionStateRef.current;\n\n      await streamGroqTranscription({\n        apiKey: clientSecret,\n        audioBlob,\n        mimeType,\n        language,\n        responseFormat: 'verbose_json',\n        stream,\n        endpoint: resolveGroqTranscriptionEndpoint(\n          groqApiBaseUrl,\n          groqTranscriptionEndpoint,\n        ),\n        signal: streamAbortRef.current.signal,\n        onInterim: (interimText) => {\n          if (!interimText || interimText === state.lastInterim) return;\n          state.lastInterim = interimText;\n          finalTranscriptRef.current = interimText;\n          logger.info(`📝 Interim: \"${interimText}\"`);\n          speechStatusCallback(true, interimText);\n        },\n      });\n    } catch (error) {\n      if (error instanceof Error && error.name !== 'AbortError') {\n        logger.error('❌ Stream error:', error);\n        if (onError) onError(error);\n      }\n    } finally {\n      transcriptionStateRef.current.isStreaming = false;\n    }\n  }, [clientSecret, groqApiBaseUrl, groqTranscriptionEndpoint, language, onError, stream]);\n\n  /**\n   * Check if audio threshold met and stream to Groq\n   * Implements debounced streaming with minimum chunk size\n   */\n  const checkAndStreamAudio = useCallback(() => {\n    const mimeType = getSupportedMimeType();\n    const audioBlob = new Blob(audioChunksRef.current, { type: mimeType });\n    const now = Date.now();\n\n    const state = transcriptionStateRef.current;\n\n    // Check: minimum chunk size reached?\n    if (audioBlob.size < MIN_CHUNK_SIZE) {\n      return;\n    }\n\n    // Check: already streaming?\n    if (state.isStreaming) {\n      return;\n    }\n\n    // Check: debounce interval respected?\n    if (now - state.lastSendTime < SEND_INTERVAL) {\n      return;\n    }\n\n    // All checks passed - start streaming\n    streamAudio(audioBlob);\n  }, [streamAudio]);\n\n  // SSE handling moved to shared helper (groq-transcription.ts)\n\n  /**\n   * Process collected audio chunks and send to Groq for transcription (matching MLX)\n   * CRITICAL: Guard with processingRef to prevent duplicate uploads\n   */\n  const processAudioChunks = useCallback(async () => {\n    if (audioChunksRef.current.length === 0) {\n      logger.warn('No audio chunks to process');\n      return;\n    }\n\n    // In streaming mode, audio already processed via stream\n    logger.info('✅ Streaming completed');\n    audioChunksRef.current = [];\n  }, []);\n\n  /**\n   * Handle shouldListen prop changes\n   */\n  useEffect(() => {\n    logger.debug(`shouldListen changed: ${shouldListen}, isRecording: ${isRecording}`);\n\n    if (shouldListen && !isRecording) {\n      logger.debug('✅ Starting recording');\n      startRecording();\n    } else if (!shouldListen && isRecording) {\n      logger.debug('❌ Stopping recording');\n      stopRecording();\n    }\n  }, [shouldListen, isRecording, startRecording, stopRecording]);\n\n  /**\n   * Cleanup on unmount\n   */\n  useEffect(() => {\n    return () => {\n      if (streamAbortRef.current) {\n        streamAbortRef.current.abort();\n      }\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    };\n  }, []);\n\n  return <View />;\n};\n\n/**\n * Get supported MIME type for MediaRecorder\n */\nfunction getSupportedMimeType(): string {\n  const types = [\n    'audio/webm;codecs=opus',\n    'audio/webm',\n    'audio/ogg;codecs=opus',\n    'audio/mp4',\n    'audio/wav',\n  ];\n\n  for (const type of types) {\n    if (MediaRecorder.isTypeSupported(type)) {\n      return type;\n    }\n  }\n\n  // Fallback\n  return 'audio/webm';\n}\n\nfunction resolveGroqTranscriptionEndpoint(\n  baseUrl?: string,\n  overrideEndpoint?: string,\n): string | undefined {\n  if (overrideEndpoint) return overrideEndpoint;\n  if (!baseUrl) return undefined;\n  const trimmed = baseUrl.replace(/\\/+$/, '');\n  if (trimmed.endsWith('/openai/v1')) {\n    return `${trimmed}/audio/transcriptions`;\n  }\n  return `${trimmed}/openai/v1/audio/transcriptions`;\n}\n\nfunction resolveGroqTranslationEndpoint(\n  baseUrl?: string,\n  overrideEndpoint?: string,\n): string | undefined {\n  if (overrideEndpoint) {\n    return overrideEndpoint.includes('/audio/transcriptions')\n      ? overrideEndpoint.replace('/audio/transcriptions', '/audio/translations')\n      : overrideEndpoint;\n  }\n  if (!baseUrl) return undefined;\n  const trimmed = baseUrl.replace(/\\/+$/, '');\n  if (trimmed.endsWith('/openai/v1')) {\n    return `${trimmed}/audio/translations`;\n  }\n  return `${trimmed}/openai/v1/audio/translations`;\n}\n\n/**\n * Get file extension from MIME type\n */\n/**\n * Check if Groq speech recognition is available\n */\nexport function isGroqSpeechAvailable(): boolean {\n  // Check if running in browser\n  if (typeof window === 'undefined') {\n    return false;\n  }\n\n  // Check for required APIs\n  const hasMediaDevices = \n    navigator?.mediaDevices?.getUserMedia !== undefined;\n  const hasMediaRecorder = typeof MediaRecorder !== 'undefined';\n\n  return hasMediaDevices && hasMediaRecorder;\n}\n\n/**\n * Get browser capabilities for Groq speech\n */\nexport function getGroqSpeechCapabilities() {\n  return {\n    available: isGroqSpeechAvailable(),\n    supportedMimeTypes: [\n      'audio/webm;codecs=opus',\n      'audio/webm',\n      'audio/ogg;codecs=opus',\n      'audio/mp4',\n      'audio/wav',\n    ].filter((type) => {\n      if (typeof MediaRecorder === 'undefined') return false;\n      return MediaRecorder.isTypeSupported(type);\n    }),\n    platform: Platform.OS,\n  };\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,15 @@
+import React from 'react';
+export type LocalWhisperMode = 'oneshot' | 'sse' | 'realtime';
+export interface MLXSpeechRecognizerProps {
+    shouldListen: boolean;
+    speechStatusCallback: (status: boolean, transcript: string) => void;
+    speechResultCallback: (result: string) => void;
+    language?: string;
+    onError?: (error: Error) => void;
+    baseUrl?: string;
+    mode?: LocalWhisperMode;
+    modelName?: string;
+    minAudioSize?: number;
+}
+export declare const MLXSpeechRecognizer: React.FC<MLXSpeechRecognizerProps>;
+export default MLXSpeechRecognizer;