@juspay/neurolink 10.11.2 → 10.11.3

package/dist/lib/providers/googleNativeGemini3/utils.js

@@ -12,6 +12,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { extname } from "node:path";
 import { DEFAULT_CONTEXT_GUARD_RATIO, DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, DEFAULT_WRAPUP_TIME_LEAD_MS, } from "../../core/constants.js";
+import { needsAudioTranscode, toProviderCompatibleAudio, } from "../../adapters/audioFormatSupport.js";
 import { logger } from "../../utils/logger.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
 import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, normalizeJsonSchemaObject, } from "../../utils/schemaConversion.js";
@@ -1432,6 +1433,53 @@ conversationMessages) {
  * is skipped rather than aborting the entire request, matching prior
  * Vertex behaviour.
  */
+/**
+ * Append audio to a Gemini request as `inlineData` parts.
+ *
+ * Shared by both Gemini front ends. Vertex assembles its request here and AI
+ * Studio assembles it in `buildUserPartsWithMultimodal`; when this lived only in
+ * the Vertex client, AI Studio advertised audio support through
+ * `NATIVE_AUDIO_PROVIDERS` and then silently dropped the bytes.
+ *
+ * Gemini's native request shape is assembled directly rather than taken from the
+ * AI SDK's `file` parts, so audio has to be added explicitly the same way PDFs
+ * and images are — a `{ type: "file" }` part built upstream simply never
+ * reaches this request body. That asymmetry is why attaching a recording
+ * produced only the metadata summary even after the message builder learned to
+ * carry the bytes.
+ *
+ * A container Gemini does not accept is converted first; one that cannot be
+ * converted is skipped rather than sent, because an unsupported inlineData
+ * mimeType fails the whole request, and the caller still has the metadata
+ * summary in the text part.
+ */
+export async function appendNativeAudioParts(userParts, audioFiles, logPrefix = "[GeminiNative]") {
+    if (!audioFiles || audioFiles.length === 0) {
+        return;
+    }
+    for (const audio of audioFiles) {
+        // Split on both separators: a Windows-style name reaching a POSIX host
+        // would otherwise keep its whole path, and the extension lookup below
+        // needs the bare filename.
+        const base = audio.filename.split(/[\\/]/).pop() ?? audio.filename;
+        const dot = base.lastIndexOf(".");
+        const extension = dot > 0 ? base.slice(dot) : ".bin";
+        const compatible = await toProviderCompatibleAudio(audio.buffer, audio.mimeType, extension);
+        if (needsAudioTranscode(compatible.mimeType)) {
+            logger.warn(`${logPrefix} Skipping native audio for ${base}: ${compatible.mimeType} ` +
+                `is not accepted and could not be converted. The metadata summary was ` +
+                `still included.`);
+            continue;
+        }
+        userParts.push({
+            inlineData: {
+                mimeType: compatible.mimeType,
+                data: compatible.buffer.toString("base64"),
+            },
+        });
+        logger.debug(`${logPrefix} Added native audio part for ${base} (${compatible.mimeType})`);
+    }
+}
 export async function buildUserPartsWithMultimodal(input, textOverride, logPrefix = "[GeminiNative]") {
     const text = typeof textOverride === "string" ? textOverride : (input?.text ?? "");
     const parts = [{ text }];
@@ -1533,6 +1581,12 @@ export async function buildUserPartsWithMultimodal(input, textOverride, logPrefi
             });
         }
     }
+    // Audio last, and through the same helper the Vertex client uses. AI Studio
+    // never touches `buildMultimodalMessagesArray` — it overrides generate() and
+    // stream() and assembles its request here — so wiring audio only into the
+    // Vertex client left this front end advertising native audio via
+    // NATIVE_AUDIO_PROVIDERS and then dropping the bytes on the floor.
+    await appendNativeAudioParts(parts, input?.nativeAudioFiles, logPrefix);
     return parts;
 }
 //# sourceMappingURL=utils.js.map

package/dist/lib/providers/googleVertex/client.js

@@ -6,6 +6,7 @@ import os from "os";
 import { AIProviderName, ErrorCategory, ErrorSeverity, } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import { unwrapImagePayload } from "../../adapters/imageFormatSupport.js";
+import { appendNativeAudioParts } from "../googleNativeGemini3/utils.js";
 import { getMimeTypeForExtension } from "../../processors/config/mimeConstants.js";
 import { DEFAULT_GEMINI_STREAM_TIMEOUT_MS, DEFAULT_MAX_STEPS, DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, DEFAULT_TOOL_MAX_RETRIES, GLOBAL_LOCATION_MODELS, IMAGE_GENERATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../../core/constants.js";
 import { ModelConfigurationManager } from "../../core/modelConfiguration.js";
@@ -1403,6 +1404,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 });
             }
         }
+        await appendNativeAudioParts(userParts, multimodalInput?.nativeAudioFiles, "[GoogleVertex]");
         // Add images as inlineData parts if present
         if (multimodalInput?.images && multimodalInput.images.length > 0) {
             logger.debug(`[GoogleVertex] Processing ${multimodalInput.images.length} image(s) for native stream`);
@@ -2408,6 +2410,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 });
             }
         }
+        await appendNativeAudioParts(userParts, multimodalInput?.nativeAudioFiles, "[GoogleVertex]");
         // Add images as inlineData parts if present
         if (multimodalInput?.images && multimodalInput.images.length > 0) {
             logger.debug(`[GoogleVertex] Processing ${multimodalInput.images.length} image(s) for native generate`);

package/dist/lib/types/file.d.ts

@@ -22,6 +22,36 @@ export type VisionImageConversion = {
     /** True when the bytes were re-encoded; false when they were left alone. */
     readonly converted: boolean;
 };
+/**
+ * Outcome of an audio-compatibility pass over one file.
+ *
+ * See `adapters/audioFormatSupport.ts`. As with images, `converted` is false
+ * both when the container was already acceptable and when nothing could
+ * re-encode it, so it is not a success flag — the caller decides what to do
+ * from the resulting `mimeType`.
+ */
+export type AudioConversionResult = {
+    readonly buffer: Buffer;
+    readonly mimeType: string;
+    /** True when the bytes were re-encoded; false when they were left alone. */
+    readonly converted: boolean;
+};
+/**
+ * One audio file destined for native delivery to a provider.
+ *
+ * Carries the bytes rather than a path because the decision to send audio is
+ * made per provider, after detection has already read the file — re-reading it
+ * from disk at dispatch time would be a second read of something already in
+ * memory.
+ */
+export type MultimodalAudioEntry = {
+    /** Raw audio bytes, as detected. */
+    buffer: Buffer;
+    /** Display name; may be a full path, so log only its basename. */
+    filename: string;
+    /** Detected MIME type of `buffer`. */
+    mimeType: string;
+};
 /**
  * Broad category a file format belongs to, as a human would name it.
  *
@@ -445,6 +475,17 @@ export type FileDetectorOptions = {
      * hint (the lazy FileReferenceRegistry path has its own hint-handling).
      */
     mimetypeHint?: string;
+    /**
+     * Caller-provided filename hint, the companion to {@link mimetypeHint}.
+     *
+     * The unified file path unwraps a `FileWithMetadata` to its `buffer` before
+     * detection runs, so the object's `filename` is gone by the time extension
+     * resolution looks for one — and TAR in particular cannot be identified any
+     * other way, because its "ustar" marker sits at byte 257 rather than at
+     * offset 0. Passing the name alongside the bytes keeps `.odp`, `.rtf` and
+     * `.tar` routed to the processors that can actually read them.
+     */
+    filenameHint?: string;
 };
 /**
  * Google AI Studio Files API types

package/dist/lib/types/generate.d.ts

@@ -17,7 +17,7 @@ import type { AvatarOptions, AvatarResult } from "./avatar.js";
 import type { MusicOptions, MusicResult } from "./music.js";
 import type { StandardRecord, ValidationSchema, ZodUnknownSchema } from "./aliases.js";
 import type { NeurolinkCredentials } from "./providers.js";
-import type { CSVProcessorOptions, FileWithMetadata } from "./file.js";
+import type { CSVProcessorOptions, FileWithMetadata, MultimodalAudioEntry } from "./file.js";
 import type { WorkflowConfig } from "./workflow.js";
 import type { Schema, Tool, ToolChoice } from "./tools.js";
 import type { StepResult, LanguageModel } from "./providers.js";
@@ -56,6 +56,17 @@ export type GenerateOptions = {
         csvFiles?: Array<Buffer | string>;
         pdfFiles?: Array<Buffer | string>;
         audioFiles?: Array<Buffer | string>;
+        /**
+         * Audio whose bytes should be delivered to the provider, populated during
+         * detection rather than by callers.
+         *
+         * Separate from `audioFiles` above, which is the caller-facing input that
+         * yields a metadata summary. This one carries the decoded bytes forward so
+         * a provider that can actually listen receives the audio instead of a
+         * description of it; providers that cannot fall back to the summary and
+         * this is ignored.
+         */
+        nativeAudioFiles?: MultimodalAudioEntry[];
         videoFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string | FileWithMetadata>;
         content?: Content[];

package/dist/lib/types/processor.d.ts

@@ -741,7 +741,26 @@ export type ProcessedVideo = ProcessedFileBase & {
 /**
  * Supported archive format identifiers.
  */
-export type ArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.bz2" | "gz" | "rar" | "7z";
+export type ArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.bz2" | "gz" | "bz2" | "xz" | "zst" | "rar" | "7z";
+/**
+ * Outcome of decompressing a single-stream archive (.bz2, .xz, .zst).
+ *
+ * A plain `Buffer | null` collapsed two very different failures into one: a
+ * machine that has no `xz` installed and a `.xz` file that is corrupt both
+ * returned null, and the caller reported both as "the command is unavailable on
+ * this machine" — actively misleading for the second. The reason is carried so
+ * the message can match the fact.
+ */
+export type ArchiveDecompressionResult = {
+    readonly status: "ok";
+    readonly buffer: Buffer;
+} | {
+    readonly status: "tool-unavailable";
+} | {
+    readonly status: "too-large";
+} | {
+    readonly status: "failed";
+};
 /**
  * Metadata about an individual entry within an archive.
  */

package/dist/lib/types/providers.d.ts

@@ -6,6 +6,7 @@ import type { NeuroLink } from "../neurolink.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
+import type { MultimodalAudioEntry } from "./file.js";
 import type { StreamOptions, StreamResult } from "./stream.js";
 import type { ExternalMCPToolInfo } from "./externalMcp.js";
 import type { ClaudeSubscriptionTier, AnthropicAuthMethod, AnthropicAuthConfig, SubscriptionInfo, OAuthToken } from "./subscription.js";
@@ -1821,6 +1822,12 @@ export type GeminiMultimodalInput = {
         data: Buffer | string;
         altText?: string;
     }>;
+    /**
+     * Audio collected during file detection, carried through to the native
+     * request as `inlineData`. Distinct from the user-facing `audioFiles`: these
+     * are already-materialised bytes with a resolved mime type.
+     */
+    nativeAudioFiles?: MultimodalAudioEntry[];
 };
 /**
  * Internal helpers used by the conversation-history builder in

package/dist/lib/utils/fileDetector.d.ts

@@ -17,6 +17,13 @@ import type { FileDetectorOptions, FileInput, FileProcessingResult } from "../ty
 export declare class FileDetector {
     static readonly DEFAULT_NETWORK_TIMEOUT = 30000;
     static readonly DEFAULT_HEAD_TIMEOUT = 5000;
+    /**
+     * Ceiling on an in-process document parse (unzip + XML walk). Generous
+     * relative to the work, because the cost of firing early on a large but
+     * legitimate file is a lost extraction, while the cost of never firing is a
+     * held request.
+     */
+    static readonly DEFAULT_DOCUMENT_TIMEOUT = 30000;
     /**
      * Auto-detect file type and process in one call
      *
@@ -80,6 +87,26 @@ export declare class FileDetector {
      * Stops at first strategy with confidence >= threshold (default: 80%)
      */
     private static detect;
+    /**
+     * Fill in `extension` from the input's name when detection did not set it.
+     *
+     * Content-based strategies identify a type from magic bytes and legitimately
+     * have no extension to report, so they return null. That is fine for the type
+     * itself but not for routing: several processors are chosen by extension
+     * *after* detection has settled the type, because one routing type covers
+     * several formats — `docx` covers .docx, .odt and .rtf.
+     *
+     * With a null extension those branches were unreachable. An .rtf scored high
+     * on its `{\\rtf1` signature, arrived as type "docx" with no extension, and
+     * fell through to the Word processor, which cannot read RTF — so a file whose
+     * dedicated processor extracts it perfectly reported "Could not extract
+     * content". The extension was known the whole time; it was simply dropped on
+     * the way through.
+     *
+     * Only fills a gap — a strategy that did determine an extension keeps it, so
+     * content still wins over a lying filename.
+     */
+    private static withResolvedExtension;
     /**
      * Load file content from various sources
      */

package/dist/lib/utils/fileDetector.js

@@ -290,6 +290,13 @@ export class FileDetector {
     // These default ensure consistent timeout behavior across all file-detection logic.
     static DEFAULT_NETWORK_TIMEOUT = 30000; // 30 seconds
     static DEFAULT_HEAD_TIMEOUT = 5000; // 5 seconds
+    /**
+     * Ceiling on an in-process document parse (unzip + XML walk). Generous
+     * relative to the work, because the cost of firing early on a large but
+     * legitimate file is a lost extraction, while the cost of never firing is a
+     * held request.
+     */
+    static DEFAULT_DOCUMENT_TIMEOUT = 30000; // 30 seconds
     /**
      * Auto-detect file type and process in one call
      *
@@ -404,7 +411,14 @@ export class FileDetector {
         if (Buffer.isBuffer(input)) {
             return "buffer";
         }
-        return "unknown-input";
+        // Everything left is a `FileWithMetadata`, which states its own name, and
+        // `withResolvedExtension` reads this to recover an extension when a
+        // content-based strategy reported none. Falling straight through to
+        // "unknown-input" threw that name away, so an `.odp`, `.rtf` or `.tar`
+        // supplied as bytes-plus-name lost the extension its processor routes on.
+        // Still defensive about the value: the type says required, callers are
+        // untyped JavaScript often enough.
+        return input?.filename || "unknown-input";
     }
     /**
      * Derive byte size from FileInput for tracing.
@@ -661,7 +675,7 @@ export class FileDetector {
                     source: FileDetector.deriveInputSource(input),
                     metadata: {
                         confidence: 95,
-                        filename: FileDetector.deriveInputFilename(input),
+                        filename: options?.filenameHint || FileDetector.deriveInputFilename(input),
                         size: FileDetector.deriveInputSize(input),
                     },
                 };
@@ -684,13 +698,68 @@ export class FileDetector {
             }
             if (result.metadata.confidence >= confidenceThreshold) {
                 logger.info(`[FileDetector] Type: ${result.type} (${result.metadata.confidence}%)`);
-                return result;
+                return FileDetector.withResolvedExtension(result, input, options);
             }
         }
         // Below-threshold detection is the common case for any file under the
         // ContentHeuristic ceiling — a debug detail, not a warning-worthy anomaly.
         logger.debug(`[FileDetector] Best-effort type below threshold: ${best?.type ?? "unknown"} (${best?.metadata.confidence ?? 0}%, threshold ${confidenceThreshold}%)`);
-        return best;
+        return FileDetector.withResolvedExtension(best, input, options);
+    }
+    /**
+     * Fill in `extension` from the input's name when detection did not set it.
+     *
+     * Content-based strategies identify a type from magic bytes and legitimately
+     * have no extension to report, so they return null. That is fine for the type
+     * itself but not for routing: several processors are chosen by extension
+     * *after* detection has settled the type, because one routing type covers
+     * several formats — `docx` covers .docx, .odt and .rtf.
+     *
+     * With a null extension those branches were unreachable. An .rtf scored high
+     * on its `{\\rtf1` signature, arrived as type "docx" with no extension, and
+     * fell through to the Word processor, which cannot read RTF — so a file whose
+     * dedicated processor extracts it perfectly reported "Could not extract
+     * content". The extension was known the whole time; it was simply dropped on
+     * the way through.
+     *
+     * Only fills a gap — a strategy that did determine an extension keeps it, so
+     * content still wins over a lying filename.
+     */
+    static withResolvedExtension(result, input, options) {
+        if (!result) {
+            return result;
+        }
+        // The caller's hint outranks a name derived from the input, because on the
+        // unified path the input has already been unwrapped to a bare Buffer and
+        // derives to the literal "buffer" — carrying no extension at all.
+        const filename = options?.filenameHint ||
+            result.metadata?.filename ||
+            FileDetector.deriveInputFilename(input);
+        if (!filename) {
+            return result;
+        }
+        // Split on both separators so a Windows-style path on a POSIX host still
+        // yields its basename, then take the final suffix.
+        const base = filename.split(/[\\/]/).pop() ?? filename;
+        const dot = base.lastIndexOf(".");
+        const extension = result.extension ??
+            (dot > 0 && dot < base.length - 1
+                ? base.slice(dot + 1).toLowerCase()
+                : null);
+        // The name is carried alongside the extension for the same reason. A
+        // content strategy reports no filename, so every processor keyed on one
+        // received the literal fallback "archive" — and archive format detection
+        // reads the name, because TAR has no magic bytes at offset 0 (its "ustar"
+        // marker sits at byte 257). A .tar therefore arrived as an unidentifiable
+        // archive and reported "Could not extract content", while the same bytes
+        // handed to the processor WITH their name extract perfectly.
+        const metadata = result.metadata && !result.metadata.filename
+            ? { ...result.metadata, filename: base }
+            : result.metadata;
+        if (extension === result.extension && metadata === result.metadata) {
+            return result;
+        }
+        return { ...result, extension, metadata };
     }
     /**
      * Load file content from various sources
@@ -1343,6 +1412,40 @@ export class FileDetector {
     static async processPptxFile(content, detection) {
         const pptxFilename = detection.metadata.filename || "presentation";
         try {
+            // ODP is an OpenDocument package, not OOXML — the PPTX reader finds no
+            // ppt/slides parts in it and returns nothing. It reaches this branch at
+            // all because one routing type ("pptx") covers every presentation
+            // format, the same way "docx" covers .odt.
+            if (detection.extension?.toLowerCase() === "odp") {
+                const { openDocumentProcessor } = await import("../processors/document/OpenDocumentProcessor.js");
+                // Bounded per the project's async-timeout guideline: this unzips and
+                // parses attacker-supplied bytes, and a stalled parse would otherwise
+                // hold the request open with no ceiling. On timeout the throw lands in
+                // this block's existing catch, which degrades to the placeholder.
+                const odpResult = await withTimeout(openDocumentProcessor.processFile({
+                    id: pptxFilename,
+                    name: pptxFilename,
+                    mimetype: detection.mimeType ||
+                        "application/vnd.oasis.opendocument.presentation",
+                    size: content.length,
+                    buffer: content,
+                }), FileDetector.DEFAULT_DOCUMENT_TIMEOUT);
+                // Gated on success rather than on text, because a presentation of
+                // nothing but images is a legitimate ODP that extracts to an empty
+                // string. Requiring text sent that file on to the PPTX reader, which
+                // cannot read OpenDocument at all — so a successful extraction was
+                // discarded in favour of a guaranteed failure. Matches how the ODT and
+                // ODS branches degrade.
+                if (odpResult.success && odpResult.data) {
+                    return {
+                        type: "pptx",
+                        content: odpResult.data.textContent ||
+                            FileDetector.formatInformativePlaceholder("Presentation", pptxFilename, content, detection),
+                        mimeType: detection.mimeType,
+                        metadata: detection.metadata,
+                    };
+                }
+            }
             const { PptxProcessor } = await import("../processors/document/PptxProcessor.js");
             const pptxResult = await PptxProcessor.extractText(content);
             if (pptxResult) {
@@ -2003,13 +2106,33 @@ class MagicBytesStrategy {
         if (input.length >= 6 && input.toString("latin1", 0, 5) === "#!AMR") {
             return this.result("audio", "audio/amr", 95);
         }
-        // JPEG 2000: 12-byte signature box.
-        if (input.length >= 8 &&
+        // JPEG 2000: the full 12-byte signature box, trailing 0D 0A 87 0A
+        // included. Those four bytes are a deliberate line-ending probe — CR LF, a
+        // high byte, LF — that any transfer which mangles newlines or strips the
+        // eighth bit will visibly corrupt, so checking only the length and brand
+        // accepts exactly the damaged files the signature exists to reject.
+        if (input.length >= 12 &&
             input[0] === 0x00 &&
             input[1] === 0x00 &&
             input[2] === 0x00 &&
             input[3] === 0x0c &&
-            input.toString("latin1", 4, 8) === "jP  ") {
+            input.toString("latin1", 4, 8) === "jP  " &&
+            input[8] === 0x0d &&
+            input[9] === 0x0a &&
+            input[10] === 0x87 &&
+            input[11] === 0x0a) {
+            return this.result("image", "image/jp2", 95);
+        }
+        // The other shape JPEG 2000 ships in: a bare codestream (.j2k/.j2c) opening
+        // with the SOC + SIZ markers. `ImageProcessor.detectImageType` learned both
+        // shapes; this strategy knew only the container, so a codestream uploaded
+        // as bytes-plus-filename was typed "unknown" and delivered as a binary
+        // blob — the codestream branch over there was unreachable from this path.
+        if (input.length >= 4 &&
+            input[0] === 0xff &&
+            input[1] === 0x4f &&
+            input[2] === 0xff &&
+            input[3] === 0x51) {
             return this.result("image", "image/jp2", 95);
         }
         // MP3: ID3 tag

package/dist/lib/utils/imageProcessor.js

@@ -468,6 +468,37 @@ export class ImageProcessor {
                 if (isoBmffMimeType) {
                     return isoBmffMimeType;
                 }
+                // JPEG 2000, in both shapes it ships in. The JP2 container opens with
+                // the 12-byte signature box `00 00 00 0C 6A 50 20 20 0D 0A 87 0A`; a
+                // bare codestream (.j2k/.j2c) opens with the SOC+SIZ markers FF 4F FF
+                // 51. Checked BEFORE ICO because the container's first three bytes are
+                // 00 00 00, which is one byte away from ICO's 00 00 01 00 and shares
+                // its leading zeros — an ordering mistake here would classify every
+                // JPEG 2000 as an icon rather than merely failing to recognise it.
+                // All twelve bytes are checked, not just the length and brand: the
+                // trailing 0D 0A 87 0A is the signature's whole point. It is a
+                // line-ending probe — CR LF, a high byte, LF — that a transfer which
+                // mangles newlines or strips the eighth bit will visibly corrupt, so
+                // skipping it accepts exactly the damaged files it exists to reject.
+                if (input.length >= 12 &&
+                    input[0] === 0x00 &&
+                    input[1] === 0x00 &&
+                    input[2] === 0x00 &&
+                    input[3] === 0x0c &&
+                    input.subarray(4, 8).toString("latin1") === "jP  " &&
+                    input[8] === 0x0d &&
+                    input[9] === 0x0a &&
+                    input[10] === 0x87 &&
+                    input[11] === 0x0a) {
+                    return "image/jp2";
+                }
+                if (input.length >= 4 &&
+                    input[0] === 0xff &&
+                    input[1] === 0x4f &&
+                    input[2] === 0xff &&
+                    input[3] === 0x51) {
+                    return "image/jp2";
+                }
                 // ICO: 00 00 01 00 (icon type=1)
                 if (input[0] === 0x00 &&
                     input[1] === 0x00 &&

package/dist/lib/utils/messageBuilder.d.ts

@@ -37,15 +37,6 @@ export declare function mergeMediaFileAliases<TFile>(input: {
     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.
- *
- * Exported so providers that bypass BaseProvider.generate() (e.g.
- * GoogleVertex's native @google/genai path) can still preprocess
- * `input.files` — without this, mimetype-hint and text-file inputs
- * would silently never reach the model on those paths.
- */
 export declare function processUnifiedFilesArray(options: GenerateOptions, maxSize: number, provider: string): Promise<void>;
 /**
  * Build multimodal message array with image support