@juspay/neurolink 10.8.6 → 10.8.8

package/dist/processors/media/AudioProcessor.js

@@ -40,6 +40,7 @@ import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
 import { SIZE_LIMITS_MB } from "../config/index.js";
 import { FileErrorCode } from "../errors/index.js";
 import { withTimeout } from "../../utils/timeout.js";
+import { formatMediaDuration } from "../../utils/mediaDuration.js";
 let _musicMetadata = null;
 async function loadMusicMetadata() {
     if (_musicMetadata) {
@@ -397,7 +398,7 @@ export class AudioProcessor extends BaseFileProcessor {
             textContent: "",
             metadata: {
                 duration: 0,
-                durationFormatted: "0:00",
+                durationFormatted: formatMediaDuration(0),
                 codec: "unknown",
                 lossless: false,
                 fileSize: buffer.length,
@@ -608,26 +609,15 @@ export class AudioProcessor extends BaseFileProcessor {
     /**
      * Format a duration in seconds to a human-readable string.
      *
-     * @param seconds - Duration in seconds
-     * @returns Formatted string: "M:SS" for < 1 hour, "H:MM:SS" for >= 1 hour
+     * Delegates to the shared formatter so audio and video describe the same
+     * file the same way — this used to render "0:02" where VideoProcessor
+     * rendered "2s".
      *
-     * @example
-     * formatDuration(225)   // "3:45"
-     * formatDuration(3750)  // "1:02:30"
-     * formatDuration(0)     // "0:00"
+     * @param seconds - Duration in seconds
+     * @returns Formatted string: "45s", "3m 45s", "1h 2m 30s"
      */
     formatDuration(seconds) {
-        if (!seconds || seconds <= 0) {
-            return "0:00";
-        }
-        const totalSeconds = Math.round(seconds);
-        const hours = Math.floor(totalSeconds / 3600);
-        const minutes = Math.floor((totalSeconds % 3600) / 60);
-        const secs = totalSeconds % 60;
-        if (hours > 0) {
-            return `${hours}:${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
-        }
-        return `${minutes}:${String(secs).padStart(2, "0")}`;
+        return formatMediaDuration(seconds);
     }
     /**
      * Format bitrate to a human-readable string.

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

@@ -205,6 +205,11 @@ export declare class VideoProcessor extends BaseFileProcessor<ProcessedVideo> {
     /**
      * Format a duration in seconds to a human-readable string.
      *
+     * Delegates to the shared formatter so audio and video agree — see
+     * `formatMediaDuration`. Rounding replaces the previous truncation, so a
+     * 2.6s clip now reads "3s" rather than "2s" and matches what the audio
+     * side reports for the same stream.
+     *
      * @param seconds - Duration in seconds
      * @returns Formatted string (e.g., "1h 23m 45s")
      */

package/dist/processors/media/VideoProcessor.js

@@ -50,6 +50,7 @@ import { join } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
+import { formatMediaDuration } from "../../utils/mediaDuration.js";
 import { SIZE_LIMITS_MB } from "../config/index.js";
 import { FileErrorCode } from "../errors/index.js";
 import { tracers, ATTR, withSpan } from "../../telemetry/index.js";
@@ -270,7 +271,7 @@ export class VideoProcessor extends BaseFileProcessor {
             keyframes: [],
             metadata: {
                 duration: 0,
-                durationFormatted: "0s",
+                durationFormatted: formatMediaDuration(0),
                 width: 0,
                 height: 0,
                 codec: "unknown",
@@ -908,27 +909,16 @@ export class VideoProcessor extends BaseFileProcessor {
     /**
      * Format a duration in seconds to a human-readable string.
      *
+     * Delegates to the shared formatter so audio and video agree — see
+     * `formatMediaDuration`. Rounding replaces the previous truncation, so a
+     * 2.6s clip now reads "3s" rather than "2s" and matches what the audio
+     * side reports for the same stream.
+     *
      * @param seconds - Duration in seconds
      * @returns Formatted string (e.g., "1h 23m 45s")
      */
     formatDuration(seconds) {
-        if (seconds <= 0) {
-            return "0s";
-        }
-        const hours = Math.floor(seconds / 3600);
-        const minutes = Math.floor((seconds % 3600) / 60);
-        const secs = Math.floor(seconds % 60);
-        const parts = [];
-        if (hours > 0) {
-            parts.push(`${hours}h`);
-        }
-        if (minutes > 0) {
-            parts.push(`${minutes}m`);
-        }
-        if (secs > 0 || parts.length === 0) {
-            parts.push(`${secs}s`);
-        }
-        return parts.join(" ");
+        return formatMediaDuration(seconds);
     }
     /**
      * Get a file extension from FileInfo, falling back to ".mp4".

package/dist/providers/googleVertex/client.d.ts

@@ -141,6 +141,26 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Validate stream options
      */
     private validateStreamOptionsOnly;
+    /**
+     * Preprocess file input before routing to the native SDKs.
+     *
+     * BaseProvider runs this via `buildMultimodalMessagesArray`, but Vertex
+     * overrides both `generate()` and `executeStream()` to reach the native
+     * @google/genai / @anthropic-ai/vertex-sdk clients directly, so neither
+     * inherits it. Without this the file content never reaches the model and
+     * the reply is an entirely plausible "no document is attached" — a silent
+     * wrong answer rather than an error.
+     *
+     * #1258: only `generate()` used to call this, so the same document that
+     * `generate()` read back correctly came back as "no documents attached"
+     * through `stream()`. Sharing one method is what keeps the two paths from
+     * drifting apart again.
+     *
+     * #1259: the alias fold has to happen *before* the `files` check, or
+     * requests carrying only `audioFiles`/`videoFiles` look empty here and skip
+     * preprocessing entirely.
+     */
+    private preprocessNativeFileInput;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodType<unknown> | Schema<unknown>): Promise<StreamResult>;
     /**
      * Emit `stream:end` so the Pipeline B observability listener creates a

package/dist/providers/googleVertex/client.js

@@ -14,7 +14,7 @@ import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, Ra
 import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
 import { applyVertexAnthropicCacheBreakpoints } from "../../utils/anthropicCacheBreakpoints.js";
 import { FileDetector } from "../../utils/fileDetector.js";
-import { processUnifiedFilesArray } from "../../utils/messageBuilder.js";
+import { mergeMediaFileAliases, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
 import { detectImageMimeType } from "../../utils/imageDetection.js";
@@ -868,6 +868,40 @@ export class GoogleVertexProvider extends BaseProvider {
     validateStreamOptionsOnly(options) {
         this.validateStreamOptions(options);
     }
+    /**
+     * Preprocess file input before routing to the native SDKs.
+     *
+     * BaseProvider runs this via `buildMultimodalMessagesArray`, but Vertex
+     * overrides both `generate()` and `executeStream()` to reach the native
+     * @google/genai / @anthropic-ai/vertex-sdk clients directly, so neither
+     * inherits it. Without this the file content never reaches the model and
+     * the reply is an entirely plausible "no document is attached" — a silent
+     * wrong answer rather than an error.
+     *
+     * #1258: only `generate()` used to call this, so the same document that
+     * `generate()` read back correctly came back as "no documents attached"
+     * through `stream()`. Sharing one method is what keeps the two paths from
+     * drifting apart again.
+     *
+     * #1259: the alias fold has to happen *before* the `files` check, or
+     * requests carrying only `audioFiles`/`videoFiles` look empty here and skip
+     * preprocessing entirely.
+     */
+    async preprocessNativeFileInput(options) {
+        if (options.input) {
+            mergeMediaFileAliases(options.input);
+        }
+        if (!options.input?.files?.length) {
+            return;
+        }
+        try {
+            // Mutates options.input.text / .images / .pdfFiles in place.
+            await processUnifiedFilesArray(options, 100 * 1024 * 1024, this.providerName);
+        }
+        catch (fileError) {
+            logger.warn(`[GoogleVertex] processUnifiedFilesArray threw, continuing without file content: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+        }
+    }
     async executeStream(options, _analysisSchema) {
         // ALL models now use native SDKs - no more @ai-sdk/google-vertex dependency
         const modelName = options.model || this.modelName || getDefaultVertexModel();
@@ -889,6 +923,9 @@ export class GoogleVertexProvider extends BaseProvider {
             // Tool filter (a0269210): trust options.tools — caller (BaseProvider.stream)
             // already merged MCP/built-in tools and applied any enabledToolNames filter.
             const optionTools = options.tools || {};
+            // #1258: stream() must run the same file preprocessing generate()
+            // does, or attached files are dropped on this path alone.
+            await this.preprocessNativeFileInput(options);
             // Emit a `neurolink.message.build` span for the native stream path
             // so observability tooling sees the same hierarchy it sees on
             // Pipeline A. Without this, test:tracing's "Message Build Span"
@@ -5742,20 +5779,7 @@ export class GoogleVertexProvider extends BaseProvider {
             const baseTools = !options.disableTools
                 ? await this.getToolsForStream(options)
                 : {};
-            // Process the unified `input.files` array before routing to the
-            // native SDK. BaseProvider.generate() runs this preprocessing via
-            // buildMultimodalMessagesArray, but Vertex's override skips it,
-            // which would otherwise drop text-file content (and the
-            // mimetype-hint contract) on the floor. Mutates options.input.text /
-            // options.input.images / options.input.pdfFiles in place.
-            if (options.input?.files && options.input.files.length > 0) {
-                try {
-                    await processUnifiedFilesArray(options, 100 * 1024 * 1024, this.providerName);
-                }
-                catch (fileError) {
-                    logger.warn(`[GoogleVertex] processUnifiedFilesArray threw, continuing without file content: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
-                }
-            }
+            await this.preprocessNativeFileInput(options);
             // Emit a `neurolink.message.build` span so observability tooling
             // sees the message-construction phase even on the native (Pipeline B)
             // Vertex path. Pipeline A normally produces this via MessageBuilder;

package/dist/proxy/rollingWorkerSupervisor.d.ts

@@ -32,6 +32,7 @@ export declare class RollingWorkerSupervisor {
     private spawnCandidate;
     private flushQueuedSockets;
     private transferSocket;
+    private maybeDrainWorker;
     private handleTransferFailure;
     private rejectSocket;
     private describeTransferError;

package/dist/proxy/rollingWorkerSupervisor.js

@@ -287,21 +287,19 @@ export class RollingWorkerSupervisor {
                     generation,
                     version: expectedVersion,
                     dispose,
+                    pendingTransfers: 0,
+                    drainRequested: false,
                 };
                 this.active = activated;
                 this.candidate = null;
                 this.flushQueuedSockets();
                 if (previous) {
                     this.draining.set(previous.generation, previous);
-                    try {
-                        previous.handle.sendControl({
-                            type: "proxy-worker:drain",
-                            generation: previous.generation,
-                        });
-                    }
-                    catch {
-                        previous.handle.terminate("SIGTERM");
-                    }
+                    // A worker can still own socket transfers accepted before this
+                    // activation. Draining it before their IPC commits makes those
+                    // clients fail even though the replacement is healthy.
+                    previous.drainRequested = true;
+                    this.maybeDrainWorker(previous);
                 }
                 this.options.log?.(`[proxy-supervisor] activated generation=${generation} pid=${handle.pid} version=${expectedVersion}`);
                 this.publishState();
@@ -340,6 +338,8 @@ export class RollingWorkerSupervisor {
                 handle,
                 generation,
                 version: expectedVersion,
+                pendingTransfers: 0,
+                drainRequested: false,
                 expectedVersion,
                 activationRequested: false,
                 dispose,
@@ -362,15 +362,41 @@ export class RollingWorkerSupervisor {
         }
     }
     transferSocket(worker, socket) {
+        worker.pendingTransfers += 1;
+        let settled = false;
+        const complete = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            worker.pendingTransfers = Math.max(0, worker.pendingTransfers - 1);
+            if (error) {
+                this.handleTransferFailure(worker, socket, error);
+            }
+            this.maybeDrainWorker(worker);
+        };
         try {
-            worker.handle.sendSocket(worker.generation, socket, (error) => {
-                if (error) {
-                    this.handleTransferFailure(worker, socket, error);
-                }
-            });
+            worker.handle.sendSocket(worker.generation, socket, complete);
         }
         catch (error) {
-            this.handleTransferFailure(worker, socket, error);
+            complete(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    maybeDrainWorker(worker) {
+        if (!worker.drainRequested ||
+            worker.pendingTransfers > 0 ||
+            !this.draining.has(worker.generation)) {
+            return;
+        }
+        worker.drainRequested = false;
+        try {
+            worker.handle.sendControl({
+                type: "proxy-worker:drain",
+                generation: worker.generation,
+            });
+        }
+        catch {
+            worker.handle.terminate("SIGTERM");
         }
     }
     handleTransferFailure(worker, socket, error) {

package/dist/types/proxy.d.ts

@@ -1949,6 +1949,8 @@ export type RollingManagedWorker = {
     generation: number;
     version: string;
     dispose: () => void;
+    pendingTransfers: number;
+    drainRequested: boolean;
 };
 export type RollingCandidateWorker = RollingManagedWorker & {
     expectedVersion: string;

package/dist/utils/mediaDuration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared duration formatting for the media processors.
+ *
+ * AudioProcessor and VideoProcessor each carried their own private
+ * `formatDuration`, and they disagreed: the same two-second file rendered as
+ * "0:02" from audio and "2s" from video, and a zero duration as "0:00" versus
+ * "0s". Both strings land in the `textContent` handed to the model, often in
+ * the same request when a video's muxed audio is described alongside it, so
+ * the mismatch reads as two different facts about one file.
+ *
+ * The explicit-unit form wins over the "m:ss" clock form because these strings
+ * are consumed by a language model, not rendered in a player scrubber: "1m 30s"
+ * has exactly one reading, while "1:30" is ambiguous between 1m30s and 1h30m
+ * and has to be disambiguated from context that may not be present.
+ */
+/**
+ * Format a duration in seconds as explicit units — "45s", "1m 30s", "1h 2m 3s".
+ *
+ * Non-finite, negative and zero durations all render as "0s": callers reach
+ * this with a probe failure or a stream that reports no duration, and a
+ * fabricated number would be worse than an obvious zero.
+ */
+export declare function formatMediaDuration(seconds: number): string;

package/dist/utils/mediaDuration.js

@@ -0,0 +1,44 @@
+/**
+ * Shared duration formatting for the media processors.
+ *
+ * AudioProcessor and VideoProcessor each carried their own private
+ * `formatDuration`, and they disagreed: the same two-second file rendered as
+ * "0:02" from audio and "2s" from video, and a zero duration as "0:00" versus
+ * "0s". Both strings land in the `textContent` handed to the model, often in
+ * the same request when a video's muxed audio is described alongside it, so
+ * the mismatch reads as two different facts about one file.
+ *
+ * The explicit-unit form wins over the "m:ss" clock form because these strings
+ * are consumed by a language model, not rendered in a player scrubber: "1m 30s"
+ * has exactly one reading, while "1:30" is ambiguous between 1m30s and 1h30m
+ * and has to be disambiguated from context that may not be present.
+ */
+/**
+ * Format a duration in seconds as explicit units — "45s", "1m 30s", "1h 2m 3s".
+ *
+ * Non-finite, negative and zero durations all render as "0s": callers reach
+ * this with a probe failure or a stream that reports no duration, and a
+ * fabricated number would be worse than an obvious zero.
+ */
+export function formatMediaDuration(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return "0s";
+    }
+    const total = Math.round(seconds);
+    const hours = Math.floor(total / 3600);
+    const minutes = Math.floor((total % 3600) / 60);
+    const secs = total % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+    }
+    // Keep the seconds term when it is the only one, so sub-minute durations
+    // never render as an empty string.
+    if (secs > 0 || parts.length === 0) {
+        parts.push(`${secs}s`);
+    }
+    return parts.join(" ");
+}

package/dist/utils/messageBuilder.d.ts

@@ -12,6 +12,31 @@ export declare function convertToModelMessages(messages: MultimodalChatMessage[]
  * Enhanced with CSV file processing support
  */
 export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): Promise<ModelMessage[]>;
+/**
+ * Fold the `audioFiles` / `videoFiles` aliases into the unified `files` array.
+ *
+ * #284 gave audio and video their own input fields, but neither has a
+ * dedicated processor — both are meant to travel through the same
+ * auto-detecting `files` pipeline that already understands "audio"/"video"
+ * FileDetector results (see `appendDetectedFileResult`). The fold used to live
+ * inline in `buildMultimodalMessagesArray`, which meant any path that bypassed
+ * that builder never performed it and dropped the files silently: the model
+ * received the prompt alone and answered as though nothing were attached
+ * (#1259). GoogleVertex's native SDK path and `buildMultimodalOptions`
+ * (Bedrock) are both such paths, so the fold has to be callable from them.
+ *
+ * The aliases are cleared once merged, which makes the call idempotent: a
+ * provider override and the shared builder can both call this on the same
+ * options object without attaching every file twice.
+ *
+ * Mutates in place, matching `processUnifiedFilesArray` below — downstream
+ * stages all read `options.input.files`.
+ */
+export declare function mergeMediaFileAliases<TFile>(input: {
+    files?: Array<TFile | Buffer | string>;
+    audioFiles?: Array<Buffer | string>;
+    videoFiles?: Array<Buffer | string>;
+}): void;
 /**
  * Process the unified files array with auto-detection.
  * Handles lazy file registration, full processing, and preview injection.

package/dist/utils/messageBuilder.js

@@ -777,6 +777,38 @@ function appendDetectedFileResult(result, file, options) {
         logger.info(`[FileDetector] ⚠️ Unknown format (metadata extracted): ${filename}`);
     }
 }
+/**
+ * Fold the `audioFiles` / `videoFiles` aliases into the unified `files` array.
+ *
+ * #284 gave audio and video their own input fields, but neither has a
+ * dedicated processor — both are meant to travel through the same
+ * auto-detecting `files` pipeline that already understands "audio"/"video"
+ * FileDetector results (see `appendDetectedFileResult`). The fold used to live
+ * inline in `buildMultimodalMessagesArray`, which meant any path that bypassed
+ * that builder never performed it and dropped the files silently: the model
+ * received the prompt alone and answered as though nothing were attached
+ * (#1259). GoogleVertex's native SDK path and `buildMultimodalOptions`
+ * (Bedrock) are both such paths, so the fold has to be callable from them.
+ *
+ * The aliases are cleared once merged, which makes the call idempotent: a
+ * provider override and the shared builder can both call this on the same
+ * options object without attaching every file twice.
+ *
+ * Mutates in place, matching `processUnifiedFilesArray` below — downstream
+ * stages all read `options.input.files`.
+ */
+export function mergeMediaFileAliases(input) {
+    if (!input.audioFiles?.length && !input.videoFiles?.length) {
+        return;
+    }
+    input.files = [
+        ...(input.files ?? []),
+        ...(input.audioFiles ?? []),
+        ...(input.videoFiles ?? []),
+    ];
+    input.audioFiles = undefined;
+    input.videoFiles = undefined;
+}
 /**
  * Process the unified files array with auto-detection.
  * Handles lazy file registration, full processing, and preview injection.
@@ -1115,18 +1147,7 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
     // local const so TypeScript sees the definite (non-optional) type in the
     // rest of this function, avoiding 60+ "possibly undefined" errors.
     const inp = options.input;
-    // #284: audioFiles/videoFiles have no dedicated processor — route them
-    // through the same auto-detecting `files` pipeline that already
-    // understands "audio"/"video" FileDetector results (see
-    // appendDetectedFileResult), instead of silently dropping them once
-    // detectMultimodal() routes an audio/video-only request here.
-    if (inp.audioFiles?.length || inp.videoFiles?.length) {
-        inp.files = [
-            ...(inp.files || []),
-            ...(inp.audioFiles || []),
-            ...(inp.videoFiles || []),
-        ];
-    }
+    mergeMediaFileAliases(inp);
     // Compute provider-specific max PDF size once for consistent validation
     const pdfConfig = PDFProcessor.getProviderConfig(provider);
     const maxSize = pdfConfig

package/dist/utils/multimodalOptionsBuilder.d.ts

@@ -12,6 +12,8 @@ import type { StreamOptions } from "../types/index.js";
  *   - input.files: Auto-detected file types
  *   - input.csvFiles: CSV files for tabular data
  *   - input.pdfFiles: PDF documents (Buffer | string paths)
+ *   - input.audioFiles: Audio files (Buffer | string paths)
+ *   - input.videoFiles: Video files (Buffer | string paths)
  *   - csvOptions: CSV parsing options
  *   - systemPrompt: System-level instructions
  *   - conversationMessages: Chat history
@@ -23,7 +25,7 @@ import type { StreamOptions } from "../types/index.js";
  * @param {string} providerName - Provider identifier (e.g., "vertex", "openai", "anthropic")
  * @param {string} modelName - Model identifier (e.g., "gemini-2.5-flash", "gpt-4o")
  * @returns {object} Normalized options object with:
- *   - input: { text, images, content, files, csvFiles, pdfFiles }
+ *   - input: { text, images, content, files, csvFiles, pdfFiles, audioFiles, videoFiles }
  *   - csvOptions: CSV processing options
  *   - systemPrompt: System prompt string
  *   - conversationHistory: Message history array
@@ -49,6 +51,8 @@ export declare function buildMultimodalOptions(options: StreamOptions, providerN
         files: (string | Buffer<ArrayBufferLike> | import("../index.js").FileWithMetadata)[] | undefined;
         csvFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
         pdfFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
+        audioFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
+        videoFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
     };
     csvOptions: import("../index.js").CSVProcessorOptions | undefined;
     pdfOptions: {

package/dist/utils/multimodalOptionsBuilder.js

@@ -11,6 +11,8 @@
  *   - input.files: Auto-detected file types
  *   - input.csvFiles: CSV files for tabular data
  *   - input.pdfFiles: PDF documents (Buffer | string paths)
+ *   - input.audioFiles: Audio files (Buffer | string paths)
+ *   - input.videoFiles: Video files (Buffer | string paths)
  *   - csvOptions: CSV parsing options
  *   - systemPrompt: System-level instructions
  *   - conversationMessages: Chat history
@@ -22,7 +24,7 @@
  * @param {string} providerName - Provider identifier (e.g., "vertex", "openai", "anthropic")
  * @param {string} modelName - Model identifier (e.g., "gemini-2.5-flash", "gpt-4o")
  * @returns {object} Normalized options object with:
- *   - input: { text, images, content, files, csvFiles, pdfFiles }
+ *   - input: { text, images, content, files, csvFiles, pdfFiles, audioFiles, videoFiles }
  *   - csvOptions: CSV processing options
  *   - systemPrompt: System prompt string
  *   - conversationHistory: Message history array
@@ -49,6 +51,11 @@ export function buildMultimodalOptions(options, providerName, modelName) {
             files: options.input?.files,
             csvFiles: options.input?.csvFiles,
             pdfFiles: options.input?.pdfFiles,
+            // #1259: this is a whitelist — a field omitted here is dropped
+            // silently, and the model answers as though nothing were attached.
+            // audioFiles/videoFiles were missing, so Bedrock received neither.
+            audioFiles: options.input?.audioFiles,
+            videoFiles: options.input?.videoFiles,
         },
         csvOptions: options.csvOptions,
         pdfOptions: options.pdfOptions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.8.6",
+  "version": "10.8.8",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {