@contentgrowth/llm-service 0.9.91 → 0.9.93

package/dist/ui/react/components/index.js

@@ -161,76 +161,32 @@ var useSpeechRecognition = (onResult, onEnd, language = "en-US") => {
   const recognitionRef = useRef(null);
   const isSimulatingRef = useRef(false);
   const simulationTimeoutRef = useRef(null);
+  const languageRef = useRef(language);
+  const instanceIdRef = useRef(Math.random().toString(36).slice(2));
+  const lastStartAtRef = useRef(null);
+  const lastStopAtRef = useRef(null);
   const onResultRef = useRef(onResult);
   const onEndRef = useRef(onEnd);
   useEffect(() => {
     onResultRef.current = onResult;
     onEndRef.current = onEnd;
   }, [onResult, onEnd]);
+  useEffect(() => {
+    languageRef.current = language;
+    if (recognitionRef.current) {
+      console.log("[useSpeechRecognition] Updating language to:", language);
+      recognitionRef.current.lang = language;
+    }
+  }, [language]);
   const isStartingRef = useRef(false);
   useEffect(() => {
+    var _a;
     if (typeof window !== "undefined") {
       const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
-      if (SpeechRecognition) {
-        setIsSupported(true);
-        const recognition = new SpeechRecognition();
-        recognition.continuous = true;
-        recognition.interimResults = true;
-        recognition.onstart = () => {
-          console.log("[useSpeechRecognition] Native onstart event fired");
-          isStartingRef.current = false;
-          setIsListening(true);
-          setError(null);
-        };
-        recognition.onend = () => {
-          console.log("[useSpeechRecognition] Native onend event fired");
-          isStartingRef.current = false;
-          if (isSimulatingRef.current) {
-            return;
-          }
-          setIsListening(false);
-          if (onEndRef.current) onEndRef.current();
-        };
-        recognition.onresult = (event) => {
-          let interimTranscript = "";
-          let finalTranscript = "";
-          for (let i = event.results.length - 1; i < event.results.length; ++i) {
-            const result = event.results[i];
-            if (result.isFinal) {
-              finalTranscript += result[0].transcript;
-              if (onResultRef.current) onResultRef.current(finalTranscript, true);
-            } else {
-              interimTranscript += result[0].transcript;
-              if (onResultRef.current) onResultRef.current(interimTranscript, false);
-            }
-          }
-          setTranscript((prev) => prev + finalTranscript);
-        };
-        recognition.onerror = (event) => {
-          console.error("[useSpeechRecognition] Native onerror event:", event.error);
-          isStartingRef.current = false;
-          if (event.error === "not-allowed" && process.env.NODE_ENV === "development") {
-            console.warn("Speech recognition blocked. Simulating input for development...");
-            isSimulatingRef.current = true;
-            setError(null);
-            setIsListening(true);
-            simulationTimeoutRef.current = setTimeout(() => {
-              const mockText = "This is a simulated voice input for testing.";
-              setTranscript((prev) => prev + (prev ? " " : "") + mockText);
-              if (onResultRef.current) onResultRef.current(mockText, true);
-              isSimulatingRef.current = false;
-              setIsListening(false);
-              if (onEndRef.current) onEndRef.current();
-              simulationTimeoutRef.current = null;
-            }, 3e3);
-            return;
-          }
-          console.error("Speech recognition error", event.error);
-          setError(event.error);
-          setIsListening(false);
-        };
-        recognitionRef.current = recognition;
-      }
+      console.log("[useSpeechRecognition] Env - isSecureContext:", window.isSecureContext, "protocol:", (_a = window.location) == null ? void 0 : _a.protocol);
+      const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || "ontouchstart" in window || navigator.maxTouchPoints > 0;
+      console.log("[useSpeechRecognition] Init check - SpeechRecognition available:", !!SpeechRecognition, "isMobile:", isMobile, "instanceId:", instanceIdRef.current);
+      setIsSupported(!!SpeechRecognition);
     }
     return () => {
       console.log("[useSpeechRecognition] Effect cleanup - stopping recognition");
@@ -239,49 +195,204 @@ var useSpeechRecognition = (onResult, onEnd, language = "en-US") => {
         simulationTimeoutRef.current = null;
       }
       if (recognitionRef.current) {
-        recognitionRef.current.stop();
+        try {
+          recognitionRef.current.stop();
+        } catch (e) {
+        }
+        recognitionRef.current = null;
+      }
+      if (typeof window !== "undefined") {
+        const w = window;
+        if (w.__llmSpeechRecognitionActiveInstanceId === instanceIdRef.current) {
+          console.log("[useSpeechRecognition] Cleanup clearing global active instance lock. instanceId:", instanceIdRef.current);
+          w.__llmSpeechRecognitionActiveInstanceId = null;
+        }
       }
     };
   }, []);
-  useEffect(() => {
-    if (recognitionRef.current) {
-      console.log("[useSpeechRecognition] Updating language to:", language);
-      recognitionRef.current.lang = language;
+  const createRecognitionInstance = useCallback(() => {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (!SpeechRecognition) {
+      console.error("[useSpeechRecognition] SpeechRecognition not available");
+      return null;
     }
-  }, [language]);
+    console.log("[useSpeechRecognition] Creating NEW recognition instance within user gesture context. Timestamp:", Date.now());
+    const recognition = new SpeechRecognition();
+    const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || "ontouchstart" in window || navigator.maxTouchPoints > 0;
+    recognition.continuous = !isMobile;
+    recognition.interimResults = true;
+    recognition.lang = languageRef.current;
+    console.log("[useSpeechRecognition] Instance created. continuous:", recognition.continuous, "interimResults:", recognition.interimResults, "lang:", recognition.lang, "isMobile:", isMobile, "instanceId:", instanceIdRef.current);
+    recognition.onaudiostart = () => {
+      console.log("[useSpeechRecognition] Native onaudiostart. Timestamp:", Date.now(), "instanceId:", instanceIdRef.current);
+    };
+    recognition.onaudioend = () => {
+      console.log("[useSpeechRecognition] Native onaudioend. Timestamp:", Date.now(), "instanceId:", instanceIdRef.current);
+    };
+    recognition.onsoundstart = () => {
+      console.log("[useSpeechRecognition] Native onsoundstart. Timestamp:", Date.now(), "instanceId:", instanceIdRef.current);
+    };
+    recognition.onsoundend = () => {
+      console.log("[useSpeechRecognition] Native onsoundend. Timestamp:", Date.now(), "instanceId:", instanceIdRef.current);
+    };
+    recognition.onspeechstart = () => {
+      console.log("[useSpeechRecognition] Native onspeechstart. Timestamp:", Date.now(), "instanceId:", instanceIdRef.current);
+    };
+    recognition.onspeechend = () => {
+      console.log("[useSpeechRecognition] Native onspeechend. Timestamp:", Date.now(), "instanceId:", instanceIdRef.current);
+    };
+    recognition.onnomatch = () => {
+      console.log("[useSpeechRecognition] Native onnomatch. Timestamp:", Date.now(), "instanceId:", instanceIdRef.current);
+    };
+    recognition.onstart = () => {
+      console.log("[useSpeechRecognition] Native onstart event fired. Timestamp:", Date.now());
+      isStartingRef.current = false;
+      setIsListening(true);
+      setError(null);
+      if (typeof window !== "undefined") {
+        const w = window;
+        w.__llmSpeechRecognitionActiveInstanceId = instanceIdRef.current;
+        console.log("[useSpeechRecognition] Set global active instance lock. instanceId:", instanceIdRef.current);
+      }
+    };
+    recognition.onend = () => {
+      console.log("[useSpeechRecognition] Native onend event fired. Timestamp:", Date.now());
+      isStartingRef.current = false;
+      if (isSimulatingRef.current) {
+        console.log("[useSpeechRecognition] onend ignored - simulating");
+        return;
+      }
+      setIsListening(false);
+      if (onEndRef.current) onEndRef.current();
+      if (typeof window !== "undefined") {
+        const w = window;
+        if (w.__llmSpeechRecognitionActiveInstanceId === instanceIdRef.current) {
+          w.__llmSpeechRecognitionActiveInstanceId = null;
+          console.log("[useSpeechRecognition] Cleared global active instance lock. instanceId:", instanceIdRef.current);
+        }
+      }
+    };
+    recognition.onresult = (event) => {
+      console.log("[useSpeechRecognition] onresult event. results count:", event.results.length);
+      let interimTranscript = "";
+      let finalTranscript = "";
+      for (let i = event.results.length - 1; i < event.results.length; ++i) {
+        const result = event.results[i];
+        if (result.isFinal) {
+          finalTranscript += result[0].transcript;
+          console.log("[useSpeechRecognition] Final transcript:", finalTranscript);
+          if (onResultRef.current) onResultRef.current(finalTranscript, true);
+        } else {
+          interimTranscript += result[0].transcript;
+          console.log("[useSpeechRecognition] Interim transcript:", interimTranscript);
+          if (onResultRef.current) onResultRef.current(interimTranscript, false);
+        }
+      }
+      setTranscript((prev) => prev + finalTranscript);
+    };
+    recognition.onerror = (event) => {
+      console.error("[useSpeechRecognition] Native onerror event:", event.error, "Timestamp:", Date.now());
+      console.error("[useSpeechRecognition] Error context - lastStartAt:", lastStartAtRef.current, "lastStopAt:", lastStopAtRef.current, "instanceId:", instanceIdRef.current);
+      console.error("[useSpeechRecognition] Error details - This could be caused by:");
+      if (event.error === "aborted") {
+        console.error("[useSpeechRecognition] - aborted: Recognition was aborted. Common causes: keyboard appeared, focus changed, another recognition started, or page navigation");
+      } else if (event.error === "not-allowed") {
+        console.error("[useSpeechRecognition] - not-allowed: Microphone permission denied");
+      } else if (event.error === "no-speech") {
+        console.error("[useSpeechRecognition] - no-speech: No speech detected");
+      } else if (event.error === "network") {
+        console.error("[useSpeechRecognition] - network: Network error during recognition");
+      }
+      isStartingRef.current = false;
+      if (event.error === "not-allowed" && process.env.NODE_ENV === "development") {
+        console.warn("Speech recognition blocked. Simulating input for development...");
+        isSimulatingRef.current = true;
+        setError(null);
+        setIsListening(true);
+        simulationTimeoutRef.current = setTimeout(() => {
+          const mockText = "This is a simulated voice input for testing.";
+          setTranscript((prev) => prev + (prev ? " " : "") + mockText);
+          if (onResultRef.current) onResultRef.current(mockText, true);
+          isSimulatingRef.current = false;
+          setIsListening(false);
+          if (onEndRef.current) onEndRef.current();
+          simulationTimeoutRef.current = null;
+        }, 3e3);
+        return;
+      }
+      console.error("Speech recognition error", event.error);
+      setError(event.error);
+      setIsListening(false);
+      if (typeof window !== "undefined") {
+        const w = window;
+        if (w.__llmSpeechRecognitionActiveInstanceId === instanceIdRef.current) {
+          w.__llmSpeechRecognitionActiveInstanceId = null;
+          console.log("[useSpeechRecognition] Cleared global active instance lock after error. instanceId:", instanceIdRef.current);
+        }
+      }
+    };
+    return recognition;
+  }, []);
   const start = useCallback(() => {
-    console.log("[useSpeechRecognition] start() called. isListening:", isListening, "isStarting:", isStartingRef.current, "hasInstance:", !!recognitionRef.current);
+    var _a;
+    const startTimestamp = Date.now();
+    console.log("[useSpeechRecognition] start() called. Timestamp:", startTimestamp);
+    console.log("[useSpeechRecognition] State check - isListening:", isListening, "isStarting:", isStartingRef.current, "hasExistingInstance:", !!recognitionRef.current);
+    if (typeof document !== "undefined") {
+      console.log("[useSpeechRecognition] Document hasFocus:", document.hasFocus(), "activeElement:", (_a = document.activeElement) == null ? void 0 : _a.tagName);
+    }
     if (isSimulatingRef.current) {
       console.log("[useSpeechRecognition] isSimulating, ignoring start");
       return;
     }
-    if (!recognitionRef.current) {
-      console.error("[useSpeechRecognition] Recognition instance missing");
-      return;
-    }
     if (isStartingRef.current) {
       console.warn("[useSpeechRecognition] Already starting - ignoring duplicate call");
       return;
     }
-    if (recognitionRef.current.isListening) {
-      console.warn("[useSpeechRecognition] Already listening (native prop) - ignoring");
-    }
     if (isListening) {
       console.warn("[useSpeechRecognition] App state says already listening - ignoring");
       return;
     }
+    if (typeof window !== "undefined") {
+      const w = window;
+      if (w.__llmSpeechRecognitionActiveInstanceId && w.__llmSpeechRecognitionActiveInstanceId !== instanceIdRef.current) {
+        console.error("[useSpeechRecognition] Another recognition instance appears active. activeInstanceId:", w.__llmSpeechRecognitionActiveInstanceId, "thisInstanceId:", instanceIdRef.current);
+      }
+    }
     try {
+      if (recognitionRef.current) {
+        console.log("[useSpeechRecognition] Stopping existing instance before creating new one");
+        try {
+          recognitionRef.current.stop();
+        } catch (e) {
+        }
+        recognitionRef.current = null;
+      }
+      const recognition = createRecognitionInstance();
+      if (!recognition) {
+        console.error("[useSpeechRecognition] Failed to create recognition instance");
+        setError("Speech recognition not available");
+        return;
+      }
+      recognitionRef.current = recognition;
       setTranscript("");
       isStartingRef.current = true;
+      lastStartAtRef.current = Date.now();
+      console.log("[useSpeechRecognition] About to call recognition.start(). Timestamp:", Date.now());
       recognitionRef.current.start();
-      console.log("[useSpeechRecognition] recognition.start() executed successfully");
+      console.log("[useSpeechRecognition] recognition.start() executed successfully. Timestamp:", Date.now());
     } catch (error2) {
       isStartingRef.current = false;
-      console.error("[useSpeechRecognition] Failed to start recognition:", error2);
+      console.error("[useSpeechRecognition] Failed to start recognition:", (error2 == null ? void 0 : error2.message) || error2);
+      if ((error2 == null ? void 0 : error2.name) === "InvalidStateError") {
+        console.error("[useSpeechRecognition] InvalidStateError - recognition may already be running");
+      }
+      setError((error2 == null ? void 0 : error2.message) || "Failed to start speech recognition");
     }
-  }, [isListening]);
+  }, [isListening, createRecognitionInstance]);
   const stop = useCallback(() => {
     console.log("[useSpeechRecognition] stop() called");
+    lastStopAtRef.current = Date.now();
     if (isSimulatingRef.current) {
       if (simulationTimeoutRef.current) {
         clearTimeout(simulationTimeoutRef.current);
@@ -601,26 +712,47 @@ var ChatInputArea = forwardRef(({
       handleSubmit();
     }
   };
+  const isMobile = useCallback3(() => {
+    if (typeof window === "undefined") return false;
+    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  }, []);
   const startRecording = async (trigger) => {
     var _a2;
-    if (voiceTrigger || isTranscribing) return;
+    console.log("[ChatInputArea] startRecording called. trigger:", trigger, "isMobile:", isMobile());
+    console.log("[ChatInputArea] Current state - voiceTrigger:", voiceTrigger, "isTranscribing:", isTranscribing);
+    if (voiceTrigger || isTranscribing) {
+      console.log("[ChatInputArea] startRecording ignored - already active");
+      return;
+    }
     setVoiceTrigger(trigger);
     setVoiceError(null);
+    console.log("[ChatInputArea] Calling voiceConfig.onVoiceStart if exists...");
     (_a2 = voiceConfig == null ? void 0 : voiceConfig.onVoiceStart) == null ? void 0 : _a2.call(voiceConfig);
     if ((voiceConfig == null ? void 0 : voiceConfig.mode) === "native") {
+      console.log("[ChatInputArea] Using native speech recognition");
       if (!nativeSpeech.isSupported) {
+        console.error("[ChatInputArea] Native speech not supported");
         alert("Speech recognition is not supported in this browser.");
         setVoiceTrigger(null);
         return;
       }
+      console.log("[ChatInputArea] Calling nativeSpeech.start()...");
       nativeSpeech.start();
+      console.log("[ChatInputArea] nativeSpeech.start() called");
     } else {
+      console.log("[ChatInputArea] Using custom recorder");
       await customRecorder.start();
+      console.log("[ChatInputArea] Custom recorder started");
+    }
+    if (!isMobile()) {
+      console.log("[ChatInputArea] Re-focusing textarea (desktop only)");
+      setTimeout(() => {
+        var _a3;
+        return (_a3 = textareaRef.current) == null ? void 0 : _a3.focus();
+      }, 0);
+    } else {
+      console.log("[ChatInputArea] SKIPPING textarea focus on mobile to prevent keyboard conflict");
     }
-    setTimeout(() => {
-      var _a3;
-      return (_a3 = textareaRef.current) == null ? void 0 : _a3.focus();
-    }, 0);
   };
   const stopRecording = () => {
     if (!voiceTrigger) return;
@@ -909,18 +1041,22 @@ var TapToTalk = ({
   const isListening = !!voiceTrigger || nativeSpeech.isListening || customRecorder.isRecording;
   const isActive = isListening || isTranscribing;
   const processingRef = useRef4(false);
+  const isMobile = useCallback4(() => {
+    if (typeof window === "undefined") return false;
+    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  }, []);
   const toggleVoice = async (e) => {
     if (e) {
       e.preventDefault();
       e.stopPropagation();
     }
-    console.trace("[TapToTalk] toggleVoice called trace");
+    console.log("[TapToTalk] toggleVoice called. isMobile:", isMobile());
     if (processingRef.current) {
       console.log("[TapToTalk] toggleVoice ignored - processing");
       return;
     }
     processingRef.current = true;
-    console.log("[TapToTalk] toggleVoice called. isActive:", isActive);
+    console.log("[TapToTalk] toggleVoice called. isActive:", isActive, "isListening:", isListening, "isTranscribing:", isTranscribing);
     try {
       const now = Date.now();
       if (now - tapCountRef.current.lastTap < 500) {
@@ -953,29 +1089,39 @@ var TapToTalk = ({
         }
         setVoiceTrigger(null);
       } else {
-        console.log("[TapToTalk] Starting voice...");
+        console.log("[TapToTalk] Starting voice... mode:", voiceConfig == null ? void 0 : voiceConfig.mode);
         setErrorMsg(null);
-        if (onFocusTarget) {
-          console.log("[TapToTalk] calling onFocusTarget() - this might trigger keyboard");
+        if (onFocusTarget && !isMobile()) {
+          console.log("[TapToTalk] calling onFocusTarget() (desktop only)");
           onFocusTarget();
+        } else if (onFocusTarget) {
+          console.log("[TapToTalk] SKIPPING onFocusTarget on mobile to prevent keyboard conflict");
         } else {
           console.log("[TapToTalk] onFocusTarget is undefined");
         }
         setVoiceTrigger("click");
+        console.log("[TapToTalk] voiceTrigger set to click");
         if ((voiceConfig == null ? void 0 : voiceConfig.mode) === "custom") {
+          console.log("[TapToTalk] Starting custom recorder...");
           try {
             await customRecorder.start();
+            console.log("[TapToTalk] Custom recorder started successfully");
           } catch (e2) {
+            console.error("[TapToTalk] Custom recorder failed:", e2);
             setErrorMsg("Mic access denied");
             setVoiceTrigger(null);
           }
         } else {
+          console.log("[TapToTalk] Starting native speech recognition...");
           if (!nativeSpeech.isSupported) {
+            console.error("[TapToTalk] Native speech not supported");
             setErrorMsg("Speech not supported");
             setVoiceTrigger(null);
             return;
           }
+          console.log("[TapToTalk] Calling nativeSpeech.start()...");
           nativeSpeech.start();
+          console.log("[TapToTalk] nativeSpeech.start() called");
         }
       }
     } finally {