@speakableio/core 1.0.60 → 1.0.61

package/dist/index.native.mjs

@@ -2212,80 +2212,18 @@ var createSetRepo = () => {
 };
 
 // src/utils/ai/detect-transcript-hallucionation.ts
-var HALLUCINATION_THRESHOLDS = {
-  // Short repeats
-  MIN_CONSECUTIVE_REPEATS: 5,
-  // Increased from 3 to allow phrases like "pio pio pio" or "no no no no"
-  MIN_WORDS_FOR_RATIO_CHECK: 15,
-  // Increased from 10 to require longer text for ratio check
-  MAX_UNIQUE_WORDS_FOR_RATIO: 3,
-  MIN_REPETITION_RATIO: 4,
-  // Increased from 3 to be more permissive
-  // Phrase repeats
-  MIN_SENTENCE_LENGTH: 15,
-  // Increased from 10 to avoid flagging short natural sentences
-  MIN_CONSECUTIVE_SIMILAR_SENTENCES: 3,
-  // Increased from 2 to allow some natural repetition
-  MIN_SENTENCES_FOR_DUPLICATE_CHECK: 4,
-  // Increased from 3
-  // Cyclic patterns
-  MIN_CYCLE_LENGTH: 30,
-  // Increased from 20 to focus on longer patterns
-  MIN_CYCLE_REPEATS: 3,
-  // Entropy detection
-  MIN_LENGTH_FOR_ENTROPY_CHECK: 60,
-  // Increased from 50
-  MAX_ENTROPY_THRESHOLD: 2.2,
-  // Decreased from 2.5 to be more strict on entropy (lower = more repetitive needed)
-  // Similarity
-  SENTENCE_SIMILARITY_THRESHOLD: 0.85,
-  // Increased from 0.8 to require more similarity
-  SEGMENT_SIMILARITY_THRESHOLD: 0.9
-  // Increased from 0.85
-};
-function detectTranscriptHallucinationWithDetails(transcript) {
+function detectTranscriptHallucination(transcript) {
   if (!transcript || transcript.trim().length === 0) {
-    return { isHallucination: false };
+    return false;
   }
   const text = transcript.trim();
-  if (text.length < 10) {
-    return { isHallucination: false };
-  }
   const shortRepeats = detectShortRepeats(text);
-  if (shortRepeats) {
-    return {
-      isHallucination: true,
-      reason: "Detected repeated short words or phrases",
-      confidence: 0.9
-    };
-  }
+  if (shortRepeats) return true;
   const phraseRepeats = detectPhraseRepeats(text);
-  if (phraseRepeats) {
-    return {
-      isHallucination: true,
-      reason: "Detected repeated sentences or phrases",
-      confidence: 0.85
-    };
-  }
+  if (phraseRepeats) return true;
   const cyclicRepeats = detectCyclicPattern(text);
-  if (cyclicRepeats) {
-    return {
-      isHallucination: true,
-      reason: "Detected cyclic repetition pattern",
-      confidence: 0.8
-    };
-  }
-  if (text.length >= HALLUCINATION_THRESHOLDS.MIN_LENGTH_FOR_ENTROPY_CHECK) {
-    const entropy = calculateEntropy(text);
-    if (entropy < HALLUCINATION_THRESHOLDS.MAX_ENTROPY_THRESHOLD) {
-      return {
-        isHallucination: true,
-        reason: "Detected low entropy (likely gibberish or excessive repetition)",
-        confidence: 0.75
-      };
-    }
-  }
-  return { isHallucination: false };
+  if (cyclicRepeats) return true;
+  return false;
 }
 function detectShortRepeats(text) {
   const words = text.toLowerCase().split(/[\s,;.!?]+/).filter((w) => w.length > 0);
@@ -2294,22 +2232,20 @@ function detectShortRepeats(text) {
   for (let i = 1; i < words.length; i++) {
     if (words[i] === words[i - 1]) {
       repeatCount++;
-      if (repeatCount >= HALLUCINATION_THRESHOLDS.MIN_CONSECUTIVE_REPEATS) {
-        return true;
-      }
+      if (repeatCount >= 3) return true;
     } else {
       repeatCount = 1;
     }
   }
   const uniqueWords = new Set(words);
   const repetitionRatio = words.length / uniqueWords.size;
-  if (words.length >= HALLUCINATION_THRESHOLDS.MIN_WORDS_FOR_RATIO_CHECK && uniqueWords.size <= HALLUCINATION_THRESHOLDS.MAX_UNIQUE_WORDS_FOR_RATIO && repetitionRatio >= HALLUCINATION_THRESHOLDS.MIN_REPETITION_RATIO) {
+  if (words.length >= 10 && uniqueWords.size <= 3 && repetitionRatio >= 3) {
     return true;
   }
   return false;
 }
 function detectPhraseRepeats(text) {
-  const sentences = text.split(/[.!?]+/).map((s) => s.trim().toLowerCase()).filter((s) => s.length > HALLUCINATION_THRESHOLDS.MIN_SENTENCE_LENGTH);
+  const sentences = text.split(/[.!?]+/).map((s) => s.trim().toLowerCase()).filter((s) => s.length > 10);
   if (sentences.length < 2) return false;
   for (let i = 0; i < sentences.length - 1; i++) {
     let consecutiveRepeats = 1;
@@ -2320,17 +2256,17 @@ function detectPhraseRepeats(text) {
         break;
       }
     }
-    if (consecutiveRepeats >= HALLUCINATION_THRESHOLDS.MIN_CONSECUTIVE_SIMILAR_SENTENCES) {
+    if (consecutiveRepeats >= 2) {
       return true;
     }
   }
   const uniqueSentences = new Set(sentences);
-  if (sentences.length >= HALLUCINATION_THRESHOLDS.MIN_SENTENCES_FOR_DUPLICATE_CHECK && uniqueSentences.size === 1) {
+  if (sentences.length >= 3 && uniqueSentences.size === 1) {
     return true;
   }
   return false;
 }
-function isSimilarSentence(s1, s2, threshold = HALLUCINATION_THRESHOLDS.SENTENCE_SIMILARITY_THRESHOLD) {
+function isSimilarSentence(s1, s2) {
   if (s1 === s2) return true;
   const normalized1 = s1.replace(/\s+/g, " ").trim();
   const normalized2 = s2.replace(/\s+/g, " ").trim();
@@ -2342,81 +2278,35 @@ function isSimilarSentence(s1, s2, threshold = HALLUCINATION_THRESHOLDS.SENTENCE
   const set2 = new Set(words2);
   const intersection = new Set([...set1].filter((w) => set2.has(w)));
   const similarity = intersection.size * 2 / (set1.size + set2.size);
-  return similarity >= threshold;
+  return similarity >= 0.8;
 }
 function detectCyclicPattern(text) {
   const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
   const length = normalized.length;
-  const minCycleLength = HALLUCINATION_THRESHOLDS.MIN_CYCLE_LENGTH;
+  const minCycleLength = 20;
   const maxCycleLength = Math.floor(length / 2);
-  if (maxCycleLength < minCycleLength) return false;
-  const step = 5;
-  for (let cycleLen = minCycleLength; cycleLen <= maxCycleLength; cycleLen += step) {
+  for (let cycleLen = minCycleLength; cycleLen <= maxCycleLength; cycleLen++) {
     const pattern = normalized.substring(0, cycleLen);
     let matchCount = 0;
     let pos = 0;
     while (pos < length) {
       const segment = normalized.substring(pos, pos + cycleLen);
-      if (segment.length < cycleLen) {
-        const partialMatch = pattern.startsWith(segment);
-        if (partialMatch && matchCount > 0) {
-          matchCount++;
-        }
-        break;
-      }
-      if (segment === pattern || isSegmentSimilar(segment, pattern)) {
+      if (segment === pattern || isSimilarSentence(segment, pattern)) {
         matchCount++;
         pos += cycleLen;
       } else {
         break;
       }
     }
-    if (matchCount >= HALLUCINATION_THRESHOLDS.MIN_CYCLE_REPEATS) {
+    if (matchCount >= 3) {
       return true;
     }
   }
   return false;
 }
-function isSegmentSimilar(s1, s2) {
-  if (s1 === s2) return true;
-  if (s1.length !== s2.length) return false;
-  let matches = 0;
-  const minLength = Math.min(s1.length, s2.length);
-  for (let i = 0; i < minLength; i++) {
-    if (s1[i] === s2[i]) {
-      matches++;
-    }
-  }
-  const similarity = matches / minLength;
-  return similarity >= HALLUCINATION_THRESHOLDS.SEGMENT_SIMILARITY_THRESHOLD;
-}
-function calculateEntropy(text) {
-  if (!text || text.length === 0) {
-    return 0;
-  }
-  const frequencies = /* @__PURE__ */ new Map();
-  for (const char of text.toLowerCase()) {
-    frequencies.set(char, (frequencies.get(char) || 0) + 1);
-  }
-  let entropy = 0;
-  const length = text.length;
-  for (const count of frequencies.values()) {
-    const probability = count / length;
-    entropy -= probability * Math.log2(probability);
-  }
-  return entropy;
-}
 function cleanHallucinatedTranscript(transcript) {
-  var _a, _b;
-  const result = detectTranscriptHallucinationWithDetails(transcript);
-  if (result.isHallucination) {
-    console.warn(
-      "Hallucinated transcript detected and removed:",
-      transcript.substring(0, 100),
-      `
-Reason: ${(_a = result.reason) != null ? _a : "Unknown"}`,
-      `Confidence: ${String((_b = result.confidence) != null ? _b : "Unknown")}`
-    );
+  if (detectTranscriptHallucination(transcript)) {
+    console.warn("Hallucinated transcript detected and removed:", transcript.substring(0, 100));
     return "";
   }
   return transcript;
@@ -2424,7 +2314,7 @@ Reason: ${(_a = result.reason) != null ? _a : "Unknown"}`,
 
 // src/utils/ai/get-transcript.ts
 async function getTranscript(model, args, cleanHallucinations = true) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g;
   const getGeminiTranscript = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "getGeminiTranscript");
   const getAssemblyAITranscript = (_d = (_c = api).httpsCallable) == null ? void 0 : _d.call(_c, "transcribeAssemblyAIAudio");
   const getWhisperTranscript = (_f = (_e = api).httpsCallable) == null ? void 0 : _f.call(_e, "generateGroqTranscript");
@@ -2445,7 +2335,7 @@ async function getTranscript(model, args, cleanHallucinations = true) {
       const { data } = await (getGeminiTranscript == null ? void 0 : getGeminiTranscript({
         audioUrl: args.audioUrl,
         targetLanguage: args.language,
-        prompt: args.prompt
+        prompt: (_g = args.prompt) != null ? _g : ""
       }));
       return cleanHallucinations ? cleanHallucinatedTranscript(data.transcript) : data.transcript;
     } catch (error) {