@juspay/neurolink 9.36.1 → 9.38.0

package/dist/processors/media/VideoProcessor.js

@@ -10,8 +10,9 @@
  * The extracted content is formatted as text + images that can be sent to any
  * AI provider for analysis.
  *
- * Uses fluent-ffmpeg for video processing and sharp for frame resizing.
- * Requires ffmpeg/ffprobe to be available (via ffmpeg-static or system PATH).
+ * Uses mediabunny (pure TypeScript) for metadata extraction, with fluent-ffmpeg
+ * as a fallback for unsupported formats. Requires ffmpeg for keyframe/subtitle
+ * extraction (via ffmpeg-static or system PATH).
  *
  * Key features:
  * - Adaptive keyframe extraction intervals based on video duration
@@ -42,10 +43,10 @@
  * }
  * ```
  */
-/// <reference path="./ffprobe-static.d.ts" />
 import { randomUUID } from "crypto";
 import ffmpegCommand from "fluent-ffmpeg";
 import { createWriteStream, existsSync, promises as fs } from "fs";
+import { Input, FilePathSource, ALL_FORMATS } from "mediabunny";
 import { tmpdir } from "os";
 import { join } from "path";
 import { Readable } from "stream";
@@ -64,8 +65,12 @@ import { logger } from "../../utils/logger.js";
  */
 let ffmpegPathInitialized = false;
 /**
- * Initialize ffmpeg and ffprobe binary paths.
- * Tries ffmpeg-static/ffprobe-static first, falls back to system binaries in PATH.
+ * Initialize ffmpeg binary paths.
+ * Tries ffmpeg-static first, falls back to system binary in PATH.
+ *
+ * Note: ffprobe-static has been removed. Metadata probing now uses mediabunny
+ * (pure TypeScript) as the primary method, with ffprobe as a fallback only when
+ * mediabunny cannot handle the format (e.g., AVI, FLV).
  *
  * This is called lazily on the first processFile() invocation so that the module
  * can be imported without side effects.
@@ -91,27 +96,6 @@ async function initFfmpegPaths() {
     catch {
         // Use system ffmpeg (already in PATH)
     }
-    // Try ffprobe-static first, fall back to system ffprobe
-    try {
-        const ffprobeStatic = (await import("ffprobe-static"));
-        // Direct path property (CommonJS default)
-        if (typeof ffprobeStatic["path"] === "string" &&
-            existsSync(ffprobeStatic["path"])) {
-            ffmpegCommand.setFfprobePath(ffprobeStatic["path"]);
-        }
-        else if (ffprobeStatic["default"] &&
-            typeof ffprobeStatic["default"] === "object" &&
-            typeof ffprobeStatic["default"]["path"] ===
-                "string") {
-            const probePath = ffprobeStatic["default"]["path"];
-            if (existsSync(probePath)) {
-                ffmpegCommand.setFfprobePath(probePath);
-            }
-        }
-    }
-    catch {
-        // Use system ffprobe (already in PATH)
-    }
 }
 // =============================================================================
 // CONSTANTS
@@ -372,23 +356,33 @@ export class VideoProcessor extends BaseFileProcessor {
                 const extension = this.getExtensionFromFileInfo(fileInfo);
                 const tempVideoPath = join(tempDir, `input${extension}`);
                 await this.writeBufferToFile(buffer, tempVideoPath);
-                // Step 4: Extract metadata via ffprobe
-                const probeResult = await this.probeVideo(tempVideoPath);
-                if (!probeResult.success) {
-                    const errMsg = probeResult.error || "ffprobe failed";
-                    span.setAttribute(ATTR.FILE_SUCCESS, false);
-                    span.setAttribute(ATTR.FILE_ERROR, errMsg);
-                    logger.warn(`[NEUROLINK] Video skipped/failed: ${filename} — reason: ${errMsg}`);
-                    return {
-                        success: false,
-                        error: this.createError(FileErrorCode.PROCESSING_FAILED, {
-                            fileType: "video",
-                            reason: probeResult.error,
-                        }),
+                // Step 4: Extract metadata — try mediabunny first (pure TS, no binary),
+                // fall back to ffprobe for formats mediabunny doesn't support (AVI, FLV, WMV).
+                let metadata;
+                const mediabunnyResult = await this.probeVideoWithMediabunny(tempVideoPath);
+                if (mediabunnyResult.success && mediabunnyResult.data) {
+                    metadata = { ...mediabunnyResult.data, fileSize: buffer.length };
+                }
+                else {
+                    // Fall back to ffprobe (requires system ffprobe to be available)
+                    const probeResult = await this.probeVideo(tempVideoPath);
+                    if (probeResult.success && probeResult.data) {
+                        metadata = this.buildMetadata(probeResult.data, buffer.length);
+                    }
+                }
+                if (!metadata) {
+                    metadata = {
+                        duration: 0,
+                        durationFormatted: "unknown",
+                        width: 0,
+                        height: 0,
+                        codec: "unknown",
+                        fps: 0,
+                        bitrate: 0,
+                        subtitleTracks: 0,
+                        fileSize: buffer.length,
                     };
                 }
-                const probeData = probeResult.data;
-                const metadata = this.buildMetadata(probeData, buffer.length);
                 // Record video-specific metadata on span
                 span.setAttribute(ATTR.VIDEO_DURATION_SEC, metadata.duration);
                 span.setAttribute(ATTR.VIDEO_WIDTH, metadata.width);
@@ -494,6 +488,61 @@ export class VideoProcessor extends BaseFileProcessor {
             });
         });
     }
+    /**
+     * Probe a video file using mediabunny (pure TypeScript, no native binary).
+     * Falls back to ffprobe if mediabunny fails or doesn't support the format.
+     */
+    async probeVideoWithMediabunny(filePath) {
+        let input;
+        try {
+            input = new Input({
+                source: new FilePathSource(filePath),
+                formats: [...ALL_FORMATS],
+            });
+            const duration = await input.computeDuration();
+            const videoTrack = await input.getPrimaryVideoTrack();
+            const audioTrack = await input.getPrimaryAudioTrack();
+            const allTracks = await input.getTracks();
+            const subtitleTracks = allTracks.filter((t) => !t.isVideoTrack() && !t.isAudioTrack());
+            // Get FPS from video track packet stats (sample a small number of packets)
+            let fps = 0;
+            if (videoTrack) {
+                try {
+                    const stats = await videoTrack.computePacketStats(120);
+                    fps = Math.round(stats.averagePacketRate * 100) / 100;
+                }
+                catch {
+                    // FPS unavailable — non-fatal
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    duration: duration ?? 0,
+                    durationFormatted: this.formatDuration(duration ?? 0),
+                    width: videoTrack?.displayWidth ?? 0,
+                    height: videoTrack?.displayHeight ?? 0,
+                    codec: videoTrack?.codec ?? "unknown",
+                    fps,
+                    bitrate: 0,
+                    audioCodec: audioTrack?.codec ?? undefined,
+                    audioChannels: audioTrack?.numberOfChannels,
+                    audioSampleRate: audioTrack?.sampleRate,
+                    subtitleTracks: subtitleTracks.length,
+                    fileSize: 0,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `mediabunny failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        finally {
+            input?.dispose();
+        }
+    }
     /**
      * Build a structured metadata object from ffprobe data.
      *

package/dist/telemetry/telemetryService.d.ts

@@ -8,7 +8,7 @@ export type HealthMetrics = {
 };
 export declare class TelemetryService {
     private static instance;
-    private sdk?;
+    private tracerProvider?;
     private enabled;
     private initialized;
     private meter?;

package/dist/telemetry/telemetryService.js

@@ -1,12 +1,12 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { metrics, trace, } from "@opentelemetry/api";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { context, metrics, trace, } from "@opentelemetry/api";
+import { BasicTracerProvider, BatchSpanProcessor, } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { logger } from "../utils/logger.js";
 export class TelemetryService {
     static instance;
-    sdk;
+    tracerProvider;
     enabled = false;
     initialized = false;
     meter;
@@ -52,11 +52,16 @@ export class TelemetryService {
                 [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
                 [ATTR_SERVICE_VERSION]: process.env.OTEL_SERVICE_VERSION || "3.0.1",
             });
-            this.sdk = new NodeSDK({
+            const exporter = new OTLPTraceExporter({
+                url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT
+                    ? `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT}/v1/traces`
+                    : undefined,
+            });
+            this.tracerProvider = new BasicTracerProvider({
                 resource,
-                // Note: Metric reader configured separately
-                instrumentations: [getNodeAutoInstrumentations()],
+                spanProcessors: [new BatchSpanProcessor(exporter)],
             });
+            trace.setGlobalTracerProvider(this.tracerProvider);
             this.meter = metrics.getMeter("neurolink-ai");
             this.tracer = trace.getTracer("neurolink-ai");
             this.initializeMetrics();
@@ -101,12 +106,21 @@ export class TelemetryService {
             return;
         }
         try {
-            await this.sdk?.start();
+            // Register AsyncLocalStorage context manager for proper parent-child
+            // span relationships across async boundaries (required for startActiveSpan)
+            try {
+                const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks");
+                context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
+            }
+            catch {
+                // context-async-hooks not installed — context propagation
+                // will use the default (noop) manager
+            }
             this.initialized = true;
-            logger.debug("[Telemetry] SDK started successfully");
+            logger.debug("[Telemetry] Tracer provider started successfully");
         }
         catch (error) {
-            logger.error("[Telemetry] Failed to start SDK:", error);
+            logger.error("[Telemetry] Failed to start:", error);
             this.enabled = false;
             this.initialized = false;
         }
@@ -294,11 +308,11 @@ export class TelemetryService {
     }
     // Cleanup
     async shutdown() {
-        if (this.enabled && this.sdk) {
+        if (this.enabled && this.tracerProvider) {
             try {
-                await this.sdk.shutdown();
+                await this.tracerProvider.shutdown();
                 this.initialized = false;
-                logger.debug("[Telemetry] SDK shutdown completed");
+                logger.debug("[Telemetry] Tracer provider shutdown completed");
             }
             catch (error) {
                 logger.error("[Telemetry] Error during shutdown:", error);

package/dist/types/index.d.ts

@@ -27,13 +27,15 @@ TextGenerationOptions, TextGenerationResult, UnifiedGenerationOptions, } from ".
 export * from "./hitlTypes.js";
 export * from "./middlewareTypes.js";
 export * from "./modelTypes.js";
+export * from "./scorerTypes.js";
 export * from "./sdkTypes.js";
 export * from "./serviceTypes.js";
 export type { EnhancedStreamProvider, ProgressCallback, StreamingMetadata, StreamingOptions, StreamingProgressData, StreamOptions, StreamResult, ToolCall as StreamToolCall, // Renamed to avoid conflict with tools.js ToolCall
 ToolCallResults, ToolCalls, ToolResult as StreamToolResult, } from "./streamTypes.js";
 export * from "./ttsTypes.js";
 export * from "./utilities.js";
-export * from "./workflowTypes.js";
+export type { AggregatedUsage, ConditioningConfig, ConditionOptions, ConditionResult, EnsembleExecutionResult, EnsembleResponse, ExecuteEnsembleOptions, ExecuteLayerOptions, ExecuteModelOptions, ExecutionConfig, ExecutionStrategy, JudgeConfig, JudgeOutputFormat, JudgeScores, LayerExecutionResult, ListOptions, ModelGroup, MultiJudgeScores, ParsedJudgeResponse, RegisterOptions, RegisterResult, RegistryEntry, RegistryStats, ScoreOptions, ScoreResult as WorkflowScoreResult, SummaryStats, ToneAdjustment, ValidationIssues, WorkflowAnalytics, WorkflowComparison, WorkflowConfig, WorkflowErrorDetails, WorkflowEvaluationData, WorkflowExecutionMetrics, WorkflowGenerateOptions, WorkflowInput, WorkflowMetadata, WorkflowModelConfig, WorkflowResult, WorkflowType, WorkflowValidationError, WorkflowValidationResult, WorkflowValidationWarning, } from "./workflowTypes.js";
+export { WorkflowError } from "./workflowTypes.js";
 export * from "./contextTypes.js";
 export * from "./fileReferenceTypes.js";
 export * from "./ragTypes.js";

package/dist/types/index.js

@@ -28,6 +28,8 @@ export * from "./hitlTypes.js";
 export * from "./middlewareTypes.js";
 // Model types - NEW
 export * from "./modelTypes.js";
+// Scorer types for evaluation system
+export * from "./scorerTypes.js";
 // SDK Types - Core types for external developers
 // Note: sdkTypes.ts uses selective re-exports internally, so we use wildcard here
 // The conflicts were from generateTypes and analytics which are now handled above
@@ -38,8 +40,7 @@ export * from "./serviceTypes.js";
 export * from "./ttsTypes.js";
 // Utilities Types - Utility module types (selective export to avoid conflicts)
 export * from "./utilities.js";
-// Workflow types
-export * from "./workflowTypes.js";
+export { WorkflowError } from "./workflowTypes.js";
 // Context compaction types
 export * from "./contextTypes.js";
 // File reference types