@juspay/neurolink 10.11.2 → 10.11.3

package/dist/processors/archive/ArchiveProcessor.d.ts

@@ -193,6 +193,43 @@ export declare class ArchiveProcessor extends BaseFileProcessor<ProcessedArchive
      * @param entries - Previously extracted entry metadata
      * @returns Map of entry name to extracted text content
      */
+    /**
+     * Whether an entry name looks like something worth inlining as text.
+     *
+     * Shared by the ZIP and TAR paths so the two cannot drift into disagreeing
+     * about which members are worth reading — they did, because only ZIP had the
+     * rule at all.
+     */
+    private isExtractableEntryName;
+    /**
+     * Decode bytes to text, or null when they are not text.
+     *
+     * A NUL byte in the first 512 bytes, or a high proportion of replacement
+     * characters after decoding, means binary — inlining that would spend the
+     * extraction budget on mojibake.
+     */
+    private decodeEntryText;
+    /**
+     * Decompress a single-stream archive (.bz2, .xz, .zst).
+     *
+     * Node ships zstd from v22.15/23, so that one needs no help. bzip2 and xz
+     * have no Node binding, and adding a native module for them would make an
+     * optional format a build-time dependency for every consumer — so the system
+     * tools are used when present, the same soft-dependency arrangement this
+     * codebase already has with ffmpeg. Absent tooling returns null and the
+     * caller reports the format as unsupported *on this machine* rather than
+     * unsupported in principle.
+     */
+    private decompressSingleStream;
+    /**
+     * Extract a single-stream archive: decompress, then treat the result as a
+     * TAR when it is one and as a lone file otherwise.
+     *
+     * The tar check matters because `.tar.xz` and `.tar.zst` are how these
+     * formats are usually met — reporting one opaque "decompressed-content" blob
+     * for an archive of forty files would be technically true and useless.
+     */
+    private extractSingleStreamEntries;
     private extractEntryContents;
     /**
      * Build a structured text description of the archive for LLM consumption.

package/dist/processors/archive/ArchiveProcessor.js

@@ -143,10 +143,27 @@ const SUPPORTED_ARCHIVE_MIME_TYPES = [
     "application/x-gzip",
     "application/x-compressed-tar",
     "application/x-bzip2",
+    // XZ and Zstandard, added alongside the extensions above: a caller that
+    // uploads bytes with a declared mimetype and no filename was rejected at the
+    // type gate for the two formats this change teaches the processor to read.
+    "application/x-xz",
+    "application/zstd",
     "application/java-archive",
 ];
+/**
+ * External decompressor per single-stream format.
+ *
+ * One map rather than a ternary repeated at each use: the decompressor and the
+ * error message that names it were derived separately, so they could disagree
+ * about which binary the user is being told to install.
+ */
+const SINGLE_STREAM_TOOLS = {
+    bz2: "bzip2",
+    xz: "xz",
+    zst: "zstd",
+};
 /** File extensions recognized as archive formats */
-const SUPPORTED_ARCHIVE_EXTENSIONS = [".zip", ".tar", ".gz", ".tgz", ".bz2", ".tbz2", ".jar"];
+const SUPPORTED_ARCHIVE_EXTENSIONS = [".zip", ".tar", ".gz", ".tgz", ".bz2", ".tbz2", ".jar", ".xz", ".txz", ".zst", ".tzst"];
 // =============================================================================
 // MAGIC BYTE SIGNATURES
 // =============================================================================
@@ -163,8 +180,20 @@ const MAGIC_BYTES = {
     ZIP_SPANNED: [0x50, 0x4b, 0x07, 0x08],
     /** GZIP: \x1f\x8b */
     GZIP: [0x1f, 0x8b],
-    /** BZIP2: BZ */
-    BZIP2: [0x42, 0x5a],
+    /**
+     * BZIP2: `BZh` — all three bytes, not just `BZ`.
+     *
+     * Two bytes was harmless while every BZIP2 match was rejected outright as an
+     * unsupported format. Now that a match actually spawns `bzip2`, any buffer
+     * beginning with the ASCII letters "BZ" is handed to the decompressor and
+     * comes back reported as a corrupt BZ2 stream — a confident wrong answer
+     * about a file that was never bzip2 at all.
+     */
+    BZIP2: [0x42, 0x5a, 0x68],
+    /** XZ: \xfd7zXZ\x00 */
+    XZ: [0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00],
+    /** Zstandard frame: \x28\xb5\x2f\xfd */
+    ZSTD: [0x28, 0xb5, 0x2f, 0xfd],
     /** RAR: Rar!\x1a\x07 */
     RAR: [0x52, 0x61, 0x72, 0x21, 0x1a, 0x07],
     /** 7-Zip: 7z\xbc\xaf\x27\x1c */
@@ -315,7 +344,7 @@ export class ArchiveProcessor extends BaseFileProcessor {
                     error: this.createError(FileErrorCode.UNSUPPORTED_TYPE, {
                         format,
                         reason: `${format.toUpperCase()} archives are not yet supported. Please convert to ZIP or TAR format.`,
-                        supportedFormats: "ZIP, TAR, TAR.GZ, GZ",
+                        supportedFormats: "ZIP, TAR, TAR.GZ, TAR.BZ2, GZ, BZ2, XZ, ZST, JAR",
                     }),
                 };
             }
@@ -356,7 +385,9 @@ export class ArchiveProcessor extends BaseFileProcessor {
             // Step 9: Extract content from text-based entries (Phase 2 sub-processing)
             // For ZIP archives, extract and include content from small text-based files.
             // Skips nested archives and binary files for safety.
-            let extractedContents = new Map();
+            // ZIP re-parses to pull member text; every other format collects it while
+            // decompressing, because their bytes stream past exactly once.
+            let extractedContents = extractionResult.contents ?? new Map();
             if (format === "zip") {
                 extractedContents = await this.extractEntryContents(buffer, entries);
             }
@@ -417,6 +448,18 @@ export class ArchiveProcessor extends BaseFileProcessor {
                 // Could still be a tar.gz without the extension - we'll detect during extraction
                 return "gz";
             }
+            // Bzip2 wraps a tar just as often, and now that a BZIP2 magic match
+            // resolves to a real format rather than being rejected outright, the
+            // same filename check has to run here too. Without it every genuine
+            // `.tar.bz2` reported its format as "BZ2" to the model — extraction was
+            // right, the label was not — and the `.tar.bz2` extension mapping below
+            // became unreachable for any well-formed file.
+            if (magicFormat === "bz2") {
+                const ext = filename.toLowerCase();
+                return ext.endsWith(".tar.bz2") || ext.endsWith(".tbz2")
+                    ? "tar.bz2"
+                    : "bz2";
+            }
             return magicFormat;
         }
         // Fallback to extension-based detection
@@ -451,9 +494,19 @@ export class ArchiveProcessor extends BaseFileProcessor {
         if (this.matchesMagic(buffer, MAGIC_BYTES.GZIP)) {
             return "gz";
         }
-        // Check for BZIP2 (2 bytes)
+        // Check for BZIP2 (3 bytes: "BZh"). A bare .bz2 is a single compressed
+        // file; the caller decides whether the decompressed bytes turn out to be a
+        // tar.
         if (this.matchesMagic(buffer, MAGIC_BYTES.BZIP2)) {
-            return "tar.bz2";
+            return "bz2";
+        }
+        // Check for XZ (6 bytes)
+        if (buffer.length >= 6 && this.matchesMagic(buffer, MAGIC_BYTES.XZ)) {
+            return "xz";
+        }
+        // Check for Zstandard (4 bytes)
+        if (buffer.length >= 4 && this.matchesMagic(buffer, MAGIC_BYTES.ZSTD)) {
+            return "zst";
         }
         return null;
     }
@@ -478,7 +531,21 @@ export class ArchiveProcessor extends BaseFileProcessor {
             return "gz";
         }
         if (lowerFilename.endsWith(".bz2")) {
-            return "tar.bz2";
+            // A bare `.bz2` is a single compressed file, not a tarball. Reporting it
+            // as "tar.bz2" sent it down a branch that refused the format outright.
+            return "bz2";
+        }
+        if (lowerFilename.endsWith(".tar.xz") || lowerFilename.endsWith(".txz")) {
+            return "xz";
+        }
+        if (lowerFilename.endsWith(".xz")) {
+            return "xz";
+        }
+        if (lowerFilename.endsWith(".tar.zst") || lowerFilename.endsWith(".tzst")) {
+            return "zst";
+        }
+        if (lowerFilename.endsWith(".zst")) {
+            return "zst";
         }
         if (lowerFilename.endsWith(".zip") || lowerFilename.endsWith(".jar")) {
             return "zip";
@@ -526,16 +593,12 @@ export class ArchiveProcessor extends BaseFileProcessor {
             case "tar.gz":
                 return this.extractTarGzEntries(buffer);
             case "tar.bz2":
-                return {
-                    success: false,
-                    entries: [],
-                    securityWarnings: [],
-                    error: this.createError(FileErrorCode.UNSUPPORTED_TYPE, {
-                        format: "tar.bz2",
-                        reason: "TAR.BZ2 archives are not yet supported. Please convert to ZIP or TAR.GZ format.",
-                        supportedFormats: "ZIP, TAR, TAR.GZ, GZ",
-                    }),
-                };
+            case "bz2":
+                return this.extractSingleStreamEntries(buffer, "bz2");
+            case "xz":
+                return this.extractSingleStreamEntries(buffer, "xz");
+            case "zst":
+                return this.extractSingleStreamEntries(buffer, "zst");
             case "gz":
                 return this.extractGzEntries(buffer);
             default:
@@ -546,7 +609,7 @@ export class ArchiveProcessor extends BaseFileProcessor {
                     error: this.createError(FileErrorCode.UNSUPPORTED_TYPE, {
                         format,
                         reason: `${format} archives are not supported`,
-                        supportedFormats: "ZIP, TAR, TAR.GZ, GZ",
+                        supportedFormats: "ZIP, TAR, TAR.GZ, TAR.BZ2, GZ, BZ2, XZ, ZST, JAR",
                     }),
                 };
         }
@@ -767,8 +830,10 @@ export class ArchiveProcessor extends BaseFileProcessor {
         return new Promise((resolve) => {
             const entries = [];
             const securityWarnings = [];
+            const contents = new Map();
             let entryCount = 0;
             let cumulativeSize = 0;
+            let extractedBytes = 0;
             let earlyError = null;
             const extract = tarStream.extract();
             extract.on("entry", (header, stream, next) => {
@@ -827,6 +892,33 @@ export class ArchiveProcessor extends BaseFileProcessor {
                     compressedSize: 0, // TAR doesn't compress individual entries
                     isDirectory,
                 });
+                // Capture the text of eligible members as they go past.
+                //
+                // A listing alone is not an answer. Asked what a .tar contains, the
+                // model could previously only recite filenames and sizes — the same
+                // archive as a .zip returned its text, because only the ZIP path
+                // extracted anything. A tar entry's bytes are available exactly once,
+                // here, while the stream is open; re-reading later would mean parsing
+                // the whole archive a second time.
+                if (!isDirectory &&
+                    this.isExtractableEntryName(entryName) &&
+                    entrySize > 0 &&
+                    entrySize <= ARCHIVE_CONFIG.MAX_EXTRACT_ENTRY_SIZE &&
+                    contents.size < ARCHIVE_CONFIG.MAX_EXTRACT_ENTRIES &&
+                    extractedBytes + entrySize <= ARCHIVE_CONFIG.MAX_TOTAL_EXTRACT_SIZE) {
+                    const chunks = [];
+                    stream.on("data", (chunk) => chunks.push(chunk));
+                    stream.on("end", () => {
+                        const text = this.decodeEntryText(Buffer.concat(chunks));
+                        if (text !== null) {
+                            contents.set(entryName, text);
+                            extractedBytes += entrySize;
+                        }
+                        next();
+                    });
+                    stream.on("error", () => next());
+                    return;
+                }
                 // Consume the stream without buffering (we only need metadata)
                 stream.resume();
                 next();
@@ -841,7 +933,7 @@ export class ArchiveProcessor extends BaseFileProcessor {
                     });
                 }
                 else {
-                    resolve({ success: true, entries, securityWarnings });
+                    resolve({ success: true, entries, securityWarnings, contents });
                 }
             });
             extract.on("error", (err) => {
@@ -929,7 +1021,14 @@ export class ArchiveProcessor extends BaseFileProcessor {
                     isDirectory: false,
                 },
             ];
-            return { success: true, entries, securityWarnings };
+            // The decompressed bytes ARE the content here; a listing that says
+            // "decompressed-content (1.02 MB)" answers nothing about the file.
+            const contents = new Map();
+            const gzText = this.decodeEntryText(decompressed);
+            if (gzText !== null) {
+                contents.set(innerFilename, gzText.slice(0, ARCHIVE_CONFIG.MAX_EXTRACT_ENTRY_SIZE));
+            }
+            return { success: true, entries, securityWarnings, contents };
         }
         catch (error) {
             return {
@@ -999,6 +1098,232 @@ export class ArchiveProcessor extends BaseFileProcessor {
      * @param entries - Previously extracted entry metadata
      * @returns Map of entry name to extracted text content
      */
+    /**
+     * Whether an entry name looks like something worth inlining as text.
+     *
+     * Shared by the ZIP and TAR paths so the two cannot drift into disagreeing
+     * about which members are worth reading — they did, because only ZIP had the
+     * rule at all.
+     */
+    isExtractableEntryName(name) {
+        const ext = path.extname(name).toLowerCase();
+        if (ARCHIVE_CONFIG.EXTRACTABLE_EXTENSIONS.has(ext)) {
+            return true;
+        }
+        const base = path.basename(name).toLowerCase();
+        return (base === "readme" ||
+            base === "license" ||
+            base === "makefile" ||
+            base === "dockerfile");
+    }
+    /**
+     * Decode bytes to text, or null when they are not text.
+     *
+     * A NUL byte in the first 512 bytes, or a high proportion of replacement
+     * characters after decoding, means binary — inlining that would spend the
+     * extraction budget on mojibake.
+     */
+    decodeEntryText(data) {
+        if (!data || data.length === 0) {
+            return null;
+        }
+        if (data.subarray(0, Math.min(512, data.length)).includes(0)) {
+            return null;
+        }
+        const text = data.toString("utf-8");
+        const replacements = (text.match(/\ufffd/g) || []).length;
+        return replacements > text.length * 0.05 ? null : text;
+    }
+    /**
+     * Decompress a single-stream archive (.bz2, .xz, .zst).
+     *
+     * Node ships zstd from v22.15/23, so that one needs no help. bzip2 and xz
+     * have no Node binding, and adding a native module for them would make an
+     * optional format a build-time dependency for every consumer — so the system
+     * tools are used when present, the same soft-dependency arrangement this
+     * codebase already has with ffmpeg. Absent tooling returns null and the
+     * caller reports the format as unsupported *on this machine* rather than
+     * unsupported in principle.
+     */
+    async decompressSingleStream(buffer, format) {
+        if (format === "zst") {
+            // Node gained zstd in v22.15/23. Older runtimes simply lack the export,
+            // so it is probed at runtime rather than assumed from the typings —
+            // which is also why this is a property check on an `unknown` module
+            // instead of a cast asserting it exists.
+            const zlibModule = await import("zlib");
+            const candidate = typeof zlibModule === "object" && zlibModule !== null
+                ? zlibModule.zstdDecompress
+                : undefined;
+            if (typeof candidate === "function") {
+                const zstdDecompress = candidate;
+                return await new Promise((resolve) => {
+                    // Bounded at the decoder rather than after the fact. The size guard
+                    // downstream only runs once the whole buffer exists, which is too
+                    // late for a zip-bomb: a few KB of zstd expands to gigabytes and the
+                    // allocation is what hurts. `maxOutputLength` makes it fail fast.
+                    zstdDecompress(buffer, { maxOutputLength: ARCHIVE_SECURITY.MAX_DECOMPRESSED_SIZE }, (err, res) => resolve(err
+                        ? {
+                            status: err.code ===
+                                "ERR_BUFFER_TOO_LARGE"
+                                ? "too-large"
+                                : "failed",
+                        }
+                        : { status: "ok", buffer: res }));
+                });
+            }
+        }
+        const tool = SINGLE_STREAM_TOOLS[format];
+        try {
+            const { execFile } = await import("node:child_process");
+            return await new Promise((resolve) => {
+                // ENOENT means the binary is absent; anything else means it ran and
+                // could not do the job. Only the former justifies telling the caller to
+                // install something.
+                //
+                // Read off the error itself rather than a flag set by the `error`
+                // listener below, because execFile invokes this callback BEFORE that
+                // listener runs — measured, not assumed:
+                //   callback(missing=false, code=ENOENT) → errorListener(code=ENOENT)
+                // The promise is already settled by the time the listener could set the
+                // flag, so a missing decompressor reported itself as a corrupt stream
+                // and told the user to re-upload a perfectly good file.
+                const isMissingTool = (error) => error?.code === "ENOENT";
+                // Hitting `maxBuffer` is the zip-bomb guard firing, not a corrupt
+                // stream: it will fail identically on every retry, so it must not be
+                // reported as retryable the way a truncated upload is.
+                const isTooLarge = (error) => error?.code ===
+                    "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+                const child = execFile(tool, ["-dc"], {
+                    encoding: "buffer",
+                    maxBuffer: ARCHIVE_SECURITY.MAX_DECOMPRESSED_SIZE,
+                    // Without this a crafted or truncated stream that makes the tool
+                    // block forever never fires the callback, so the promise never
+                    // settles and the request that awaits it hangs indefinitely.
+                    timeout: ARCHIVE_CONFIG.TIMEOUT_MS,
+                }, (error, stdout) => {
+                    // Only a non-zero exit means failure. Empty output does not:
+                    // compressing an empty file is legal and round-trips — a 32-byte
+                    // `empty.txt.xz` decompresses to nothing with exit 0 — so treating
+                    // zero length as an error reported a valid archive as corrupt. The
+                    // in-process zstd path above already keyed on the error alone, so
+                    // the two backends disagreed about the same input.
+                    if (error || !stdout) {
+                        resolve({
+                            status: isMissingTool(error)
+                                ? "tool-unavailable"
+                                : isTooLarge(error)
+                                    ? "too-large"
+                                    : "failed",
+                        });
+                        return;
+                    }
+                    resolve({ status: "ok", buffer: Buffer.from(stdout) });
+                });
+                // Kept as a backstop for spawn failures that never reach the
+                // callback. Whichever settles first wins; both now classify the same
+                // way, so the outcome no longer depends on the order.
+                child.on("error", (error) => {
+                    resolve({
+                        status: isMissingTool(error) ? "tool-unavailable" : "failed",
+                    });
+                });
+                // Swallowed, deliberately not resolved from. A stdin write fails with
+                // EPIPE precisely because the child already died — including when Node
+                // killed it for exceeding `maxBuffer`, which is the zip-bomb guard.
+                // Resolving here raced the exec callback and, when it won, downgraded a
+                // "too-large" verdict to a retryable "failed", telling the caller to
+                // retry a bomb. The callback is the authoritative signal: it always
+                // fires once the process exits or fails to spawn, and the `timeout`
+                // above bounds the wait. This listener exists only so an unhandled
+                // 'error' event cannot take the process down.
+                child.stdin?.on("error", () => undefined);
+                child.stdin?.end(buffer);
+            });
+        }
+        catch {
+            return { status: "tool-unavailable" };
+        }
+    }
+    /**
+     * Extract a single-stream archive: decompress, then treat the result as a
+     * TAR when it is one and as a lone file otherwise.
+     *
+     * The tar check matters because `.tar.xz` and `.tar.zst` are how these
+     * formats are usually met — reporting one opaque "decompressed-content" blob
+     * for an archive of forty files would be technically true and useless.
+     */
+    async extractSingleStreamEntries(buffer, format) {
+        const result = await this.decompressSingleStream(buffer, format);
+        if (result.status !== "ok") {
+            const tool = SINGLE_STREAM_TOOLS[format];
+            // Three distinct outcomes, and the codes carry contracts a caller acts
+            // on. UNSUPPORTED_TYPE is `retryable: false` and advises converting the
+            // file; DECOMPRESSION_FAILED is `retryable: true` and advises
+            // re-uploading; SECURITY_VALIDATION_FAILED is how the GZIP and TAR.GZ
+            // paths in this file already report a decompression bomb. `retryable` is
+            // read downstream by `isRetryableErrorCode`, so a stream that tripped the
+            // decoder's size cap must not be advertised as worth retrying — it will
+            // fail identically every time — and a merely truncated upload must not be
+            // reported as an unsupported format.
+            const code = result.status === "tool-unavailable"
+                ? FileErrorCode.UNSUPPORTED_TYPE
+                : result.status === "too-large"
+                    ? FileErrorCode.SECURITY_VALIDATION_FAILED
+                    : FileErrorCode.DECOMPRESSION_FAILED;
+            return {
+                success: false,
+                entries: [],
+                securityWarnings: [],
+                error: this.createError(code, {
+                    format,
+                    reason: result.status === "tool-unavailable"
+                        ? `${format.toUpperCase()} could not be decompressed. Node has no built-in ` +
+                            `decoder for it and the "${tool}" command is unavailable on this machine.`
+                        : result.status === "too-large"
+                            ? `${format.toUpperCase()} expands beyond the ` +
+                                `${this.formatSizeMB(ARCHIVE_SECURITY.MAX_DECOMPRESSED_SIZE)} MB ` +
+                                `decompression limit and was refused before it could be read.`
+                            : `${format.toUpperCase()} could not be decompressed. The stream is ` +
+                                `corrupt or truncated.`,
+                    supportedFormats: "ZIP, TAR, TAR.GZ, TAR.BZ2, GZ, BZ2, XZ, ZST, JAR",
+                }),
+            };
+        }
+        const decompressed = result.buffer;
+        if (decompressed.length > ARCHIVE_SECURITY.MAX_DECOMPRESSED_SIZE) {
+            return {
+                success: false,
+                entries: [],
+                securityWarnings: [],
+                error: this.createError(FileErrorCode.SECURITY_VALIDATION_FAILED, {
+                    reason: `Decompressed size (${this.formatSizeMB(decompressed.length)} MB) exceeds limit (${this.formatSizeMB(ARCHIVE_SECURITY.MAX_DECOMPRESSED_SIZE)} MB)`,
+                }),
+            };
+        }
+        if (this.looksLikeTar(decompressed)) {
+            const tarStream = await import("tar-stream");
+            return await this.parseTarStream(tarStream, decompressed);
+        }
+        const contents = new Map();
+        const text = this.decodeEntryText(decompressed);
+        if (text !== null) {
+            contents.set("decompressed-content", text.slice(0, ARCHIVE_CONFIG.MAX_EXTRACT_ENTRY_SIZE));
+        }
+        return {
+            success: true,
+            entries: [
+                {
+                    name: "decompressed-content",
+                    uncompressedSize: decompressed.length,
+                    compressedSize: buffer.length,
+                    isDirectory: false,
+                },
+            ],
+            securityWarnings: [],
+            contents,
+        };
+    }
     async extractEntryContents(buffer, entries) {
         const contents = new Map();
         try {
@@ -1016,17 +1341,7 @@ export class ArchiveProcessor extends BaseFileProcessor {
                 if (e.uncompressedSize === 0) {
                     return false;
                 }
-                const ext = path.extname(e.name).toLowerCase();
-                // Check by extension
-                if (ARCHIVE_CONFIG.EXTRACTABLE_EXTENSIONS.has(ext)) {
-                    return true;
-                }
-                // Check for common extensionless config files
-                const basename = path.basename(e.name).toLowerCase();
-                if (basename === "readme" || basename === "license" || basename === "makefile" || basename === "dockerfile") {
-                    return true;
-                }
-                return false;
+                return this.isExtractableEntryName(e.name);
             })
                 // Sort: smaller files first (more likely to fit), then by name
                 .sort((a, b) => a.uncompressedSize - b.uncompressedSize);

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

@@ -30,6 +30,23 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      * Estimate token count from text using centralized estimation with provider multipliers
      */
     private estimateTokenCount;
+    /**
+     * Run the file preprocessing this provider's native paths depend on.
+     *
+     * AI Studio overrides both `generate()` and `executeStream()` and routes
+     * straight to the native SDK, so neither reaches
+     * `buildMultimodalMessagesArray` — the place that turns `input.files` into
+     * text, images, PDFs and `nativeAudioFiles`. `BaseProvider.stream()` does
+     * build messages, but onto a throwaway clone whose result is discarded, so
+     * the real `options.input` came through untouched.
+     *
+     * The consequence was asymmetric and easy to miss: `generate()` did this
+     * inline and worked, while `stream()` silently dropped every attached file —
+     * not just audio, but the metadata summary too. Vertex hit the identical bug
+     * (#1258) and solved it with exactly this shape, called from both entry
+     * points.
+     */
+    private preprocessNativeFileInput;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
      * Execute stream using native @google/genai SDK

package/dist/providers/googleAiStudio/client.js

@@ -1,7 +1,7 @@
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import { IMAGE_GENERATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../../core/constants.js";
-import { normalizeVisionImageFormats, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
+import { mergeMediaFileAliases, normalizeVisionImageFormats, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { ATTR, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../../telemetry/index.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
@@ -513,12 +513,55 @@ export class GoogleAIStudioProvider extends BaseProvider {
         return estimateTokens(text, "google-ai");
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
+    /**
+     * Run the file preprocessing this provider's native paths depend on.
+     *
+     * AI Studio overrides both `generate()` and `executeStream()` and routes
+     * straight to the native SDK, so neither reaches
+     * `buildMultimodalMessagesArray` — the place that turns `input.files` into
+     * text, images, PDFs and `nativeAudioFiles`. `BaseProvider.stream()` does
+     * build messages, but onto a throwaway clone whose result is discarded, so
+     * the real `options.input` came through untouched.
+     *
+     * The consequence was asymmetric and easy to miss: `generate()` did this
+     * inline and worked, while `stream()` silently dropped every attached file —
+     * not just audio, but the metadata summary too. Vertex hit the identical bug
+     * (#1258) and solved it with exactly this shape, called from both entry
+     * points.
+     */
+    async preprocessNativeFileInput(options) {
+        // The user-facing aliases (`input.audioFiles`, `input.videoFiles`) are
+        // folded into `input.files` here, exactly as the Vertex client does. Only
+        // `files` is processed below, so without this a caller who used the
+        // documented `audioFiles` field had it silently ignored on both of this
+        // provider's paths.
+        if (options.input) {
+            mergeMediaFileAliases(options.input);
+        }
+        if (options.input?.files && options.input.files.length > 0) {
+            try {
+                // Mutates options.input.text / .images / .pdfFiles / .nativeAudioFiles
+                // in place.
+                await processUnifiedFilesArray(options, 100 * 1024 * 1024, this.providerName);
+            }
+            catch (fileError) {
+                logger.warn(`[GoogleAIStudio] processUnifiedFilesArray threw, continuing without file content: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+            }
+        }
+        // Runs even without input.files: a caller can populate input.images
+        // directly, and this native path never reaches the shared multimodal
+        // builder that would otherwise normalize the formats.
+        await normalizeVisionImageFormats(options.input);
+    }
     async executeStream(options, analysisSchema) {
         const modelName = options.model || this.modelName;
         // Phase 1: if audio input present, bridge to Gemini Live (Studio) using @google/genai
         if (options.input?.audio) {
             return await this.executeAudioStreamViaGeminiLive(options);
         }
+        // #1258, for this provider: stream() must run the same file preprocessing
+        // generate() does, or attached files are dropped on this path alone.
+        await this.preprocessNativeFileInput(options);
         // Structured output (analysisSchema, JSON format, or schema) is incompatible with tools on Gemini.
         const wantsStructuredOutput = analysisSchema || options.output?.format === "json" || options.schema;
         // Tool filter (a0269210): trust options.tools — caller (BaseProvider.stream)
@@ -1171,24 +1214,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             logger.info("[GoogleAIStudio] Routing TTS direct-synthesis to handleDirectTTSSynthesis", { model: modelName });
             return this.handleDirectTTSSynthesis(options, Date.now());
         }
-        // Process the unified `input.files` array before routing to the
-        // native SDK. BaseProvider.generate() runs this preprocessing via
-        // buildMultimodalMessagesArray, but AI Studio'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(`[GoogleAIStudio] processUnifiedFilesArray threw, continuing without file content: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
-            }
-        }
-        // Runs even without input.files: a caller can populate input.images
-        // directly, and this native path never reaches the shared multimodal
-        // builder that would otherwise normalize the formats.
-        await normalizeVisionImageFormats(options.input);
+        await this.preprocessNativeFileInput(options);
         // Merge registered (built-in / MCP) tools with caller-supplied tools.
         // AI Studio's generate() bypasses BaseProvider.generate(), so the
         // ToolsManager-driven merge that normally injects sdk.registerTool()