@juspay/neurolink 13.6.5 → 13.8.0

package/dist/server/routes/transcribeRoutes.js

@@ -18,7 +18,10 @@ import { tracers } from "../../telemetry/tracers.js";
 import { logger } from "../../utils/logger.js";
 import { MAX_AUDIO_BYTES } from "../../utils/sizeGuard.js";
 import { RawBodyTooLargeError } from "../utils/rawBody.js";
-import { createErrorResponse, TranscribeConfigSchema, TranscribeRequestSchema, validateRequest, } from "../utils/validation.js";
+import { getSTTProviderDescriptor, listConfiguredSTTProviders, resolveDefaultSTTProvider, resolveSTTEndpoints, } from "../../factories/sttDescriptors.js";
+import { STTProcessor } from "../../utils/sttProcessor.js";
+import { STTEvalStore } from "../../voice/eval/sttEvalStore.js";
+import { createErrorResponse, STTEvalBatchSchema, TranscribeConfigSchema, TranscribeRequestSchema, validateRequest, } from "../utils/validation.js";
 const FORMAT_BY_MIME = {
     "audio/mpeg": "mp3",
     "audio/mp3": "mp3",
@@ -198,6 +201,9 @@ function toTranscribeOptions(config, audio, format, maxAudioBytes) {
         ...(config.dictionary ? { dictionary: config.dictionary } : {}),
         ...(config.correction ? { correction: config.correction } : {}),
         ...(config.fallback ? { fallback: config.fallback } : {}),
+        ...(config.routing ? { routing: config.routing } : {}),
+        ...(config.chunking ? { chunking: config.chunking } : {}),
+        ...(config.output ? { output: config.output } : {}),
         ...(config.diarization !== undefined
             ? { diarization: config.diarization }
             : {}),
@@ -313,6 +319,7 @@ function toVerboseJson(result) {
             : {}),
         steps: result.steps,
         timings: result.timings,
+        ...(result.outputs ? { outputs: result.outputs } : {}),
     };
 }
 async function handleOpenAITranscription(ctx, options, limit, route) {
@@ -368,6 +375,11 @@ async function handleOpenAITranscription(ctx, options, limit, route) {
     const fallback = textField(form, "fallback");
     const language = textField(form, "language");
     const prompt = textField(form, "prompt");
+    const chunking = textField(form, "chunking");
+    const outputLanguages = (textField(form, "output_languages") ?? "")
+        .split(",")
+        .map((tag) => tag.trim())
+        .filter(Boolean);
     const candidate = {
         provider: textField(form, "provider") ?? engine.provider,
         model: engine.model,
@@ -379,12 +391,20 @@ async function handleOpenAITranscription(ctx, options, limit, route) {
                 correction: {
                     enabled: true,
                     ...(secondOpinion
-                        ? { secondOpinion: { provider: secondOpinion } }
+                        ? {
+                            secondOpinion: secondOpinion === "auto"
+                                ? "auto"
+                                : { provider: secondOpinion },
+                        }
                         : {}),
                 },
             }
             : {}),
         ...(fallback ? { fallback: { provider: fallback } } : {}),
+        ...(chunking ? { chunking } : {}),
+        ...(outputLanguages.length
+            ? { output: { languages: outputLanguages } }
+            : {}),
         ...(isTruthyField(form.get("diarize")) ? { diarization: true } : {}),
         ...(granularities.includes("word") ? { wordTimestamps: true } : {}),
     };
@@ -450,6 +470,21 @@ const TRANSCRIBE_REQUEST_JSON_SCHEMA = {
         },
         correction: { type: "object" },
         fallback: { type: "object" },
+        routing: { type: "object" },
+        chunking: { type: "string", enum: ["engine", "utterances"] },
+        output: {
+            type: "object",
+            description: "Renderings in other languages: languages is a list of BCP-47 tags (es, fr-CA, hi-Latn) or source",
+            properties: {
+                languages: { type: "array", items: { type: "string" } },
+                provider: { type: "string" },
+                model: { type: "string" },
+                timeoutMs: { type: "number" },
+                contextUtterances: { type: "number" },
+                glossary: { type: "boolean" },
+            },
+            required: ["languages"],
+        },
         diarization: { type: "boolean" },
         wordTimestamps: { type: "boolean" },
         timeoutMs: { type: "number" },
@@ -463,10 +498,50 @@ const TRANSCRIBE_REQUEST_JSON_SCHEMA = {
  *   `maxAudioBytes` (default 50 MB) and `openaiBasePath` (default `""`, so the
  *   OpenAI-compatible route is `/v1/audio/transcriptions`).
  */
+/** `GET /agent/transcribe/providers`: engines, default and correction models, from the process environment. */
+function describeTranscription(ctx) {
+    const endpoints = resolveSTTEndpoints();
+    const configured = new Set(listConfiguredSTTProviders());
+    const names = [
+        ...configured,
+        ...STTProcessor.listProviders().filter((n) => !configured.has(n)),
+    ];
+    const providers = names.map((name) => {
+        const endpoint = endpoints[name];
+        if (endpoint) {
+            return {
+                name,
+                kind: "endpoint",
+                ...(endpoint.model ? { model: endpoint.model } : {}),
+                ...(endpoint.lidModel ? { languageProbe: true } : {}),
+                ...(endpoint.priorLanguageForm ? { languagePrior: true } : {}),
+            };
+        }
+        return {
+            name,
+            kind: getSTTProviderDescriptor(name) ? "builtin" : "registered",
+        };
+    });
+    const decision = ctx.neurolink.decisionLimits();
+    const rewriteProvider = process.env.NEUROLINK_STT_REWRITE_PROVIDER?.trim() || null;
+    const rewriteModel = process.env.NEUROLINK_STT_REWRITE_MODEL?.trim() || null;
+    return {
+        default: resolveDefaultSTTProvider(),
+        providers,
+        correction: {
+            decision: decision
+                ? { provider: decision.provider, model: decision.model }
+                : null,
+            rewrite: { provider: rewriteProvider, model: rewriteModel },
+        },
+    };
+}
 export function createTranscribeRoutes(basePath = "/api", options = {}) {
     const limit = options.maxAudioBytes ?? MAX_AUDIO_BYTES;
     const nativePath = `${basePath}/agent/transcribe`;
     const openaiPath = `${options.openaiBasePath ?? ""}/v1/audio/transcriptions`;
+    const evalPath = `${options.openaiBasePath ?? ""}/v1/evals/stt`;
+    const evalStore = options.evals === false ? undefined : new STTEvalStore(options.evals);
     return {
         // Empty prefix: the two routes live under different roots, and every
         // route path already starts with "", so the adapters add nothing.
@@ -494,13 +569,65 @@ export function createTranscribeRoutes(basePath = "/api", options = {}) {
                 requestSchema: TRANSCRIBE_REQUEST_JSON_SCHEMA,
                 tags: ["agent", "transcribe"],
             },
+            {
+                method: "GET",
+                path: `${nativePath}/providers`,
+                handler: async (ctx) => describeTranscription(ctx),
+                description: "The STT providers this server is configured with, the default one, and the decision and rewrite models behind correction",
+                tags: ["agent", "transcribe"],
+            },
             {
                 method: "POST",
                 path: openaiPath,
                 handler: (ctx) => handleOpenAITranscription(ctx, options, limit, openaiPath),
-                description: "OpenAI-compatible transcription (multipart/form-data: file, model, language, prompt, response_format; extensions: provider, diarize, dictionary, correct, fallback, second_opinion)",
+                description: "OpenAI-compatible transcription (multipart/form-data: file, model, language, prompt, response_format; extensions: provider, diarize, dictionary, correct, fallback, second_opinion, chunking, output_languages)",
                 tags: ["transcribe", "openai-compatible"],
             },
+            ...(evalStore ? createEvalRoutes(evalPath, evalStore) : []),
         ],
     };
 }
+/**
+ * The STT evaluation collector: a sender posts what two STTs wrote for the
+ * same call (`primary` shown, `shadow` run alongside), and reads back how far
+ * apart they were per speaker.
+ */
+function createEvalRoutes(evalPath, store) {
+    return [
+        {
+            method: "POST",
+            path: evalPath,
+            handler: async (ctx) => {
+                const validation = validateRequest(STTEvalBatchSchema, ctx.body, ctx.requestId);
+                if (!validation.success) {
+                    return validation.error;
+                }
+                const batch = validation.data;
+                return store.accept(batch);
+            },
+            description: "Accept a batch of one call's segments from two STTs (primary shown, shadow for evaluation); a resent segment id replaces the earlier one",
+            tags: ["transcribe", "evaluation"],
+        },
+        {
+            method: "GET",
+            path: evalPath,
+            handler: async () => ({ calls: await store.list() }),
+            description: "Calls collected for STT evaluation, most recent first",
+            tags: ["transcribe", "evaluation"],
+        },
+        {
+            method: "GET",
+            path: `${evalPath}/:callId`,
+            handler: async (ctx) => {
+                // Adapters already decode path params; decoding again would turn a
+                // literal "%" in an id into something else, or throw on "%E0%A4%A".
+                const callId = ctx.params.callId ?? "";
+                const report = await store.report(callId, ctx.query.segments === "true");
+                return (report ??
+                    createErrorResponse("NOT_FOUND", `No STT evaluation for call ${callId}`, undefined, ctx.requestId, 404));
+            },
+            description: "Per-speaker comparison of the two STTs for one call (?segments=true adds the segments)",
+            tags: ["transcribe", "evaluation"],
+        },
+    ];
+}