@garrix82/reactgenie-lib 1.3.0

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

@@ -0,0 +1,589 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.UnifiedSpeechRecognizer = void 0;
+Object.defineProperty(exports, "getGroqSpeechCapabilities", {
+  enumerable: true,
+  get: function () {
+    return _speechRecognitionGroq.getGroqSpeechCapabilities;
+  }
+});
+Object.defineProperty(exports, "getOpenAISpeechCapabilities", {
+  enumerable: true,
+  get: function () {
+    return _speechRecognitionOpenai.getOpenAISpeechCapabilities;
+  }
+});
+exports.getSpeechRecognitionConfig = getSpeechRecognitionConfig;
+exports.getSpeechRecognitionStatus = getSpeechRecognitionStatus;
+Object.defineProperty(exports, "isGroqSpeechAvailable", {
+  enumerable: true,
+  get: function () {
+    return _speechRecognitionGroq.isGroqSpeechAvailable;
+  }
+});
+Object.defineProperty(exports, "isOpenAISpeechAvailable", {
+  enumerable: true,
+  get: function () {
+    return _speechRecognitionOpenai.isOpenAISpeechAvailable;
+  }
+});
+exports.isWebSpeechAvailable = void 0;
+exports.selectSpeechRecognitionMethod = selectSpeechRecognitionMethod;
+var _react = _interopRequireDefault(require("react"));
+var _reactNative = require("react-native");
+var _speechRecognition = require("../speech-recognition");
+var _speechRecognitionGroq = require("./speech-recognition-groq");
+var _speechRecognitionMlx = require("./speech-recognition-mlx");
+var _speechRecognitionOpenai = require("./speech-recognition-openai");
+var _logger = _interopRequireDefault(require("../logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /**
+ * Unified Speech Recognition Component
+ * Automatically selects best speech recognition method based on:
+ * 1. Platform (Web vs Native)
+ * 2. Environment configuration
+ * 3. Feature availability
+ */
+/**
+ * Configuration for speech recognition.
+ * Resolved from in-code defaults + explicit runtime overrides passed via props.
+ */
+
+function normalizeProvider(value) {
+  if (!value) return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "groq") return "groq";
+  if (normalized === "openai") return "openai";
+  return undefined;
+}
+const DEFAULT_REALTIME_MODEL = "gpt-4o-transcribe";
+const DEFAULT_TRANSLATION_MODEL = "gpt-4.1-mini";
+const DEFAULT_OPENAI_AUTO_STOP_ON_VAD_SILENCE = false;
+const DEFAULT_OPENAI_VAD_SILENCE_DURATION_MS = 2000;
+const DEFAULT_OPENAI_PREWARM_ON_MOUNT = true;
+function getRuntimeEnvValue(key) {
+  try {
+    const env = typeof process !== "undefined" ? process.env : undefined;
+    const value = env?.[key];
+    if (typeof value !== "string") return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+function parseBooleanEnv(key, fallback) {
+  const raw = getRuntimeEnvValue(key);
+  if (!raw) return fallback;
+  const normalized = raw.toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return fallback;
+}
+function parseNumberEnv(key, fallback) {
+  const raw = getRuntimeEnvValue(key);
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return fallback;
+  return parsed;
+}
+const toOpenAIEndpointsFromBaseUrl = baseUrl => {
+  const trimmed = (baseUrl || "").trim().replace(/\/+$/, "");
+  if (!trimmed) {
+    return {
+      transcriptionSessionEndpoint: undefined,
+      translationEndpoint: undefined
+    };
+  }
+  return {
+    transcriptionSessionEndpoint: `${trimmed}/openai/v1/realtime/transcription_sessions`,
+    translationEndpoint: `${trimmed}/openai/v1/speech/translate-to-english`
+  };
+};
+function resolveOpenAIConfig(config) {
+  const defaults = {
+    realtimeModel: DEFAULT_REALTIME_MODEL,
+    translationModel: DEFAULT_TRANSLATION_MODEL,
+    vadEnabled: true,
+    autoStopOnVadSilence: parseBooleanEnv("OPENAI_AUTO_STOP_ON_VAD_SILENCE", DEFAULT_OPENAI_AUTO_STOP_ON_VAD_SILENCE),
+    vadThreshold: 0.7,
+    vadPrefixPaddingMs: 400,
+    vadSilenceDurationMs: parseNumberEnv("OPENAI_VAD_SILENCE_DURATION_MS", DEFAULT_OPENAI_VAD_SILENCE_DURATION_MS),
+    vadIdleTimeoutMs: 6000,
+    prewarmOnMount: parseBooleanEnv("OPENAI_PREWARM_ON_MOUNT", DEFAULT_OPENAI_PREWARM_ON_MOUNT)
+  };
+  const nested = config?.openai || {};
+  const endpointBase = nested.proxyBaseUrl;
+  const derivedEndpoints = toOpenAIEndpointsFromBaseUrl(endpointBase);
+  return _objectSpread(_objectSpread(_objectSpread({}, defaults), nested), {}, {
+    transcriptionSessionEndpoint: nested.transcriptionSessionEndpoint || derivedEndpoints.transcriptionSessionEndpoint,
+    translationEndpoint: nested.translationEndpoint || derivedEndpoints.translationEndpoint,
+    realtimeWebRtcUrl: nested.realtimeWebRtcUrl,
+    realtimeModel: nested.realtimeModel || defaults.realtimeModel,
+    translationModel: nested.translationModel || defaults.translationModel,
+    vadEnabled: nested.vadEnabled ?? defaults.vadEnabled,
+    autoStopOnVadSilence: nested.autoStopOnVadSilence ?? defaults.autoStopOnVadSilence,
+    vadThreshold: nested.vadThreshold ?? defaults.vadThreshold,
+    vadPrefixPaddingMs: nested.vadPrefixPaddingMs ?? defaults.vadPrefixPaddingMs,
+    vadSilenceDurationMs: nested.vadSilenceDurationMs ?? defaults.vadSilenceDurationMs,
+    vadIdleTimeoutMs: nested.vadIdleTimeoutMs ?? defaults.vadIdleTimeoutMs,
+    prewarmOnMount: nested.prewarmOnMount ?? defaults.prewarmOnMount
+  });
+}
+function resolveGroqConfig(config) {
+  const defaults = {
+    enabled: true,
+    stream: true
+  };
+  return _objectSpread(_objectSpread({}, defaults), config?.groq || {});
+}
+function resolveLocalModelConfig(config) {
+  const defaults = {
+    enabledOnWeb: false,
+    baseUrl: "http://127.0.0.1:8000",
+    mode: "oneshot",
+    model: "large-v3-turbo"
+  };
+  return _objectSpread(_objectSpread({}, defaults), config?.localModel || {});
+}
+
+/**
+ * Load speech recognition config from defaults + explicit overrides.
+ */
+function getSpeechRecognitionConfig(overrides) {
+  const defaults = {
+    provider: "groq",
+    fallbackToWebSpeech: true,
+    groq: resolveGroqConfig(),
+    openai: resolveOpenAIConfig(),
+    localModel: resolveLocalModelConfig()
+  };
+  const merged = _objectSpread(_objectSpread(_objectSpread({}, defaults), overrides || {}), {}, {
+    provider: normalizeProvider(overrides?.provider) || normalizeProvider(defaults.provider) || "groq"
+  });
+  return _objectSpread(_objectSpread({}, merged), {}, {
+    groq: resolveGroqConfig(merged),
+    openai: resolveOpenAIConfig(merged),
+    localModel: resolveLocalModelConfig(merged)
+  });
+}
+
+/**
+ * Check if Web Speech API is available
+ */
+function checkWebSpeechAvailability() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return "webkitSpeechRecognition" in window || "SpeechRecognition" in window;
+}
+const isWebSpeechAvailable = exports.isWebSpeechAvailable = checkWebSpeechAvailability;
+const normalizeLanguageTag = lang => {
+  const normalized = (lang || "en").trim().toLowerCase();
+  return normalized.length > 0 ? normalized : "en";
+};
+const toShortLanguageCode = lang => lang.split("-")[0];
+const toWebSpeechLocale = lang => {
+  if (lang.startsWith("en")) return "en-US";
+  if (lang.startsWith("de")) return "de-DE";
+  return lang;
+};
+
+/**
+ * Types of speech recognition methods
+ */
+
+let nativeSpeechModuleCache;
+let openAiNativeSpeechModuleCache;
+function getNativeSpeechModule() {
+  if (nativeSpeechModuleCache !== undefined) {
+    return nativeSpeechModuleCache;
+  }
+  try {
+    // Keep native module lazy to avoid loading native-only dependencies on web.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    nativeSpeechModuleCache = require("./speech-recognition-native");
+  } catch (error) {
+    nativeSpeechModuleCache = null;
+    _logger.default.debug("Native speech module unavailable:", error);
+  }
+  return nativeSpeechModuleCache;
+}
+function isNativeRecognizerAvailable() {
+  const nativeModule = getNativeSpeechModule();
+  return !!nativeModule?.isNativeSpeechAvailable?.();
+}
+function getOpenAINativeSpeechModule() {
+  if (openAiNativeSpeechModuleCache !== undefined) {
+    return openAiNativeSpeechModuleCache;
+  }
+  try {
+    // Keep native module lazy to avoid loading native-only dependencies on web.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    openAiNativeSpeechModuleCache = require("./speech-recognition-openai-native");
+  } catch (error) {
+    openAiNativeSpeechModuleCache = null;
+    _logger.default.debug("OpenAI native speech module unavailable:", error);
+  }
+  return openAiNativeSpeechModuleCache;
+}
+function isOpenAINativeRecognizerAvailable() {
+  const nativeModule = getOpenAINativeSpeechModule();
+  return !!nativeModule?.isOpenAINativeSpeechAvailable?.();
+}
+
+/**
+ * Determine which speech recognition method to use
+ */
+function selectSpeechRecognitionMethod(config, clientSecret) {
+  const isWeb = _reactNative.Platform.OS === "web";
+  const isNative = _reactNative.Platform.OS === "ios" || _reactNative.Platform.OS === "android";
+  const isWebClientRuntime = isWeb && typeof window !== "undefined";
+  const shouldWarnUnavailable = isWebClientRuntime;
+  const provider = normalizeProvider(config.provider) || "groq";
+  const groq = resolveGroqConfig(config);
+  const openai = resolveOpenAIConfig(config);
+  const localModel = resolveLocalModelConfig(config);
+  const hasGroqKey = !!(clientSecret || groq.apiKey);
+  if (provider === "openai") {
+    if (isNative) {
+      if (openai.transcriptionSessionEndpoint && isOpenAINativeRecognizerAvailable()) {
+        _logger.default.info("✅ Using OpenAI Native Realtime (WebRTC)");
+        return "openai-native";
+      }
+      if (shouldWarnUnavailable) {
+        _logger.default.warn("⚠️ OpenAI native speech unavailable. Configure OPENAI_TRANSCRIPTION_SESSION_ENDPOINT and install react-native-webrtc.");
+      }
+      return "none";
+    }
+    if (isWeb) {
+      if (openai.transcriptionSessionEndpoint && (0, _speechRecognitionOpenai.isOpenAISpeechAvailable)()) {
+        _logger.default.info("✅ Using OpenAI Web Realtime (WebRTC)");
+        return "openai-web";
+      }
+      if (shouldWarnUnavailable) {
+        _logger.default.warn("⚠️ OpenAI web speech unavailable");
+      }
+      return "none";
+    }
+  }
+
+  // Native platforms: Use native Groq implementation
+  if (isNative) {
+    if (groq.enabled && hasGroqKey && isNativeRecognizerAvailable()) {
+      _logger.default.info("✅ Using Groq Native (expo-audio)");
+      return "groq-native";
+    }
+    if (shouldWarnUnavailable) {
+      _logger.default.warn("⚠️ No speech recognition available on native (install expo-audio + expo-file-system and run a dev client build)");
+    }
+    return "none";
+  }
+
+  // Web platform: Can use both, prefer based on config
+  if (isWeb) {
+    if (localModel.enabledOnWeb && localModel.baseUrl) {
+      _logger.default.info("✅ Using Local MLX Whisper server");
+      return "mlx-local";
+    }
+
+    // Use Groq if enabled and available
+    if (groq.enabled && hasGroqKey && (0, _speechRecognitionGroq.isGroqSpeechAvailable)()) {
+      _logger.default.info("✅ Using Groq Web (Enabled and available)");
+      return "groq-web";
+    }
+
+    // Fallback to Web Speech API
+    if (config.fallbackToWebSpeech && isWebSpeechAvailable()) {
+      _logger.default.info("✅ Using Web Speech API (Fallback)");
+      return "webspeech";
+    }
+  }
+  if (shouldWarnUnavailable) {
+    _logger.default.warn("⚠️ No speech recognition method available");
+  }
+  return "none";
+}
+
+/**
+ * Unified Speech Recognizer Component
+ * Automatically selects and uses the best speech recognition method
+ */
+const UnifiedSpeechRecognizer = ({
+  shouldListen,
+  speechStatusCallback,
+  speechResultCallback,
+  speechTranslationCallback,
+  speechReadyCallback,
+  waveformPreviewCallback,
+  clientSecret,
+  language = "en",
+  onError,
+  requestContextProvider,
+  config
+}) => {
+  // Get configuration
+  const resolvedConfig = getSpeechRecognitionConfig(config);
+  const isWebClientRuntime = _reactNative.Platform.OS === "web" && typeof window !== "undefined";
+  const normalizedLanguage = normalizeLanguageTag(language);
+  const apiLanguage = toShortLanguageCode(normalizedLanguage);
+  const webSpeechLanguage = toWebSpeechLocale(normalizedLanguage);
+
+  // Determine which method to use
+  const method = selectSpeechRecognitionMethod(resolvedConfig, clientSecret);
+  if (isWebClientRuntime) {
+    _logger.default.debug("Selected speech recognition method:", method);
+  }
+  const groqConfig = resolveGroqConfig(resolvedConfig);
+  const openaiConfig = resolveOpenAIConfig(resolvedConfig);
+  const localModelConfig = resolveLocalModelConfig(resolvedConfig);
+  const finalGroqApiKey = clientSecret || groqConfig.apiKey || "";
+  const groqApiBaseUrl = groqConfig.apiBaseUrl;
+  const groqTranscriptionEndpoint = groqConfig.transcriptionEndpoint;
+  const streamGroq = groqConfig.stream;
+  if (groqConfig.enabled && !finalGroqApiKey) {
+    _logger.default.warn("Groq speech is enabled but no API key was provided. Pass a non-secret client key or disable Groq speech.");
+  }
+
+  // Error handler with fallback
+  const handleError = error => {
+    _logger.default.error("Speech recognition error:", error);
+    if (onError) {
+      onError(error);
+    }
+
+    // If Groq fails and fallback is enabled, we could switch to Web Speech
+    // (This would require more complex state management)
+  };
+
+  // Render appropriate component based on method
+  switch (method) {
+    case "openai-native":
+      {
+        if (!openaiConfig.transcriptionSessionEndpoint) {
+          _logger.default.error("OpenAI transcription session endpoint is required but not provided");
+          return null;
+        }
+        const openaiNativeModule = getOpenAINativeSpeechModule();
+        if (!openaiNativeModule?.OpenAINativeSpeechRecognizer) {
+          _logger.default.error("OpenAI native speech module unavailable. Install react-native-webrtc and use a native/dev build.");
+          return null;
+        }
+        const OpenAINativeSpeechRecognizer = openaiNativeModule.OpenAINativeSpeechRecognizer;
+        return /*#__PURE__*/_react.default.createElement(OpenAINativeSpeechRecognizer, {
+          shouldListen: shouldListen,
+          speechStatusCallback: speechStatusCallback,
+          speechResultCallback: speechResultCallback,
+          speechTranslationCallback: speechTranslationCallback,
+          speechReadyCallback: speechReadyCallback,
+          clientSecret: finalGroqApiKey,
+          openaiTranscriptionSessionEndpoint: openaiConfig.transcriptionSessionEndpoint,
+          openaiTranslationEndpoint: openaiConfig.translationEndpoint,
+          openaiRealtimeWebRtcUrl: openaiConfig.realtimeWebRtcUrl,
+          openaiRealtimeModel: openaiConfig.realtimeModel,
+          openaiTranslationModel: openaiConfig.translationModel,
+          openaiVadEnabled: openaiConfig.vadEnabled,
+          openaiAutoStopOnVadSilence: openaiConfig.autoStopOnVadSilence,
+          openaiVadThreshold: openaiConfig.vadThreshold,
+          openaiVadPrefixPaddingMs: openaiConfig.vadPrefixPaddingMs,
+          openaiVadSilenceDurationMs: openaiConfig.vadSilenceDurationMs,
+          openaiVadIdleTimeoutMs: openaiConfig.vadIdleTimeoutMs,
+          openaiPrewarmOnMount: openaiConfig.prewarmOnMount,
+          language: apiLanguage,
+          requestContextProvider: requestContextProvider,
+          onError: handleError
+        });
+      }
+    case "openai-web":
+      if (!openaiConfig.transcriptionSessionEndpoint) {
+        _logger.default.error("OpenAI transcription session endpoint is required but not provided");
+        return null;
+      }
+      return /*#__PURE__*/_react.default.createElement(_speechRecognitionOpenai.OpenAISpeechRecognizer, {
+        shouldListen: shouldListen,
+        speechStatusCallback: speechStatusCallback,
+        speechResultCallback: speechResultCallback,
+        speechTranslationCallback: speechTranslationCallback,
+        speechReadyCallback: speechReadyCallback,
+        clientSecret: finalGroqApiKey,
+        openaiTranscriptionSessionEndpoint: openaiConfig.transcriptionSessionEndpoint,
+        openaiTranslationEndpoint: openaiConfig.translationEndpoint,
+        openaiRealtimeWebRtcUrl: openaiConfig.realtimeWebRtcUrl,
+        openaiRealtimeModel: openaiConfig.realtimeModel,
+        openaiTranslationModel: openaiConfig.translationModel,
+        openaiVadEnabled: openaiConfig.vadEnabled,
+        openaiAutoStopOnVadSilence: openaiConfig.autoStopOnVadSilence,
+        openaiVadThreshold: openaiConfig.vadThreshold,
+        openaiVadPrefixPaddingMs: openaiConfig.vadPrefixPaddingMs,
+        openaiVadSilenceDurationMs: openaiConfig.vadSilenceDurationMs,
+        openaiVadIdleTimeoutMs: openaiConfig.vadIdleTimeoutMs,
+        openaiPrewarmOnMount: openaiConfig.prewarmOnMount,
+        language: apiLanguage,
+        requestContextProvider: requestContextProvider,
+        onError: handleError
+      });
+    case "groq-native":
+      {
+        if (!finalGroqApiKey) {
+          _logger.default.error("Groq API key is required but not provided");
+          return null;
+        }
+        const nativeModule = getNativeSpeechModule();
+        if (!nativeModule?.NativeSpeechRecognizer) {
+          _logger.default.error("Native speech module is unavailable. Install expo-audio + expo-file-system and use a dev client build.");
+          return null;
+        }
+        const NativeSpeechRecognizer = nativeModule.NativeSpeechRecognizer;
+        return /*#__PURE__*/_react.default.createElement(NativeSpeechRecognizer, {
+          shouldListen: shouldListen,
+          speechStatusCallback: speechStatusCallback,
+          speechResultCallback: speechResultCallback,
+          speechTranslationCallback: speechTranslationCallback,
+          clientSecret: finalGroqApiKey,
+          groqApiBaseUrl: groqApiBaseUrl,
+          groqTranscriptionEndpoint: groqTranscriptionEndpoint,
+          stream: streamGroq,
+          language: apiLanguage,
+          onError: handleError
+        });
+      }
+    case "groq-web":
+      if (!finalGroqApiKey) {
+        _logger.default.error("Groq API key is required but not provided");
+        return null;
+      }
+      return /*#__PURE__*/_react.default.createElement(_speechRecognitionGroq.GroqSpeechRecognizer, {
+        shouldListen: shouldListen,
+        speechStatusCallback: speechStatusCallback,
+        speechResultCallback: speechResultCallback,
+        speechTranslationCallback: speechTranslationCallback,
+        clientSecret: finalGroqApiKey,
+        groqApiBaseUrl: groqApiBaseUrl,
+        groqTranscriptionEndpoint: groqTranscriptionEndpoint,
+        stream: streamGroq,
+        language: apiLanguage,
+        onError: handleError
+      });
+    case "mlx-local":
+      {
+        const effectiveUrl = localModelConfig.baseUrl;
+        if (!effectiveUrl) {
+          _logger.default.error("Local whisper URL is required but not provided");
+          return null;
+        }
+        return /*#__PURE__*/_react.default.createElement(_speechRecognitionMlx.MLXSpeechRecognizer, {
+          shouldListen: shouldListen,
+          speechStatusCallback: speechStatusCallback,
+          speechResultCallback: speechResultCallback,
+          language: apiLanguage,
+          onError: handleError,
+          baseUrl: effectiveUrl,
+          mode: localModelConfig.mode,
+          modelName: localModelConfig.model
+        });
+      }
+    case "webspeech":
+      return /*#__PURE__*/_react.default.createElement(_speechRecognition.SpeechRecognizer, {
+        shouldListen: shouldListen,
+        speechStatusCallback: speechStatusCallback,
+        speechResultCallback: speechResultCallback,
+        language: webSpeechLanguage
+      });
+    case "none":
+    default:
+      if (isWebClientRuntime) {
+        _logger.default.warn("No speech recognition available");
+      }
+      return null;
+  }
+};
+
+/**
+ * Get speech recognition status and capabilities
+ */
+exports.UnifiedSpeechRecognizer = UnifiedSpeechRecognizer;
+function getSpeechRecognitionStatus(overrides) {
+  const config = getSpeechRecognitionConfig(overrides);
+  const method = selectSpeechRecognitionMethod(config);
+  const localModel = resolveLocalModelConfig(config);
+  return {
+    method,
+    config,
+    capabilities: {
+      groq: (0, _speechRecognitionGroq.getGroqSpeechCapabilities)(),
+      openai: (0, _speechRecognitionOpenai.getOpenAISpeechCapabilities)(),
+      webSpeech: {
+        available: isWebSpeechAvailable(),
+        platform: _reactNative.Platform.OS
+      },
+      localModel: {
+        enabled: !!localModel.enabledOnWeb,
+        url: localModel.baseUrl,
+        mode: localModel.mode || "oneshot"
+      }
+    },
+    recommendations: getRecommendations(method, config)
+  };
+}
+
+/**
+ * Get recommendations for improving speech recognition
+ */
+function getRecommendations(method, config) {
+  const recommendations = [];
+  if (method === "none") {
+    recommendations.push("No speech recognition available");
+    if (!config.groq?.apiKey && config.provider !== "openai") {
+      recommendations.push("Provide a Groq client secret via config or disable Groq speech");
+    }
+    if (_reactNative.Platform.OS === "web") {
+      if (!(0, _speechRecognitionGroq.isGroqSpeechAvailable)()) {
+        recommendations.push("Browser does not support MediaRecorder API");
+      }
+      if (!isWebSpeechAvailable()) {
+        recommendations.push("Browser does not support Web Speech API");
+      }
+    } else {
+      recommendations.push("Install expo-audio + expo-file-system and use a dev client build");
+    }
+  }
+  if (method === "webspeech") {
+    recommendations.push("Using Web Speech API (free but less accurate)");
+    recommendations.push("Enable Groq speech for better accuracy");
+  }
+  if (method === "groq-web") {
+    recommendations.push("Using Groq Web (high accuracy, best for web)");
+  }
+  if (method === "groq-native") {
+    recommendations.push("Using Groq Native capture (expo-audio)");
+  }
+  if (method === "openai-web") {
+    recommendations.push("Using OpenAI Web Realtime with server VAD");
+  }
+  if (method === "openai-native") {
+    recommendations.push("Using OpenAI Native Realtime with PCM stream");
+  }
+  if (method === "mlx-local") {
+    recommendations.push("Using Local MLX Whisper server (fast, offline)");
+    if (!config.localModel?.baseUrl) {
+      recommendations.push("Set LOCAL_WHISPER_URL to point at your server");
+    }
+  }
+  return recommendations;
+}
+
+// Export for convenience
+// Default export
+var _default = exports.default = UnifiedSpeechRecognizer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_reactNative","_speechRecognition","_speechRecognitionGroq","_speechRecognitionMlx","_speechRecognitionOpenai","_logger","e","__esModule","default","ownKeys","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","normalizeProvider","undefined","normalized","trim","toLowerCase","DEFAULT_REALTIME_MODEL","DEFAULT_TRANSLATION_MODEL","DEFAULT_OPENAI_AUTO_STOP_ON_VAD_SILENCE","DEFAULT_OPENAI_VAD_SILENCE_DURATION_MS","DEFAULT_OPENAI_PREWARM_ON_MOUNT","getRuntimeEnvValue","key","env","process","trimmed","parseBooleanEnv","fallback","raw","parseNumberEnv","parsed","isFinite","toOpenAIEndpointsFromBaseUrl","baseUrl","replace","transcriptionSessionEndpoint","translationEndpoint","resolveOpenAIConfig","config","defaults","realtimeModel","translationModel","vadEnabled","autoStopOnVadSilence","vadThreshold","vadPrefixPaddingMs","vadSilenceDurationMs","vadIdleTimeoutMs","prewarmOnMount","nested","openai","endpointBase","proxyBaseUrl","derivedEndpoints","realtimeWebRtcUrl","resolveGroqConfig","enabled","stream","groq","resolveLocalModelConfig","enabledOnWeb","mode","model","localModel","getSpeechRecognitionConfig","overrides","provider","fallbackToWebSpeech","merged","checkWebSpeechAvailability","window","isWebSpeechAvailable","exports","normalizeLanguageTag","lang","toShortLanguageCode","split","toWebSpeechLocale","startsWith","nativeSpeechModuleCache","openAiNativeSpeechModuleCache","getNativeSpeechModule","error","logger","debug","isNativeRecognizerAvailable","nativeModule","isNativeSpeechAvailable","getOpenAINativeSpeechModule","isOpenAINativeRecognizerAvailable","isOpenAINativeSpeechAvailable","selectSpeechRecognitionMethod","clientSecret","isWeb","Platform","OS","isNative","isWebClientRuntime","shouldWarnUnavailable","hasGroqKey","apiKey","info","warn","isOpenAISpeechAvailable","isGroqSpeechAvailable","UnifiedSpeechRecognizer","shouldListen","speechStatusCallback","speechResultCallback","speechTranslationCallback","speechReadyCallback","waveformPreviewCallback","language","onError","requestContextProvider","resolvedConfig","normalizedLanguage","apiLanguage","webSpeechLanguage","method","groqConfig","openaiConfig","localModelConfig","finalGroqApiKey","groqApiBaseUrl","apiBaseUrl","groqTranscriptionEndpoint","transcriptionEndpoint","streamGroq","handleError","openaiNativeModule","OpenAINativeSpeechRecognizer","createElement","openaiTranscriptionSessionEndpoint","openaiTranslationEndpoint","openaiRealtimeWebRtcUrl","openaiRealtimeModel","openaiTranslationModel","openaiVadEnabled","openaiAutoStopOnVadSilence","openaiVadThreshold","openaiVadPrefixPaddingMs","openaiVadSilenceDurationMs","openaiVadIdleTimeoutMs","openaiPrewarmOnMount","OpenAISpeechRecognizer","NativeSpeechRecognizer","GroqSpeechRecognizer","effectiveUrl","MLXSpeechRecognizer","modelName","SpeechRecognizer","getSpeechRecognitionStatus","capabilities","getGroqSpeechCapabilities","getOpenAISpeechCapabilities","webSpeech","available","platform","url","recommendations","getRecommendations","_default"],"sources":["../../src/speech-recognition/speech-recognition-unified.tsx"],"sourcesContent":["/**\n * Unified Speech Recognition Component\n * Automatically selects best speech recognition method based on:\n * 1. Platform (Web vs Native)\n * 2. Environment configuration\n * 3. Feature availability\n */\n\nimport React from \"react\";\nimport { Platform } from \"react-native\";\nimport { SpeechRecognizer as WebSpeechRecognizer } from \"../speech-recognition\";\nimport {\n  GroqSpeechRecognizer,\n  isGroqSpeechAvailable,\n  getGroqSpeechCapabilities,\n} from \"./speech-recognition-groq\";\nimport {\n  MLXSpeechRecognizer,\n  type LocalWhisperMode,\n} from \"./speech-recognition-mlx\";\nimport {\n  OpenAISpeechRecognizer,\n  isOpenAISpeechAvailable,\n  getOpenAISpeechCapabilities,\n} from \"./speech-recognition-openai\";\nimport logger from \"../logger\";\n\nexport interface UnifiedSpeechRecognizerProps {\n  shouldListen: boolean;\n  speechStatusCallback: (status: boolean, transcript: string) => void;\n  speechResultCallback: (result: string) => void;\n  speechTranslationCallback?: (translation: string) => void;\n  speechReadyCallback?: (ready: boolean) => void;\n  waveformPreviewCallback?: (waveform: number[]) => void;\n  clientSecret?: string;\n  language?: string;\n  onError?: (error: Error) => void;\n  requestContextProvider?: () =>\n    | {\n        threadId?: string | null;\n        turnId?: string | null;\n        sessionId?: string | number | null;\n        sentryTrace?: string | null;\n        baggage?: string | null;\n      }\n    | null\n    | undefined;\n  // Optional runtime config overrides\n  config?: SpeechRecognitionConfig;\n}\n\nexport interface GroqConfigProps {\n  enabled?: boolean;\n  apiKey?: string;\n  apiBaseUrl?: string;\n  transcriptionEndpoint?: string;\n  stream?: boolean;\n}\n\nexport interface OpenAIConfigProps {\n  proxyBaseUrl?: string;\n  transcriptionSessionEndpoint?: string;\n  translationEndpoint?: string;\n  realtimeWebRtcUrl?: string;\n  realtimeModel?: \"gpt-4o-transcribe\" | \"gpt-4o-mini-transcribe\";\n  translationModel?: string;\n  vadEnabled?: boolean;\n  autoStopOnVadSilence?: boolean;\n  vadThreshold?: number;\n  vadPrefixPaddingMs?: number;\n  vadSilenceDurationMs?: number;\n  vadIdleTimeoutMs?: number;\n  prewarmOnMount?: boolean;\n}\n\nexport interface LocalModelConfigProps {\n  enabledOnWeb?: boolean;\n  baseUrl?: string;\n  mode?: LocalWhisperMode;\n  model?: string;\n}\n\n/**\n * Configuration for speech recognition.\n * Resolved from in-code defaults + explicit runtime overrides passed via props.\n */\nexport interface SpeechRecognitionConfig {\n  // Speech provider\n  provider?: \"groq\" | \"openai\";\n  // Fallback to web speech if Groq fails\n  fallbackToWebSpeech?: boolean;\n  // Provider-specific nested configs\n  groq?: GroqConfigProps;\n  openai?: OpenAIConfigProps;\n  localModel?: LocalModelConfigProps;\n}\n\nfunction normalizeProvider(\n  value?: string,\n): \"groq\" | \"openai\" | undefined {\n  if (!value) return undefined;\n  const normalized = value.trim().toLowerCase();\n  if (normalized === \"groq\") return \"groq\";\n  if (normalized === \"openai\") return \"openai\";\n  return undefined;\n}\n\nconst DEFAULT_REALTIME_MODEL: OpenAIConfigProps[\"realtimeModel\"] =\n  \"gpt-4o-transcribe\";\nconst DEFAULT_TRANSLATION_MODEL = \"gpt-4.1-mini\";\nconst DEFAULT_OPENAI_AUTO_STOP_ON_VAD_SILENCE = false;\nconst DEFAULT_OPENAI_VAD_SILENCE_DURATION_MS = 2000;\nconst DEFAULT_OPENAI_PREWARM_ON_MOUNT = true;\n\nfunction getRuntimeEnvValue(key: string): string | undefined {\n  try {\n    const env = typeof process !== \"undefined\" ? process.env : undefined;\n    const value = env?.[key];\n    if (typeof value !== \"string\") return undefined;\n    const trimmed = value.trim();\n    return trimmed.length > 0 ? trimmed : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction parseBooleanEnv(\n  key: string,\n  fallback: boolean\n): boolean {\n  const raw = getRuntimeEnvValue(key);\n  if (!raw) return fallback;\n  const normalized = raw.toLowerCase();\n  if (normalized === \"true\" || normalized === \"1\" || normalized === \"yes\" || normalized === \"on\") {\n    return true;\n  }\n  if (normalized === \"false\" || normalized === \"0\" || normalized === \"no\" || normalized === \"off\") {\n    return false;\n  }\n  return fallback;\n}\n\nfunction parseNumberEnv(\n  key: string,\n  fallback: number\n): number {\n  const raw = getRuntimeEnvValue(key);\n  if (!raw) return fallback;\n  const parsed = Number(raw);\n  if (!Number.isFinite(parsed)) return fallback;\n  return parsed;\n}\n\nconst toOpenAIEndpointsFromBaseUrl = (baseUrl?: string) => {\n  const trimmed = (baseUrl || \"\").trim().replace(/\\/+$/, \"\");\n  if (!trimmed) {\n    return {\n      transcriptionSessionEndpoint: undefined,\n      translationEndpoint: undefined,\n    };\n  }\n  return {\n    transcriptionSessionEndpoint: `${trimmed}/openai/v1/realtime/transcription_sessions`,\n    translationEndpoint: `${trimmed}/openai/v1/speech/translate-to-english`,\n  };\n};\n\nfunction resolveOpenAIConfig(\n  config?: Partial<SpeechRecognitionConfig>,\n): OpenAIConfigProps {\n  const defaults: OpenAIConfigProps = {\n    realtimeModel: DEFAULT_REALTIME_MODEL,\n    translationModel: DEFAULT_TRANSLATION_MODEL,\n    vadEnabled: true,\n    autoStopOnVadSilence: parseBooleanEnv(\n      \"OPENAI_AUTO_STOP_ON_VAD_SILENCE\",\n      DEFAULT_OPENAI_AUTO_STOP_ON_VAD_SILENCE\n    ),\n    vadThreshold: 0.7,\n    vadPrefixPaddingMs: 400,\n    vadSilenceDurationMs: parseNumberEnv(\n      \"OPENAI_VAD_SILENCE_DURATION_MS\",\n      DEFAULT_OPENAI_VAD_SILENCE_DURATION_MS\n    ),\n    vadIdleTimeoutMs: 6000,\n    prewarmOnMount: parseBooleanEnv(\n      \"OPENAI_PREWARM_ON_MOUNT\",\n      DEFAULT_OPENAI_PREWARM_ON_MOUNT\n    ),\n  };\n\n  const nested = config?.openai || {};\n  const endpointBase = nested.proxyBaseUrl;\n  const derivedEndpoints = toOpenAIEndpointsFromBaseUrl(endpointBase);\n\n  return {\n    ...defaults,\n    ...nested,\n    transcriptionSessionEndpoint:\n      nested.transcriptionSessionEndpoint ||\n      derivedEndpoints.transcriptionSessionEndpoint,\n    translationEndpoint:\n      nested.translationEndpoint || derivedEndpoints.translationEndpoint,\n    realtimeWebRtcUrl: nested.realtimeWebRtcUrl,\n    realtimeModel: nested.realtimeModel || defaults.realtimeModel,\n    translationModel: nested.translationModel || defaults.translationModel,\n    vadEnabled: nested.vadEnabled ?? defaults.vadEnabled,\n    autoStopOnVadSilence:\n      nested.autoStopOnVadSilence ?? defaults.autoStopOnVadSilence,\n    vadThreshold: nested.vadThreshold ?? defaults.vadThreshold,\n    vadPrefixPaddingMs:\n      nested.vadPrefixPaddingMs ?? defaults.vadPrefixPaddingMs,\n    vadSilenceDurationMs:\n      nested.vadSilenceDurationMs ?? defaults.vadSilenceDurationMs,\n    vadIdleTimeoutMs:\n      nested.vadIdleTimeoutMs ?? defaults.vadIdleTimeoutMs,\n    prewarmOnMount:\n      nested.prewarmOnMount ?? defaults.prewarmOnMount,\n  };\n}\n\nfunction resolveGroqConfig(\n  config?: Partial<SpeechRecognitionConfig>,\n): GroqConfigProps {\n  const defaults: GroqConfigProps = {\n    enabled: true,\n    stream: true,\n  };\n\n  return {\n    ...defaults,\n    ...(config?.groq || {}),\n  };\n}\n\nfunction resolveLocalModelConfig(\n  config?: Partial<SpeechRecognitionConfig>,\n): LocalModelConfigProps {\n  const defaults: LocalModelConfigProps = {\n    enabledOnWeb: false,\n    baseUrl: \"http://127.0.0.1:8000\",\n    mode: \"oneshot\",\n    model: \"large-v3-turbo\",\n  };\n\n  return {\n    ...defaults,\n    ...(config?.localModel || {}),\n  };\n}\n\n/**\n * Load speech recognition config from defaults + explicit overrides.\n */\nexport function getSpeechRecognitionConfig(\n  overrides?: Partial<SpeechRecognitionConfig>,\n): SpeechRecognitionConfig {\n  const defaults: SpeechRecognitionConfig = {\n    provider: \"groq\",\n    fallbackToWebSpeech: true,\n    groq: resolveGroqConfig(),\n    openai: resolveOpenAIConfig(),\n    localModel: resolveLocalModelConfig(),\n  };\n\n  const merged: SpeechRecognitionConfig = {\n    ...defaults,\n    ...(overrides || {}),\n    provider:\n      normalizeProvider(overrides?.provider) ||\n      normalizeProvider(defaults.provider) ||\n      \"groq\",\n  };\n\n  return {\n    ...merged,\n    groq: resolveGroqConfig(merged),\n    openai: resolveOpenAIConfig(merged),\n    localModel: resolveLocalModelConfig(merged),\n  };\n}\n\n/**\n * Check if Web Speech API is available\n */\nfunction checkWebSpeechAvailability(): boolean {\n  if (typeof window === \"undefined\") {\n    return false;\n  }\n\n  return \"webkitSpeechRecognition\" in window || \"SpeechRecognition\" in window;\n}\n\nexport const isWebSpeechAvailable = checkWebSpeechAvailability;\n\nconst normalizeLanguageTag = (lang?: string) => {\n  const normalized = (lang || \"en\").trim().toLowerCase();\n  return normalized.length > 0 ? normalized : \"en\";\n};\n\nconst toShortLanguageCode = (lang: string) => lang.split(\"-\")[0];\n\nconst toWebSpeechLocale = (lang: string) => {\n  if (lang.startsWith(\"en\")) return \"en-US\";\n  if (lang.startsWith(\"de\")) return \"de-DE\";\n  return lang;\n};\n\n/**\n * Types of speech recognition methods\n */\ntype SpeechRecognitionMode =\n  | \"openai-web\"\n  | \"openai-native\"\n  | \"groq-web\"\n  | \"groq-native\"\n  | \"webspeech\"\n  | \"mlx-local\"\n  | \"none\";\n\ntype NativeSpeechModule = typeof import(\"./speech-recognition-native\");\nlet nativeSpeechModuleCache: NativeSpeechModule | null | undefined;\ntype OpenAINativeSpeechModule = typeof import(\"./speech-recognition-openai-native\");\nlet openAiNativeSpeechModuleCache: OpenAINativeSpeechModule | null | undefined;\n\nfunction getNativeSpeechModule(): NativeSpeechModule | null {\n  if (nativeSpeechModuleCache !== undefined) {\n    return nativeSpeechModuleCache;\n  }\n\n  try {\n    // Keep native module lazy to avoid loading native-only dependencies on web.\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    nativeSpeechModuleCache = require(\"./speech-recognition-native\");\n  } catch (error) {\n    nativeSpeechModuleCache = null;\n    logger.debug(\"Native speech module unavailable:\", error);\n  }\n\n  return nativeSpeechModuleCache;\n}\n\nfunction isNativeRecognizerAvailable(): boolean {\n  const nativeModule = getNativeSpeechModule();\n  return !!nativeModule?.isNativeSpeechAvailable?.();\n}\n\nfunction getOpenAINativeSpeechModule(): OpenAINativeSpeechModule | null {\n  if (openAiNativeSpeechModuleCache !== undefined) {\n    return openAiNativeSpeechModuleCache;\n  }\n\n  try {\n    // Keep native module lazy to avoid loading native-only dependencies on web.\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    openAiNativeSpeechModuleCache = require(\"./speech-recognition-openai-native\");\n  } catch (error) {\n    openAiNativeSpeechModuleCache = null;\n    logger.debug(\"OpenAI native speech module unavailable:\", error);\n  }\n\n  return openAiNativeSpeechModuleCache;\n}\n\nfunction isOpenAINativeRecognizerAvailable(): boolean {\n  const nativeModule = getOpenAINativeSpeechModule();\n  return !!nativeModule?.isOpenAINativeSpeechAvailable?.();\n}\n\n/**\n * Determine which speech recognition method to use\n */\nexport function selectSpeechRecognitionMethod(\n  config: SpeechRecognitionConfig,\n  clientSecret?: string,\n): SpeechRecognitionMode {\n  const isWeb = Platform.OS === \"web\";\n  const isNative = Platform.OS === \"ios\" || Platform.OS === \"android\";\n  const isWebClientRuntime = isWeb && typeof window !== \"undefined\";\n  const shouldWarnUnavailable = isWebClientRuntime;\n  const provider = normalizeProvider(config.provider) || \"groq\";\n  const groq = resolveGroqConfig(config);\n  const openai = resolveOpenAIConfig(config);\n  const localModel = resolveLocalModelConfig(config);\n\n  const hasGroqKey = !!(clientSecret || groq.apiKey);\n\n  if (provider === \"openai\") {\n    if (isNative) {\n      if (\n        openai.transcriptionSessionEndpoint &&\n        isOpenAINativeRecognizerAvailable()\n      ) {\n        logger.info(\"✅ Using OpenAI Native Realtime (WebRTC)\");\n        return \"openai-native\";\n      }\n      if (shouldWarnUnavailable) {\n        logger.warn(\n          \"⚠️ OpenAI native speech unavailable. Configure OPENAI_TRANSCRIPTION_SESSION_ENDPOINT and install react-native-webrtc.\",\n        );\n      }\n      return \"none\";\n    }\n\n    if (isWeb) {\n      if (openai.transcriptionSessionEndpoint && isOpenAISpeechAvailable()) {\n        logger.info(\"✅ Using OpenAI Web Realtime (WebRTC)\");\n        return \"openai-web\";\n      }\n      if (shouldWarnUnavailable) {\n        logger.warn(\"⚠️ OpenAI web speech unavailable\");\n      }\n      return \"none\";\n    }\n  }\n\n  // Native platforms: Use native Groq implementation\n  if (isNative) {\n    if (groq.enabled && hasGroqKey && isNativeRecognizerAvailable()) {\n      logger.info(\"✅ Using Groq Native (expo-audio)\");\n      return \"groq-native\";\n    }\n    if (shouldWarnUnavailable) {\n      logger.warn(\n        \"⚠️ No speech recognition available on native (install expo-audio + expo-file-system and run a dev client build)\",\n      );\n    }\n    return \"none\";\n  }\n\n  // Web platform: Can use both, prefer based on config\n  if (isWeb) {\n    if (localModel.enabledOnWeb && localModel.baseUrl) {\n      logger.info(\"✅ Using Local MLX Whisper server\");\n      return \"mlx-local\";\n    }\n\n    // Use Groq if enabled and available\n    if (groq.enabled && hasGroqKey && isGroqSpeechAvailable()) {\n      logger.info(\"✅ Using Groq Web (Enabled and available)\");\n      return \"groq-web\";\n    }\n\n    // Fallback to Web Speech API\n    if (config.fallbackToWebSpeech && isWebSpeechAvailable()) {\n      logger.info(\"✅ Using Web Speech API (Fallback)\");\n      return \"webspeech\";\n    }\n  }\n  if (shouldWarnUnavailable) {\n    logger.warn(\"⚠️ No speech recognition method available\");\n  }\n  return \"none\";\n}\n\n/**\n * Unified Speech Recognizer Component\n * Automatically selects and uses the best speech recognition method\n */\nexport const UnifiedSpeechRecognizer: React.FC<\n  UnifiedSpeechRecognizerProps\n> = ({\n  shouldListen,\n  speechStatusCallback,\n  speechResultCallback,\n  speechTranslationCallback,\n  speechReadyCallback,\n  waveformPreviewCallback,\n  clientSecret,\n  language = \"en\",\n  onError,\n  requestContextProvider,\n  config,\n}: UnifiedSpeechRecognizerProps) => {\n  // Get configuration\n  const resolvedConfig = getSpeechRecognitionConfig(config);\n  const isWebClientRuntime =\n    Platform.OS === \"web\" && typeof window !== \"undefined\";\n  const normalizedLanguage = normalizeLanguageTag(language);\n  const apiLanguage = toShortLanguageCode(normalizedLanguage);\n  const webSpeechLanguage = toWebSpeechLocale(normalizedLanguage);\n\n  // Determine which method to use\n  const method = selectSpeechRecognitionMethod(resolvedConfig, clientSecret);\n  if (isWebClientRuntime) {\n    logger.debug(\"Selected speech recognition method:\", method);\n  }\n  const groqConfig = resolveGroqConfig(resolvedConfig);\n  const openaiConfig = resolveOpenAIConfig(resolvedConfig);\n  const localModelConfig = resolveLocalModelConfig(resolvedConfig);\n\n  const finalGroqApiKey = clientSecret || groqConfig.apiKey || \"\";\n  const groqApiBaseUrl = groqConfig.apiBaseUrl;\n  const groqTranscriptionEndpoint = groqConfig.transcriptionEndpoint;\n  const streamGroq = groqConfig.stream;\n\n  if (groqConfig.enabled && !finalGroqApiKey) {\n    logger.warn(\n      \"Groq speech is enabled but no API key was provided. Pass a non-secret client key or disable Groq speech.\",\n    );\n  }\n\n  // Error handler with fallback\n  const handleError = (error: Error) => {\n    logger.error(\"Speech recognition error:\", error);\n\n    if (onError) {\n      onError(error);\n    }\n\n    // If Groq fails and fallback is enabled, we could switch to Web Speech\n    // (This would require more complex state management)\n  };\n\n  // Render appropriate component based on method\n  switch (method) {\n    case \"openai-native\": {\n      if (!openaiConfig.transcriptionSessionEndpoint) {\n        logger.error(\n          \"OpenAI transcription session endpoint is required but not provided\",\n        );\n        return null;\n      }\n\n      const openaiNativeModule = getOpenAINativeSpeechModule();\n      if (!openaiNativeModule?.OpenAINativeSpeechRecognizer) {\n        logger.error(\n          \"OpenAI native speech module unavailable. Install react-native-webrtc and use a native/dev build.\",\n        );\n        return null;\n      }\n\n      const OpenAINativeSpeechRecognizer =\n        openaiNativeModule.OpenAINativeSpeechRecognizer;\n\n      return (\n        <OpenAINativeSpeechRecognizer\n          shouldListen={shouldListen}\n          speechStatusCallback={speechStatusCallback}\n          speechResultCallback={speechResultCallback}\n          speechTranslationCallback={speechTranslationCallback}\n          speechReadyCallback={speechReadyCallback}\n          clientSecret={finalGroqApiKey}\n          openaiTranscriptionSessionEndpoint={\n            openaiConfig.transcriptionSessionEndpoint\n          }\n          openaiTranslationEndpoint={openaiConfig.translationEndpoint}\n          openaiRealtimeWebRtcUrl={openaiConfig.realtimeWebRtcUrl}\n          openaiRealtimeModel={openaiConfig.realtimeModel}\n          openaiTranslationModel={openaiConfig.translationModel}\n          openaiVadEnabled={openaiConfig.vadEnabled}\n          openaiAutoStopOnVadSilence={\n            openaiConfig.autoStopOnVadSilence\n          }\n          openaiVadThreshold={openaiConfig.vadThreshold}\n          openaiVadPrefixPaddingMs={openaiConfig.vadPrefixPaddingMs}\n          openaiVadSilenceDurationMs={\n            openaiConfig.vadSilenceDurationMs\n          }\n          openaiVadIdleTimeoutMs={openaiConfig.vadIdleTimeoutMs}\n          openaiPrewarmOnMount={openaiConfig.prewarmOnMount}\n          language={apiLanguage}\n          requestContextProvider={requestContextProvider}\n          onError={handleError}\n        />\n      );\n    }\n\n    case \"openai-web\":\n      if (!openaiConfig.transcriptionSessionEndpoint) {\n        logger.error(\n          \"OpenAI transcription session endpoint is required but not provided\",\n        );\n        return null;\n      }\n\n      return (\n        <OpenAISpeechRecognizer\n          shouldListen={shouldListen}\n          speechStatusCallback={speechStatusCallback}\n          speechResultCallback={speechResultCallback}\n          speechTranslationCallback={speechTranslationCallback}\n          speechReadyCallback={speechReadyCallback}\n          clientSecret={finalGroqApiKey}\n          openaiTranscriptionSessionEndpoint={\n            openaiConfig.transcriptionSessionEndpoint\n          }\n          openaiTranslationEndpoint={openaiConfig.translationEndpoint}\n          openaiRealtimeWebRtcUrl={openaiConfig.realtimeWebRtcUrl}\n          openaiRealtimeModel={openaiConfig.realtimeModel}\n          openaiTranslationModel={openaiConfig.translationModel}\n          openaiVadEnabled={openaiConfig.vadEnabled}\n          openaiAutoStopOnVadSilence={\n            openaiConfig.autoStopOnVadSilence\n          }\n          openaiVadThreshold={openaiConfig.vadThreshold}\n          openaiVadPrefixPaddingMs={openaiConfig.vadPrefixPaddingMs}\n          openaiVadSilenceDurationMs={\n            openaiConfig.vadSilenceDurationMs\n          }\n          openaiVadIdleTimeoutMs={openaiConfig.vadIdleTimeoutMs}\n          openaiPrewarmOnMount={openaiConfig.prewarmOnMount}\n          language={apiLanguage}\n          requestContextProvider={requestContextProvider}\n          onError={handleError}\n        />\n      );\n\n    case \"groq-native\": {\n      if (!finalGroqApiKey) {\n        logger.error(\"Groq API key is required but not provided\");\n        return null;\n      }\n\n      const nativeModule = getNativeSpeechModule();\n      if (!nativeModule?.NativeSpeechRecognizer) {\n        logger.error(\n          \"Native speech module is unavailable. Install expo-audio + expo-file-system and use a dev client build.\",\n        );\n        return null;\n      }\n\n      const NativeSpeechRecognizer = nativeModule.NativeSpeechRecognizer;\n      return (\n        <NativeSpeechRecognizer\n          shouldListen={shouldListen}\n          speechStatusCallback={speechStatusCallback}\n          speechResultCallback={speechResultCallback}\n          speechTranslationCallback={speechTranslationCallback}\n          clientSecret={finalGroqApiKey}\n          groqApiBaseUrl={groqApiBaseUrl}\n          groqTranscriptionEndpoint={groqTranscriptionEndpoint}\n          stream={streamGroq}\n          language={apiLanguage}\n          onError={handleError}\n        />\n      );\n    }\n\n    case \"groq-web\":\n      if (!finalGroqApiKey) {\n        logger.error(\"Groq API key is required but not provided\");\n        return null;\n      }\n      return (\n        <GroqSpeechRecognizer\n          shouldListen={shouldListen}\n          speechStatusCallback={speechStatusCallback}\n          speechResultCallback={speechResultCallback}\n          speechTranslationCallback={speechTranslationCallback}\n          clientSecret={finalGroqApiKey}\n          groqApiBaseUrl={groqApiBaseUrl}\n          groqTranscriptionEndpoint={groqTranscriptionEndpoint}\n          stream={streamGroq}\n          language={apiLanguage}\n          onError={handleError}\n        />\n      );\n\n    case \"mlx-local\": {\n      const effectiveUrl = localModelConfig.baseUrl;\n      if (!effectiveUrl) {\n        logger.error(\"Local whisper URL is required but not provided\");\n        return null;\n      }\n\n      return (\n        <MLXSpeechRecognizer\n          shouldListen={shouldListen}\n          speechStatusCallback={speechStatusCallback}\n          speechResultCallback={speechResultCallback}\n          language={apiLanguage}\n          onError={handleError}\n          baseUrl={effectiveUrl}\n          mode={localModelConfig.mode}\n          modelName={localModelConfig.model}\n        />\n      );\n    }\n\n    case \"webspeech\":\n      return (\n        <WebSpeechRecognizer\n          shouldListen={shouldListen}\n          speechStatusCallback={speechStatusCallback}\n          speechResultCallback={speechResultCallback}\n          language={webSpeechLanguage}\n        />\n      );\n\n    case \"none\":\n    default:\n      if (isWebClientRuntime) {\n        logger.warn(\"No speech recognition available\");\n      }\n      return null;\n  }\n};\n\n/**\n * Get speech recognition status and capabilities\n */\nexport function getSpeechRecognitionStatus(\n  overrides?: Partial<SpeechRecognitionConfig>,\n) {\n  const config = getSpeechRecognitionConfig(overrides);\n  const method = selectSpeechRecognitionMethod(config);\n  const localModel = resolveLocalModelConfig(config);\n\n  return {\n    method,\n    config,\n    capabilities: {\n      groq: getGroqSpeechCapabilities(),\n      openai: getOpenAISpeechCapabilities(),\n      webSpeech: {\n        available: isWebSpeechAvailable(),\n        platform: Platform.OS,\n      },\n      localModel: {\n        enabled: !!localModel.enabledOnWeb,\n        url: localModel.baseUrl,\n        mode: localModel.mode || \"oneshot\",\n      },\n    },\n    recommendations: getRecommendations(method, config),\n  };\n}\n\n/**\n * Get recommendations for improving speech recognition\n */\nfunction getRecommendations(\n  method:\n    | \"openai-web\"\n    | \"openai-native\"\n    | \"groq-web\"\n    | \"groq-native\"\n    | \"webspeech\"\n    | \"mlx-local\"\n    | \"none\",\n  config: SpeechRecognitionConfig,\n): string[] {\n  const recommendations: string[] = [];\n\n  if (method === \"none\") {\n    recommendations.push(\"No speech recognition available\");\n\n    if (!config.groq?.apiKey && config.provider !== \"openai\") {\n      recommendations.push(\n        \"Provide a Groq client secret via config or disable Groq speech\",\n      );\n    }\n\n    if (Platform.OS === \"web\") {\n      if (!isGroqSpeechAvailable()) {\n        recommendations.push(\"Browser does not support MediaRecorder API\");\n      }\n\n      if (!isWebSpeechAvailable()) {\n        recommendations.push(\"Browser does not support Web Speech API\");\n      }\n    } else {\n      recommendations.push(\n        \"Install expo-audio + expo-file-system and use a dev client build\",\n      );\n    }\n  }\n\n  if (method === \"webspeech\") {\n    recommendations.push(\"Using Web Speech API (free but less accurate)\");\n    recommendations.push(\"Enable Groq speech for better accuracy\");\n  }\n\n  if (method === \"groq-web\") {\n    recommendations.push(\"Using Groq Web (high accuracy, best for web)\");\n  }\n\n  if (method === \"groq-native\") {\n    recommendations.push(\"Using Groq Native capture (expo-audio)\");\n  }\n\n  if (method === \"openai-web\") {\n    recommendations.push(\"Using OpenAI Web Realtime with server VAD\");\n  }\n\n  if (method === \"openai-native\") {\n    recommendations.push(\"Using OpenAI Native Realtime with PCM stream\");\n  }\n\n  if (method === \"mlx-local\") {\n    recommendations.push(\"Using Local MLX Whisper server (fast, offline)\");\n    if (!config.localModel?.baseUrl) {\n      recommendations.push(\"Set LOCAL_WHISPER_URL to point at your server\");\n    }\n  }\n\n  return recommendations;\n}\n\n// Export for convenience\nexport {\n  isGroqSpeechAvailable,\n  getGroqSpeechCapabilities,\n  isOpenAISpeechAvailable,\n  getOpenAISpeechCapabilities,\n};\n\n// Default export\nexport default UnifiedSpeechRecognizer;\n"],"mappings":"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","ignoreList":[]}