@juspay/neurolink 12.40.0 → 12.40.1

package/dist/processors/media/VideoProcessor.d.ts

@@ -129,6 +129,23 @@ export declare class VideoProcessor extends BaseFileProcessor<ProcessedVideo> {
      * Falls back to ffprobe if mediabunny fails or doesn't support the format.
      */
     private probeVideoWithMediabunny;
+    /**
+     * Read metadata from the ffmpeg binary itself, for hosts that have ffmpeg
+     * but no ffprobe (mediabunny cannot read AVI, FLV or WMV, and ffprobe was the
+     * only other reader).
+     *
+     * ffmpeg prints the input's streams to stderr before it opens the output, so
+     * a zero-length run to the null muxer is enough to read them.
+     */
+    private probeVideoWithFfmpeg;
+    /**
+     * Parse the input section of an ffmpeg banner: `Duration:`, `bitrate:` and
+     * one `Stream #…: Video|Audio|Subtitle:` line per stream. Returns undefined
+     * when there is no positive duration, since frames cannot be timed without it.
+     */
+    private parseFfmpegInputReport;
+    /** ffmpeg names a layout ("mono", "stereo", "5.1(side)") or counts ("6 channels"). */
+    private channelCountFromLayout;
     /**
      * Build a structured metadata object from ffprobe data.
      *

package/dist/processors/media/VideoProcessor.js

@@ -445,6 +445,20 @@ export class VideoProcessor extends BaseFileProcessor {
                         metadata = this.buildMetadata(probeResult.data, buffer.length);
                     }
                 }
+                if (!metadata) {
+                    // ffmpeg-static ships ffmpeg only, so a host that relies on it has
+                    // no ffprobe. Without a duration no frame timestamps can be chosen.
+                    const ffmpegProbe = await this.probeVideoWithFfmpeg(tempVideoPath);
+                    if (ffmpegProbe.success && ffmpegProbe.data) {
+                        metadata = { ...ffmpegProbe.data, fileSize: buffer.length };
+                    }
+                    else {
+                        // Nothing downstream reports this: an empty duration selects no
+                        // frames, the request still succeeds, and the model is simply
+                        // told nothing about the video.
+                        logger.warn(`[NEUROLINK] No metadata could be read for ${filename} (mediabunny, ffprobe and ffmpeg all failed), so no keyframes will be extracted: ${ffmpegProbe.error}`);
+                    }
+                }
                 if (!metadata) {
                     metadata = {
                         duration: 0,
@@ -636,6 +650,111 @@ export class VideoProcessor extends BaseFileProcessor {
             input?.dispose();
         }
     }
+    /**
+     * Read metadata from the ffmpeg binary itself, for hosts that have ffmpeg
+     * but no ffprobe (mediabunny cannot read AVI, FLV or WMV, and ffprobe was the
+     * only other reader).
+     *
+     * ffmpeg prints the input's streams to stderr before it opens the output, so
+     * a zero-length run to the null muxer is enough to read them.
+     */
+    async probeVideoWithFfmpeg(filePath) {
+        let report;
+        try {
+            const { stderr } = await runFfmpeg(["-hide_banner", "-i", filePath, "-t", "0", "-f", "null", "-"], { timeoutMs: VIDEO_CONFIG.FFPROBE_TIMEOUT_MS });
+            report = stderr;
+        }
+        catch (error) {
+            // A non-zero exit still carries the stream report when the failure came
+            // after the input was opened.
+            const stderr = error.stderr;
+            if (typeof stderr !== "string") {
+                return {
+                    success: false,
+                    error: `ffmpeg probe failed: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+            report = stderr;
+        }
+        const data = this.parseFfmpegInputReport(report);
+        return data
+            ? { success: true, data }
+            : { success: false, error: "ffmpeg reported no duration" };
+    }
+    /**
+     * Parse the input section of an ffmpeg banner: `Duration:`, `bitrate:` and
+     * one `Stream #…: Video|Audio|Subtitle:` line per stream. Returns undefined
+     * when there is no positive duration, since frames cannot be timed without it.
+     */
+    parseFfmpegInputReport(report) {
+        const lines = report.split(/\r?\n/);
+        const outputStart = lines.findIndex((line) => line.startsWith("Output #"));
+        const inputLines = outputStart === -1 ? lines : lines.slice(0, outputStart);
+        const inputText = inputLines.join("\n");
+        const durationMatch = /Duration:\s*(\d+):(\d{2}):(\d{2}(?:\.\d+)?)/.exec(inputText);
+        if (!durationMatch) {
+            return undefined;
+        }
+        const duration = Number(durationMatch[1]) * 3600 +
+            Number(durationMatch[2]) * 60 +
+            Number(durationMatch[3]);
+        if (!(duration > 0)) {
+            return undefined;
+        }
+        const streams = inputLines.flatMap((line) => {
+            const match = /^\s*Stream #\d+:\d+(?:\[[^\]]*\])?(?:\([^)]*\))?:\s*(Video|Audio|Subtitle):\s*(.*)$/.exec(line);
+            return match ? [{ kind: match[1], details: match[2] }] : [];
+        });
+        const video = streams.find((stream) => stream.kind === "Video" && !stream.details.includes("attached pic"));
+        const audio = streams.find((stream) => stream.kind === "Audio");
+        const size = video
+            ? /(?:^|[\s,])(\d{2,5})x(\d{2,5})(?=[\s,[]|$)/.exec(video.details)
+            : null;
+        const frameRate = video
+            ? /,\s*(\d+(?:\.\d+)?)\s*(?:fps|tbr)/.exec(video.details)
+            : null;
+        const bitrate = /bitrate:\s*(\d+)\s*kb\/s/.exec(inputText);
+        const sampleRate = audio ? /(\d+)\s*Hz/.exec(audio.details) : null;
+        const layout = audio ? /Hz,\s*([^,]+)/.exec(audio.details) : null;
+        return {
+            duration,
+            durationFormatted: this.formatDuration(duration),
+            width: size ? Number(size[1]) : 0,
+            height: size ? Number(size[2]) : 0,
+            codec: video
+                ? (/^([^\s,(]+)/.exec(video.details)?.[1] ?? "unknown")
+                : "unknown",
+            fps: frameRate ? Number(frameRate[1]) : 0,
+            bitrate: bitrate ? Number(bitrate[1]) * 1000 : 0,
+            audioCodec: audio ? /^([^\s,(]+)/.exec(audio.details)?.[1] : undefined,
+            audioChannels: layout
+                ? this.channelCountFromLayout(layout[1])
+                : undefined,
+            audioSampleRate: sampleRate ? Number(sampleRate[1]) : undefined,
+            subtitleTracks: streams.filter((stream) => stream.kind === "Subtitle")
+                .length,
+            fileSize: 0,
+        };
+    }
+    /** ffmpeg names a layout ("mono", "stereo", "5.1(side)") or counts ("6 channels"). */
+    channelCountFromLayout(layout) {
+        const named = new Map([
+            ["mono", 1],
+            ["stereo", 2],
+            ["quad", 4],
+        ]);
+        const trimmed = layout.trim();
+        const namedCount = named.get(trimmed);
+        if (namedCount !== undefined) {
+            return namedCount;
+        }
+        const counted = /^(\d+) channels?/.exec(trimmed);
+        if (counted) {
+            return Number(counted[1]);
+        }
+        const dotted = /^(\d+)\.(\d)/.exec(trimmed);
+        return dotted ? Number(dotted[1]) + Number(dotted[2]) : undefined;
+    }
     /**
      * Build a structured metadata object from ffprobe data.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.40.0",
+  "version": "12.40.1",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -251,9 +251,10 @@
     "check:all": "pnpm run lint && pnpm run format --check && pnpm run validate && pnpm run validate:commit",
     "test:file-formats": "pnpm exec tsx test/continuous-test-suite-file-formats.ts",
     "test:audio-transcription": "pnpm exec tsx test/continuous-test-suite-audio-transcription.ts",
-    "test:multimodal": "pnpm run test:file-formats && pnpm run test:multimodal:sdk && pnpm run test:video-native && pnpm run test:video-frames",
+    "test:multimodal": "pnpm run test:file-formats && pnpm run test:multimodal:sdk && pnpm run test:video-native && pnpm run test:video-frames && pnpm run test:video-no-ffprobe",
     "test:multimodal:sdk": "pnpm exec tsx test/continuous-test-suite-multimodal-sdk.ts",
     "test:video-frames": "pnpm exec tsx test/continuous-test-suite-video-frames.ts",
+    "test:video-no-ffprobe": "pnpm exec tsx test/continuous-test-suite-video-no-ffprobe.ts",
     "test:video-native": "pnpm exec tsx test/continuous-test-suite-video-native.ts",
     "test:mcp-result-cache": "pnpm exec tsx test/continuous-test-suite-mcp-result-cache.ts",
     "test:mcp-breaker-resolved-errors": "pnpm exec tsx test/continuous-test-suite-mcp-breaker-resolved-errors.ts",