@juspay/neurolink 13.7.0 → 13.8.1

package/dist/voice/correction/index.js

@@ -12,8 +12,8 @@
  */
 import { applyDictionary, dictionaryBlock, dictionaryVocabulary, findDictionaryCandidates, } from "./dictionary.js";
 import { DEFAULT_DECIDE_TIMEOUT_MS, decideCandidates } from "./guard.js";
-import { buildRewriteSystemPrompt, buildRewriteUserPrompt, rewriteLines, rewriteTranscript, } from "./rewrite.js";
-export { applyDictionary, buildRewriteSystemPrompt, buildRewriteUserPrompt, decideCandidates, dictionaryBlock, dictionaryVocabulary, findDictionaryCandidates, rewriteLines, rewriteTranscript, };
+import { buildRewriteSystemPrompt, buildRewriteUserPrompt, reconcilePairs, rewriteLines, rewriteTranscript, rewriteWanted, } from "./rewrite.js";
+export { applyDictionary, buildRewriteSystemPrompt, buildRewriteUserPrompt, decideCandidates, dictionaryBlock, dictionaryVocabulary, findDictionaryCandidates, rewriteLines, rewriteTranscript, rewriteWanted, };
 /** Correction is on when asked for, or by default when a dictionary or a rewrite is configured. */
 export function isCorrectionEnabled(dictionary, options) {
     if (options?.enabled !== undefined) {
@@ -102,10 +102,25 @@ export async function correctTranscript(input, deps) {
     if (guarded.decideMs !== undefined) {
         timings.decideMs = guarded.decideMs;
     }
-    if (options?.rewrite !== false) {
+    const want = rewriteWanted(text, options, {
+        hasSecondOpinion: !!secondary,
+        termsApplied: guarded.decisions.filter((d) => d.choice === "term").length,
+        language: input.language,
+    });
+    if (!want.wanted) {
+        if (options?.rewrite !== false) {
+            steps.push(`rewrite skipped · ${want.reason}`);
+        }
+    }
+    else {
+        const aligned = reconcilePairs(text, secondary);
+        if (aligned) {
+            steps.push(`aligned two readings · ${Math.round(aligned.englishShare * 100)}% of words heard alike`);
+        }
         const outcome = await rewriteTranscript({
             primary: text,
             secondOpinion: secondary,
+            ...(aligned ? { pairs: aligned.pairs } : {}),
             dictionary,
             options,
             labels: secondLed
@@ -117,6 +132,8 @@ export async function correctTranscript(input, deps) {
             literal: guarded.decisions
                 .filter((d) => d.choice === "literal")
                 .map((d) => d.heard),
+            language: input.language,
+            previous: input.previous,
             onPartial: input.onPartial,
         }, deps.rewrite);
         timings.rewriteMs = outcome.ms;
@@ -137,6 +154,9 @@ export async function correctTranscript(input, deps) {
             case "dropped":
                 steps.push(`rewrite dropped ${Math.round((outcome.dropRatio ?? 0) * 100)}% of words · kept text`);
                 break;
+            case "added":
+                steps.push("rewrite added words that were not said · kept text");
+                break;
         }
     }
     timings.correctionMs = Date.now() - started;
@@ -147,6 +167,113 @@ export async function correctTranscript(input, deps) {
         timings,
     };
 }
+/**
+ * Split a transcript into sentences on terminal punctuation (., !, ?, the
+ * danda, an ellipsis), keeping the marks. Text without any mark is one
+ * sentence; a split that would leave a fragment under three words glues it
+ * to its neighbour so a stray "No." never travels alone.
+ */
+export function splitSentences(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const parts = trimmed
+        .split(/(?<=[.!?\u0964\u0965\u2026]["'\u201D\u2019)\]]*)\s+/u)
+        .map((p) => p.trim())
+        .filter(Boolean);
+    const out = [];
+    for (const part of parts) {
+        const words = part.split(/\s+/u).length;
+        if (out.length > 0 && words < 3) {
+            out[out.length - 1] = `${out[out.length - 1]} ${part}`;
+        }
+        else {
+            out.push(part);
+        }
+    }
+    return out;
+}
+/**
+ * Correct one final sentence by sentence: each sentence gets its own
+ * dictionary pass, its own "does this need the rewrite" decision (an
+ * English sentence that is already clean costs nothing; a Devanagari one
+ * is romanised) and sentences run three at a time. The joined text has the
+ * same sentences in the same order; a sentence whose correction fails keeps
+ * its words. `onPartial` receives the whole utterance with the sentences
+ * corrected so far, so a caption can update progressively.
+ *
+ * Falls back to a single whole-text pass when there is one sentence or a
+ * second opinion (whole-utterance by nature) to reconcile.
+ */
+export async function correctTranscriptSentences(input, deps) {
+    const sentences = splitSentences(input.text ?? "");
+    if (sentences.length < 2 || input.secondOpinion?.trim()) {
+        const one = await correctTranscript(input, deps);
+        return { ...one, sentences: Math.max(1, sentences.length) };
+    }
+    const started = Date.now();
+    const out = [...sentences];
+    const results = sentences.map(() => undefined);
+    let next = 0;
+    const emit = () => {
+        input.onPartial?.(out.join(" "));
+    };
+    const worker = async () => {
+        while (next < sentences.length) {
+            const index = next++;
+            try {
+                const res = await correctTranscript({
+                    ...input,
+                    text: sentences[index],
+                    secondOpinion: undefined,
+                    onPartial: undefined,
+                }, deps);
+                results[index] = res;
+                out[index] = res.text.trim() ? res.text : sentences[index];
+            }
+            catch {
+                out[index] = sentences[index];
+            }
+            emit();
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(3, sentences.length) }, () => worker()));
+    const decisions = results.flatMap((r) => r?.decisions ?? []);
+    const rewrites = results.filter((r) => r?.steps.some((st) => st.startsWith("rewrite ") && st.endsWith(" ms"))).length;
+    const skipped = results.filter((r) => r?.steps.some((st) => st.startsWith("rewrite skipped"))).length;
+    const kept = results.filter((r) => r?.steps.some((st) => st.includes("kept text"))).length;
+    const steps = [
+        `per sentence (${sentences.length})`,
+        ...(decisions.length
+            ? [
+                `dictionary ${decisions.filter((d) => d.choice === "term").length}/${decisions.length}`,
+            ]
+            : []),
+        ...(rewrites ? [`rewrite ${rewrites} sentence(s)`] : []),
+        ...(skipped ? [`rewrite skipped ${skipped} sentence(s)`] : []),
+        ...(kept ? [`${kept} sentence(s) kept their text`] : []),
+    ];
+    const sum = (key) => {
+        const values = results
+            .map((r) => r?.timings[key])
+            .filter((v) => typeof v === "number");
+        return values.length ? values.reduce((a, b) => a + b, 0) : undefined;
+    };
+    const decideMs = sum("decideMs");
+    const rewriteMs = sum("rewriteMs");
+    return {
+        text: out.join(" "),
+        decisions,
+        steps,
+        timings: {
+            ...(decideMs !== undefined ? { decideMs } : {}),
+            ...(rewriteMs !== undefined ? { rewriteMs } : {}),
+            correctionMs: Date.now() - started,
+        },
+        sentences: sentences.length,
+    };
+}
 /**
  * Correct a long transcript line by line (file transcription, diarized
  * turns). With the rewrite on, lines go to the model in numbered batches of
@@ -156,7 +283,7 @@ export async function correctTranscript(input, deps) {
  * four at a time) and the dictionary is applied per line. The result always
  * has exactly as many lines as the input.
  */
-export async function correctTranscriptLines(lines, dictionary, options, deps) {
+export async function correctTranscriptLines(lines, dictionary, options, deps, language) {
     const started = Date.now();
     if (!isCorrectionEnabled(dictionary, options) || lines.length === 0) {
         return { lines: [...lines], decisions: [], steps: [], timings: {} };
@@ -165,6 +292,7 @@ export async function correctTranscriptLines(lines, dictionary, options, deps) {
         const outcome = await rewriteLines(lines, deps.rewrite, {
             dictionary,
             correction: options,
+            language,
         });
         const steps = [
             `rewrite ${outcome.batchesOk}/${outcome.batches} batches (${outcome.ms} ms)`,

package/dist/voice/correction/rewrite.d.ts

@@ -17,9 +17,39 @@
  *
  * @module voice/correction/rewrite
  */
-import type { STTCorrectionDeps, STTCorrectionOptions, STTDictionaryEntry, STTRewriteLinesOutcome, STTRewriteOutcome } from "../../types/index.js";
-/** Default per-call rewrite timeout; on expiry the input text is kept. */
-export declare const DEFAULT_REWRITE_TIMEOUT_MS = 12000;
+import type { STTCorrectionDeps, STTCorrectionOptions, STTDictionaryEntry, STTRewriteLinesOutcome, STTRewriteOutcome, STTWordPair } from "../../types/index.js";
+/**
+ * The rewrite's provider/model/timeout settings, whatever shape `rewrite`
+ * took: `false` and `"auto"` carry none, an object carries its own.
+ */
+export declare function rewriteSettings(rewrite: STTCorrectionOptions["rewrite"]): {
+    provider?: string;
+    model?: string;
+    timeoutMs?: number;
+} | undefined;
+/**
+ * Whether the rewrite is wanted for a text, under the "auto" rule: it runs
+ * when there is something for it to do and is skipped otherwise, which is
+ * what makes an already clean English sentence cost nothing. `"always"`
+ * (object form with `mode: "always"`) runs it every time; `false` never.
+ */
+export declare function rewriteWanted(text: string, options: STTCorrectionOptions | undefined, signals?: {
+    /** The rewrite has a second transcript to reconcile. */
+    hasSecondOpinion?: boolean;
+    /** The dictionary changed something (a term was applied). */
+    termsApplied?: number;
+    /** Detected language of the speech. */
+    language?: string;
+}): {
+    wanted: boolean;
+    reason: string;
+};
+/**
+ * The script setting in effect. Unset, Indian languages (and speech whose
+ * language is unknown, as before) are written in Latin letters; any other
+ * known language keeps its own script.
+ */
+export declare function resolveTransliterate(options: Pick<STTCorrectionOptions, "transliterate"> | undefined, language: string | undefined): "latin" | "native";
 /** Default per-batch timeout for `rewriteLines`: a batch carries up to 25 lines. */
 export declare const DEFAULT_REWRITE_LINES_TIMEOUT_MS = 60000;
 /** Default share of words a rewrite may drop before it is discarded. */
@@ -44,6 +74,9 @@ export declare function buildRewriteSystemPrompt(options?: {
     punctuate?: boolean;
     dictionary?: readonly STTDictionaryEntry[];
     lines?: boolean;
+    cleanup?: "verbatim" | "clean";
+    /** Detected language of the speech; a known language outside India gets the general prompt. */
+    language?: string;
 }): string;
 /**
  * User message for the rewrite. With a second opinion the two transcripts are
@@ -56,7 +89,27 @@ export declare function buildRewriteUserPrompt(primary: string, secondOpinion?:
         secondary?: string;
     };
     literal?: readonly string[];
+    /** Earlier corrected utterances, oldest first: context the model must not echo. */
+    previous?: readonly string[];
+    /** The two transcripts aligned word by word (Indic reading against English reading). */
+    pairs?: readonly STTWordPair[];
 }): string;
+/**
+ * The word alignment of two transcripts as a prompt block: same-sounding
+ * words side by side ("मीटिंग ≈ meeting"), and runs where only one engine
+ * heard something, so the rewrite decides word by word which reading holds
+ * the speaker's word in which language.
+ */
+export declare function alignmentBlock(pairs: readonly STTWordPair[] | undefined): string | undefined;
+/**
+ * Word pairs for a reconciliation: the Indic-script transcript aligned
+ * against the Latin-script one, whichever order they came in; `undefined`
+ * when both are in the same script (nothing to line up across scripts).
+ */
+export declare function reconcilePairs(primary: string, secondOpinion: string | undefined): {
+    pairs: STTWordPair[];
+    englishShare: number;
+} | undefined;
 /**
  * The model's answer: the last `lineCount` non-empty lines, since a preamble,
  * if any, comes first. An echoed "Transcript:" label is stripped.
@@ -77,6 +130,12 @@ export declare function rewriteTranscript(input: {
         secondary?: string;
     };
     literal?: readonly string[];
+    /** Detected language of the speech. */
+    language?: string;
+    /** Earlier corrected utterances, oldest first. */
+    previous?: readonly string[];
+    /** The two transcripts aligned word by word (see `reconcilePairs`). */
+    pairs?: readonly STTWordPair[];
     onPartial?: (text: string) => void;
 }, rewrite: STTCorrectionDeps["rewrite"]): Promise<STTRewriteOutcome>;
 /**
@@ -89,4 +148,6 @@ export declare function rewriteTranscript(input: {
 export declare function rewriteLines(lines: readonly string[], rewrite: STTCorrectionDeps["rewrite"], options?: {
     dictionary?: readonly STTDictionaryEntry[];
     correction?: STTCorrectionOptions;
+    /** Detected language of the recording. */
+    language?: string;
 }): Promise<STTRewriteLinesOutcome>;