@juspay/neurolink 9.37.0 → 9.39.0

package/dist/lib/models/anthropicModels.d.ts

@@ -20,8 +20,10 @@ export declare enum AnthropicModel {
     CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20241022",
     CLAUDE_3_5_SONNET_V2 = "claude-3-5-sonnet-v2-20241022",
     CLAUDE_SONNET_4 = "claude-sonnet-4-20250514",
+    CLAUDE_SONNET_4_6 = "claude-sonnet-4-6",
     CLAUDE_3_OPUS = "claude-3-opus-20240229",
-    CLAUDE_OPUS_4 = "claude-opus-4-20250514"
+    CLAUDE_OPUS_4 = "claude-opus-4-20250514",
+    CLAUDE_OPUS_4_6 = "claude-opus-4-6"
 }
 /**
  * Model access mapping by subscription tier

package/dist/lib/models/anthropicModels.js

@@ -27,10 +27,14 @@ export var AnthropicModel;
     AnthropicModel["CLAUDE_3_5_SONNET_V2"] = "claude-3-5-sonnet-v2-20241022";
     // Claude Sonnet 4 (Latest Sonnet)
     AnthropicModel["CLAUDE_SONNET_4"] = "claude-sonnet-4-20250514";
+    // Claude Sonnet 4.6
+    AnthropicModel["CLAUDE_SONNET_4_6"] = "claude-sonnet-4-6";
     // Claude 3 Opus (Legacy flagship)
     AnthropicModel["CLAUDE_3_OPUS"] = "claude-3-opus-20240229";
     // Claude Opus 4 (Latest flagship)
     AnthropicModel["CLAUDE_OPUS_4"] = "claude-opus-4-20250514";
+    // Claude Opus 4.6
+    AnthropicModel["CLAUDE_OPUS_4_6"] = "claude-opus-4-6";
 })(AnthropicModel || (AnthropicModel = {}));
 // ============================================================================
 // MODEL TIER ACCESS DEFINITIONS
@@ -56,6 +60,7 @@ export const MODEL_TIER_ACCESS = {
         AnthropicModel.CLAUDE_3_5_SONNET,
         AnthropicModel.CLAUDE_3_5_SONNET_V2,
         AnthropicModel.CLAUDE_SONNET_4,
+        AnthropicModel.CLAUDE_SONNET_4_6,
     ],
     // Max tier: All models including Opus
     max: ["*"], // All models
@@ -167,6 +172,32 @@ export const MODEL_METADATA = {
         family: "opus",
         description: "Latest flagship model with advanced reasoning",
     },
+    // Claude Sonnet 4.6
+    [AnthropicModel.CLAUDE_SONNET_4_6]: {
+        displayName: "Claude Sonnet 4.6",
+        contextWindow: 1000000,
+        maxOutputTokens: 64000,
+        supportsVision: true,
+        supportsExtendedThinking: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+        deprecated: false,
+        family: "sonnet",
+        description: "Claude 4.6 Sonnet with 1M context window",
+    },
+    // Claude Opus 4.6
+    [AnthropicModel.CLAUDE_OPUS_4_6]: {
+        displayName: "Claude Opus 4.6",
+        contextWindow: 1000000,
+        maxOutputTokens: 64000,
+        supportsVision: true,
+        supportsExtendedThinking: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+        deprecated: false,
+        family: "opus",
+        description: "Claude 4.6 Opus flagship with 1M context window",
+    },
 };
 // ============================================================================
 // DEFAULT MODELS BY TIER
@@ -417,11 +448,16 @@ export function getLatestModelsByFamily() {
     const familyPriority = {
         haiku: [AnthropicModel.CLAUDE_3_5_HAIKU, AnthropicModel.CLAUDE_3_HAIKU],
         sonnet: [
+            AnthropicModel.CLAUDE_SONNET_4_6,
             AnthropicModel.CLAUDE_SONNET_4,
             AnthropicModel.CLAUDE_3_5_SONNET_V2,
             AnthropicModel.CLAUDE_3_5_SONNET,
         ],
-        opus: [AnthropicModel.CLAUDE_OPUS_4, AnthropicModel.CLAUDE_3_OPUS],
+        opus: [
+            AnthropicModel.CLAUDE_OPUS_4_6,
+            AnthropicModel.CLAUDE_OPUS_4,
+            AnthropicModel.CLAUDE_3_OPUS,
+        ],
     };
     for (const family of Object.keys(familyPriority)) {
         for (const model of familyPriority[family]) {

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

@@ -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
@@ -157,6 +158,11 @@ export declare class VideoProcessor extends BaseFileProcessor<ProcessedVideo> {
      * @returns Success result with probe data or error message
      */
     private probeVideo;
+    /**
+     * Probe a video file using mediabunny (pure TypeScript, no native binary).
+     * Falls back to ffprobe if mediabunny fails or doesn't support the format.
+     */
+    private probeVideoWithMediabunny;
     /**
      * Build a structured metadata object from ffprobe data.
      *

package/dist/lib/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/lib/providers/anthropic.js

@@ -140,7 +140,24 @@ const detectSubscriptionTier = (oauthToken) => {
  * OAuth takes precedence over API key if both are available.
  */
 const detectAuthMethod = (oauthToken) => {
-    // OAuth takes precedence if available
+    // Explicit env var takes highest precedence — allows forcing api_key mode
+    // even when OAuth credentials exist (e.g., when using a proxy that handles auth)
+    const explicit = process.env.ANTHROPIC_AUTH_METHOD?.toLowerCase();
+    if (explicit === "api_key" || explicit === "apikey") {
+        logger.debug("[detectAuthMethod] Forced to api_key by ANTHROPIC_AUTH_METHOD env var");
+        return "api_key";
+    }
+    if (explicit === "oauth") {
+        if (oauthToken) {
+            logger.debug("[detectAuthMethod] Forced to oauth by ANTHROPIC_AUTH_METHOD env var");
+            return "oauth";
+        }
+        logger.warn("[detectAuthMethod] ANTHROPIC_AUTH_METHOD=oauth but no OAuth token found; falling through to auto-detection");
+    }
+    else if (explicit) {
+        logger.warn("[detectAuthMethod] Unrecognized ANTHROPIC_AUTH_METHOD value; falling through to auto-detection", { value: explicit });
+    }
+    // Auto-detect: OAuth takes precedence if available
     const method = oauthToken ? "oauth" : "api_key";
     logger.debug("[detectAuthMethod] Auth method resolved", {
         method,
@@ -200,11 +217,22 @@ export class AnthropicProvider extends BaseProvider {
     constructor(modelName, sdk, config) {
         // Pre-compute effective model with tier validation before calling super
         const oauthToken = config?.oauthToken ?? getOAuthToken();
-        const subscriptionTier = config?.subscriptionTier ?? detectSubscriptionTier(oauthToken);
+        // Resolve auth method FIRST so that tier detection uses the chosen method.
+        // If ANTHROPIC_AUTH_METHOD=api_key wins over an existing OAuth token, the
+        // tier must reflect api_key mode (full model access) rather than the OAuth
+        // token's subscription level.
+        const authMethod = config?.authMethod ?? detectAuthMethod(oauthToken);
+        const subscriptionTier = config?.subscriptionTier ??
+            (authMethod === "oauth" ? detectSubscriptionTier(oauthToken) : "api");
         const targetModel = modelName || getDefaultAnthropicModel();
-        // Determine effective model based on tier access
+        // Determine effective model based on tier access.
+        // Skip tier validation when a proxy is in use (ANTHROPIC_BASE_URL is set)
+        // — the proxy handles model access and auth, so the SDK should pass
+        // the requested model through without downgrading.
         let effectiveModel = targetModel;
-        if (subscriptionTier !== "api" &&
+        const usingProxy = !!process.env.ANTHROPIC_BASE_URL;
+        if (!usingProxy &&
+            subscriptionTier !== "api" &&
             !isModelAvailableForTier(targetModel, subscriptionTier)) {
             effectiveModel = getRecommendedModelForTier(subscriptionTier);
             logger.warn("Model not available for subscription tier, using recommended model", {
@@ -219,8 +247,8 @@ export class AnthropicProvider extends BaseProvider {
         // Store computed values
         this.oauthToken = oauthToken;
         this.subscriptionTier = subscriptionTier;
-        // Determine auth method - config takes precedence, then auto-detect
-        this.authMethod = config?.authMethod ?? detectAuthMethod(this.oauthToken);
+        // Use the auth method already resolved above (before tier computation)
+        this.authMethod = authMethod;
         // Build headers based on auth method and subscription tier
         const headers = this.getAuthHeaders();
         // Create Anthropic instance based on auth method
@@ -348,6 +376,10 @@ export class AnthropicProvider extends BaseProvider {
      * ```
      */
     validateModelAccess(model) {
+        // Proxy mode: bypass tier validation entirely — the proxy handles model access
+        if (process.env.ANTHROPIC_BASE_URL) {
+            return true;
+        }
         // API tier has access to all models
         if (this.subscriptionTier === "api") {
             return true;