@absolutejs/voice-deepgram 0.0.19 → 0.0.20-beta.0

package/dist/index.js

@@ -88,7 +88,28 @@ var collectPhraseHintTerms = (options) => (options.phraseHints ?? []).flatMap((h
   hint.text,
   ...hint.aliases ?? []
 ]);
+var collectLexiconTerms = (options) => (options.lexicon ?? []).flatMap((entry) => [
+  entry.text,
+  ...entry.aliases ?? []
+]);
 var normalizeKeyterms = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
+var MAX_KEYTERM_COUNT = 16;
+var MAX_KEYTERM_LENGTH = 48;
+var countScripts = (value) => {
+  const scripts = new Set;
+  if (/\p{Script=Latin}/u.test(value)) {
+    scripts.add("latin");
+  }
+  if (/\p{Script=Devanagari}/u.test(value)) {
+    scripts.add("devanagari");
+  }
+  return scripts.size;
+};
+var scoreKeytermCandidate = (value) => {
+  const normalized = value.trim();
+  return (countScripts(normalized) >= 2 ? 40 : 0) + (normalized.includes(" ") ? 20 : 0) + (/[^\x00-\x7F]/u.test(normalized) ? 10 : 0) + (normalized.includes("'") ? 5 : 0) + Math.min(normalized.length, 20);
+};
+var selectKeyterms = (terms) => terms.map((term) => term.trim()).filter((term) => term.length >= 2 && term.length <= MAX_KEYTERM_LENGTH).filter((term, index, list) => list.indexOf(term) === index).sort((left, right) => scoreKeytermCandidate(right) - scoreKeytermCandidate(left)).slice(0, MAX_KEYTERM_COUNT);
 var formatErrorMessage = (details) => {
   const parts = [
     details.code ? `code=${details.code}` : undefined,
@@ -123,8 +144,17 @@ var normalizeWords = (words) => {
   }
   const first = words[0];
   const last = words.at(-1);
+  const speakerCounts = new Map;
+  for (const word of words) {
+    if (typeof word.speaker !== "number") {
+      continue;
+    }
+    speakerCounts.set(word.speaker, (speakerCounts.get(word.speaker) ?? 0) + 1);
+  }
+  const speaker = [...speakerCounts.entries()].sort((left, right) => right[1] - left[1])[0]?.[0];
   return {
     endedAtMs: typeof last?.end === "number" ? Math.round(last.end * 1000) : undefined,
+    speaker,
     startedAtMs: typeof first?.start === "number" ? Math.round(first.start * 1000) : undefined
   };
 };
@@ -160,79 +190,113 @@ var buildFluxTranscript = (payload) => {
   };
 };
 var omitUndefined = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-var buildLiveOptions = (config, format) => {
-  const isFlux = String(config.model).startsWith("flux");
-  const language = typeof config.language === "string" && config.language.trim().length > 0 ? config.language.trim() : undefined;
-  const options = {
+var normalizeLanguageCode = (value) => {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : undefined;
+};
+var resolveStrategyLanguage = (options) => {
+  if (options.languageStrategy?.mode !== "fixed") {
+    return;
+  }
+  return normalizeLanguageCode(options.languageStrategy.primaryLanguage);
+};
+var resolveDeepgramModel = (config, options) => {
+  if (config.model !== "flux") {
+    return config.model;
+  }
+  if (options.languageStrategy?.mode === "allow-switching" || options.languageStrategy?.mode === "auto-detect") {
+    return "flux-general-multi";
+  }
+  const language = normalizeLanguageCode(options.languageStrategy?.mode === "fixed" ? options.languageStrategy.primaryLanguage : config.language);
+  if (!language || language.startsWith("en")) {
+    return "flux-general-en";
+  }
+  return "flux-general-multi";
+};
+var buildLiveOptions = (config, format, options) => {
+  const model = resolveDeepgramModel(config, options);
+  const isFlux = String(model).startsWith("flux");
+  const language = normalizeLanguageCode(config.language) ?? resolveStrategyLanguage(options);
+  const liveOptions = {
     encoding: "linear16",
-    model: config.model,
+    model,
     sample_rate: format.sampleRateHz
   };
   if (!isFlux) {
-    options.channels = format.channels;
+    liveOptions.channels = format.channels;
     if (config.punctuate !== undefined) {
-      options.punctuate = config.punctuate;
+      liveOptions.punctuate = config.punctuate;
     }
     if (config.smartFormat !== undefined) {
-      options.smart_format = config.smartFormat;
+      liveOptions.smart_format = config.smartFormat;
     }
     if (config.interimResults !== undefined) {
-      options.interim_results = config.interimResults;
+      liveOptions.interim_results = config.interimResults;
     }
     if (config.endpointing !== undefined) {
-      options.endpointing = config.endpointing;
+      liveOptions.endpointing = config.endpointing;
     }
     if (language) {
-      options.language = language;
+      liveOptions.language = language;
     }
     if (config.utteranceEndMs !== undefined) {
-      options.utterance_end_ms = config.utteranceEndMs;
+      liveOptions.utterance_end_ms = config.utteranceEndMs;
     }
     if (config.vadEvents !== undefined) {
-      options.vad_events = config.vadEvents;
+      liveOptions.vad_events = config.vadEvents;
     }
   } else {
-    options.eager_eot_threshold = config.eagerEotThreshold ?? 0.8;
-    options.eot_threshold = config.eotThreshold ?? 0.82;
-    options.eot_timeout_ms = config.eotTimeoutMs ?? 1200;
+    liveOptions.eager_eot_threshold = config.eagerEotThreshold ?? 0.8;
+    liveOptions.eot_threshold = config.eotThreshold ?? 0.82;
+    liveOptions.eot_timeout_ms = config.eotTimeoutMs ?? 1200;
   }
   if (!isFlux && config.diarize !== undefined) {
-    options.diarize = config.diarize;
+    liveOptions.diarize = config.diarize;
   }
   if (!isFlux && config.numerals !== undefined) {
-    options.numerals = config.numerals;
+    liveOptions.numerals = config.numerals;
   }
   if (!isFlux && config.profanityFilter !== undefined) {
-    options.profanity_filter = config.profanityFilter;
+    liveOptions.profanity_filter = config.profanityFilter;
   }
   if (!isFlux && config.redact !== undefined) {
-    options.redact = config.redact;
+    liveOptions.redact = config.redact;
   }
   if (config.tag !== undefined) {
-    options.tag = config.tag;
+    liveOptions.tag = config.tag;
   }
   if (config.extra) {
-    options.extra = config.extra;
+    liveOptions.extra = config.extra;
   }
   const keyterm = config.keyterms ?? config.keyterm;
   if (keyterm !== undefined) {
-    options.keyterm = keyterm;
+    liveOptions.keyterm = keyterm;
   }
-  return omitUndefined(options);
+  return omitUndefined(liveOptions);
 };
 var buildUrl = (config, input) => {
-  const url = new URL(String(config.model).startsWith("flux") ? LISTEN_V2_URL : LISTEN_V1_URL);
+  const context = {
+    format: {
+      channels: input.context.format.channels,
+      container: "raw",
+      encoding: "pcm_s16le",
+      sampleRateHz: input.context.format.sampleRateHz
+    },
+    languageStrategy: input.context.languageStrategy,
+    lexicon: input.context.lexicon,
+    sessionId: input.context.sessionId
+  };
+  const url = new URL(String(resolveDeepgramModel(config, context)).startsWith("flux") ? LISTEN_V2_URL : LISTEN_V1_URL);
   const keytermTerms = [
     ...normalizeKeyterms(config.keyterms ?? config.keyterm),
+    ...collectLexiconTerms(context),
     ...input.phraseHintTerms ?? []
-  ].filter((value, index, list) => list.indexOf(value) === index);
+  ];
+  const selectedKeyterms = selectKeyterms(keytermTerms);
   const options = buildLiveOptions({
     ...config,
-    keyterms: keytermTerms.length > 0 ? keytermTerms : config.keyterms
-  }, {
-    channels: input.channels,
-    sampleRateHz: input.sampleRateHz
-  });
+    keyterms: selectedKeyterms.length > 0 ? selectedKeyterms : config.keyterms
+  }, input.context.format, context);
   for (const [key, value] of Object.entries(options)) {
     if (isNil(value)) {
       continue;
@@ -275,12 +339,20 @@ var resolveOpenFailure = (error, url, timeoutMs) => {
 var deepgram = (config) => ({
   kind: "stt",
   open: async (options) => {
+    const runtimeOptions = options;
     const emitsNativeEndOfTurn = String(config.model).startsWith("flux");
     const listeners = createListenerMap();
     const url = buildUrl(config, {
-      channels: options.format.channels,
-      phraseHintTerms: collectPhraseHintTerms(options),
-      sampleRateHz: options.format.sampleRateHz
+      context: {
+        format: {
+          channels: runtimeOptions.format.channels,
+          sampleRateHz: runtimeOptions.format.sampleRateHz
+        },
+        languageStrategy: runtimeOptions.languageStrategy,
+        lexicon: runtimeOptions.lexicon,
+        sessionId: runtimeOptions.sessionId
+      },
+      phraseHintTerms: collectPhraseHintTerms(runtimeOptions)
     });
     const connection = await createTransport(url, config.apiKey, config.authMode);
     const connectTimeoutMs = config.connectTimeoutMs ?? 8000;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice-deepgram",
-	"version": "0.0.19",
+	"version": "0.0.20-beta.0",
 	"description": "Deepgram speech-to-text adapter for @absolutejs/voice",
 	"repository": {
 		"type": "git",
@@ -28,7 +28,7 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"dependencies": {
-		"@absolutejs/voice": "0.0.21"
+		"@absolutejs/voice": "0.0.22-beta.0"
 	},
 	"devDependencies": {
 		"@absolutejs/absolute": "0.19.0-beta.648",