@juspay/neurolink 12.40.0 → 12.40.2

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/dist/utils/schemaConversion.js

@@ -1,8 +1,70 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { jsonSchemaToZod } from "json-schema-to-zod";
+import { createRequire } from "node:module";
 import * as zodModule from "zod";
 import { z } from "zod";
 import { logger } from "./logger.js";
+/**
+ * zod-to-json-schema and json-schema-to-zod are loaded synchronously via
+ * require() on first actual use, not via a top-level import, so merely
+ * importing this module no longer pulls in either package for the many
+ * callers who never convert a schema. Both ship a CJS `require` export
+ * condition (checked against their package.json), so require() works on
+ * any Node >=22.0.0 — no experimental flag, unlike require(esm) of a local
+ * ES module (which only works unflagged from Node >=22.12). Zod itself
+ * stays a normal static import: its runtime schemas (`z`, `zodModule`) are
+ * public exports used well beyond schema conversion. Follows the pattern in
+ * src/lib/proxy/otelLogSink.ts — construction stays one synchronous call,
+ * exactly as before; only the *import* is deferred.
+ *
+ * A require() made through createRequire() is invisible to bundlers, so a
+ * consumer that bundles the SDK without these packages next to the output can
+ * no longer resolve them, and listing them as external changes nothing for the
+ * same reason: the bundler never sees the call. That must not pass for a
+ * schema that simply had no properties: the failure is reported once per
+ * package at error level (the only level shown without NEUROLINK_DEBUG),
+ * remembered so later calls neither retry the lookup nor repeat the report,
+ * and the caller degrades exactly as it does when a conversion throws. The
+ * browser artifact is the one bundle we build ourselves;
+ * scripts/build-browser.mjs bundles both packages into it and serves them from
+ * its `module` stub.
+ */
+const require = createRequire(import.meta.url);
+function lazyPackageFunction(packageName, exportName) {
+    let attempted = false;
+    let resolved;
+    return () => {
+        if (attempted) {
+            return resolved;
+        }
+        attempted = true;
+        let failure;
+        try {
+            const loadedModule = require(packageName);
+            const candidate = typeof loadedModule === "object" && loadedModule !== null
+                ? Reflect.get(loadedModule, exportName)
+                : undefined;
+            if (typeof candidate === "function") {
+                resolved = candidate;
+            }
+            else {
+                failure = `it resolved without a "${exportName}" function`;
+            }
+        }
+        catch (error) {
+            failure = (error instanceof Error ? error.message : String(error)).split("\n")[0];
+        }
+        if (failure !== undefined) {
+            logger.error(`[SCHEMA-CONVERSION] Cannot load "${packageName}" (${failure}). Any schema ` +
+                `that needs it is replaced with an empty object schema, so the model ` +
+                `sees no parameters for it. The SDK loads this package at run time ` +
+                `and a bundler cannot see that load, so bundling the SDK does not ` +
+                `provide it: install "${packageName}" where @juspay/neurolink can ` +
+                `resolve it, next to your bundle if you bundle the SDK.`);
+        }
+        return resolved;
+    };
+}
+const loadZodToJsonSchema = lazyPackageFunction("zod-to-json-schema", "zodToJsonSchema");
+const loadJsonSchemaToZod = lazyPackageFunction("json-schema-to-zod", "jsonSchemaToZod");
 // Zod 4 ships a built-in `z.toJSONSchema(...)`. Zod 3 does not — it returned
 // nothing of the sort and we relied entirely on `zod-to-json-schema`. The
 // `zod-to-json-schema` package only understands Zod 3's internal `_def`
@@ -360,12 +422,16 @@ target = "jsonSchema7") {
         }
     }
     // Zod 3 fallback path
+    const convertWithZodToJsonSchema = loadZodToJsonSchema();
+    if (!convertWithZodToJsonSchema) {
+        return { type: "object", properties: {} };
+    }
     try {
         // Zod 4→3 boundary: zodToJsonSchema types reference Zod 3's ZodSchema via zod/v3.
         // Runtime compatible — cast through unknown at this third-party boundary only.
         // eslint-disable-next-line no-restricted-syntax -- genuine third-party type-system boundary: zod-to-json-schema's input type is zod/v3's ZodType, structurally incompatible with the Zod 4 schema held here (no overlap, single assertion cannot compile); runtime-compatible fallback contract documented above.
         const zodV3Schema = zodSchema;
-        const jsonSchema = zodToJsonSchema(zodV3Schema, {
+        const jsonSchema = convertWithZodToJsonSchema(zodV3Schema, {
             name: "ToolParameters",
             target,
             errorMessages: true,
@@ -612,7 +678,11 @@ export function convertJsonSchemaToZod(jsonSchema) {
                 : [],
         });
         // Use official library to convert JSON Schema to Zod code
-        const zodCodeResult = jsonSchemaToZod(jsonSchema, {
+        const convertToZodCode = loadJsonSchemaToZod();
+        if (!convertToZodCode) {
+            return z.object({}).passthrough();
+        }
+        const zodCodeResult = convertToZodCode(jsonSchema, {
             module: "esm",
             name: "schema",
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.40.0",
+  "version": "12.40.2",
   "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",