@juspay/neurolink 10.12.2 → 10.12.4

package/dist/processors/base/BaseFileProcessor.js

@@ -52,6 +52,30 @@ import { tracers } from "../../telemetry/tracers.js";
 import { createFileError, extractHttpStatus, FileErrorCode, isRetryableError, } from "../errors/index.js";
 import { DEFAULT_RETRY_CONFIG } from "../../types/index.js";
 const gunzipAsync = promisify(gunzip);
+/**
+ * Marker on the error raised when a download is refused for exceeding the
+ * processor's size limit.
+ *
+ * A code rather than a message match, for two reasons. `classifyDownloadError`
+ * can then report FILE_TOO_LARGE — the same verdict the post-download check
+ * gave, so refusing earlier does not quietly downgrade the error a caller
+ * sees to DOWNLOAD_FAILED. And `isRetryableError` decides from text; a bound
+ * that fires is not a transient fault, and re-fetching a file that will be
+ * exactly as oversized next time is the one thing worth not doing three times.
+ */
+const DOWNLOAD_TOO_LARGE_CODE = "DOWNLOAD_TOO_LARGE";
+function downloadTooLargeError(maxSizeMB, typeName) {
+    const error = new Error(`Download exceeds the maximum size of ${maxSizeMB} MB for ${typeName}`);
+    error.code = DOWNLOAD_TOO_LARGE_CODE;
+    return error;
+}
+function isDownloadTooLarge(error) {
+    return (error?.code === DOWNLOAD_TOO_LARGE_CODE);
+}
+/** Node's signal that a zlib output bound was reached. */
+function isBufferTooLargeError(error) {
+    return (error?.code === "ERR_BUFFER_TOO_LARGE");
+}
 /**
  * Abstract base class for file processors.
  * Provides common download, validation, and error handling functionality.
@@ -389,8 +413,8 @@ export class BaseFileProcessor {
             if (contentType && contentType.includes("text/html")) {
                 throw new Error(`Received HTML response instead of file content (Content-Type: ${contentType}). This usually means the download URL returned an error page.`);
             }
-            const arrayBuffer = await response.arrayBuffer();
-            let buffer = Buffer.from(arrayBuffer);
+            const maxBytes = this.config.maxSizeMB * 1024 * 1024;
+            let buffer = await this.readBodyWithinLimit(response, maxBytes);
             // Check for gzip encoding and decompress if needed
             // Only decompress if the data actually starts with gzip magic bytes (0x1f 0x8b)
             const contentEncoding = response.headers.get("Content-Encoding");
@@ -398,9 +422,16 @@ export class BaseFileProcessor {
             if (contentEncoding?.toLowerCase().includes("gzip") &&
                 isActuallyGzipped) {
                 try {
-                    buffer = Buffer.from(await gunzipAsync(buffer));
+                    // Bounded at the decoder. The size check that runs after the download
+                    // only ever sees what already fits in memory, so a few KB of gzip
+                    // declaring gigabytes was inflated in full before anything objected —
+                    // the response passed the "is it small" test on its way in.
+                    buffer = Buffer.from(await gunzipAsync(buffer, { maxOutputLength: maxBytes }));
                 }
                 catch (gzipError) {
+                    if (isBufferTooLargeError(gzipError)) {
+                        throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+                    }
                     throw new Error(`Failed to decompress gzip response: ${gzipError instanceof Error ? gzipError.message : String(gzipError)}`, { cause: gzipError });
                 }
             }
@@ -408,7 +439,68 @@ export class BaseFileProcessor {
         }
         finally {
             clearTimeout(timeoutId);
+            // Release the connection on every early exit. Rejecting a response for
+            // its status or its Content-Type leaves the body unread, which keeps the
+            // socket out of the pool until the response is garbage-collected. After
+            // a successful read there is nothing left in flight, so this is a no-op.
+            controller.abort();
+        }
+    }
+    /**
+     * Read a response body, refusing it the moment it passes `maxBytes`.
+     *
+     * `response.arrayBuffer()` buffers whatever the server sends before anyone
+     * can object, so the size check further up only ever ran against a body that
+     * had already been paid for in full. Metering the stream makes the ceiling
+     * the configured limit instead of the server's choice, and cancelling the
+     * reader stops the transfer rather than merely stopping our interest in it.
+     *
+     * Content-Length is deliberately not trusted as the bound — it is a hint that
+     * can be absent or a lie — but it is worth honouring when present, because it
+     * refuses the honest oversized case without reading a byte.
+     *
+     * @param response - Fetch response whose body should be read
+     * @param maxBytes - Ceiling for the body, in bytes
+     * @returns The body as a Buffer
+     * @throws When the body exceeds `maxBytes`
+     */
+    async readBodyWithinLimit(response, maxBytes) {
+        const declared = Number(response.headers.get("Content-Length"));
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            // Release the socket. An unread body keeps the connection out of the
+            // pool until the response is collected, so a run of oversized downloads
+            // would hold one socket open each.
+            await response.body?.cancel();
+            throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+        }
+        // Some responses carry no readable stream (mocked fetch, polyfills). The
+        // buffered read is the fallback, still checked — just after the fact.
+        if (!response.body) {
+            const buffered = Buffer.from(await response.arrayBuffer());
+            if (buffered.length > maxBytes) {
+                throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+            }
+            return buffered;
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let total = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (!value) {
+                continue;
+            }
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+            }
+            chunks.push(Buffer.from(value));
         }
+        return Buffer.concat(chunks, total);
     }
     /**
      * Download file with retry logic for transient failures.
@@ -559,6 +651,15 @@ export class BaseFileProcessor {
      * @returns Structured file processing error
      */
     classifyDownloadError(error) {
+        // Refusing an oversized body mid-stream is the same verdict the old
+        // post-download check gave, so it must carry the same code — otherwise
+        // bounding the read earlier would silently reclassify a familiar error.
+        if (isDownloadTooLarge(error)) {
+            return this.createError(FileErrorCode.FILE_TOO_LARGE, {
+                maxMB: this.config.maxSizeMB,
+                type: this.config.fileTypeName,
+            }, error);
+        }
         if (isAbortError(error)) {
             return this.createError(FileErrorCode.DOWNLOAD_TIMEOUT, { timeoutMs: this.config.timeoutMs }, error);
         }

package/dist/types/processor.d.ts

@@ -761,6 +761,29 @@ export type ArchiveDecompressionResult = {
 } | {
     readonly status: "failed";
 };
+/**
+ * Outcome of reading one ZIP entry under an explicit output bound.
+ *
+ * Separate from {@link ArchiveDecompressionResult} because the failures differ:
+ * a single-stream archive can fail for want of an external tool, while a ZIP
+ * entry can instead use a compression method this reader does not implement.
+ * Collapsing them would force one caller to handle a state it can never see.
+ *
+ * `too-large` is a distinct outcome rather than a corrupt-file error because it
+ * is a verdict about our limit, not about the archive: the entry may be
+ * perfectly well-formed, and telling the user it is damaged would send them to
+ * re-create a file that was never broken.
+ */
+export type ArchiveEntryReadResult = {
+    readonly status: "ok";
+    readonly buffer: Buffer;
+} | {
+    readonly status: "too-large";
+} | {
+    readonly status: "unsupported-method";
+} | {
+    readonly status: "corrupt";
+};
 /**
  * Metadata about an individual entry within an archive.
  */

package/dist/types/proxy.d.ts

@@ -1861,6 +1861,14 @@ export type UpdateCheckResult = {
     latestVersion: string;
     updateAvailable: boolean;
 };
+/** Result of one local proxy health probe by the updater or fail-open guard. */
+export type ProxyHealthProbe = {
+    healthy: boolean;
+    durationMs: number;
+    failure: "http_status" | "network" | "timeout" | null;
+    statusCode: number | null;
+    errorCode: string | null;
+};
 /** Parsed major.minor.patch components of a semver string. */
 export type SemVer = {
     major: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.12.2",
+  "version": "10.12.4",
   "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": {
@@ -163,7 +163,7 @@
     "test:system-messages": "npx tsx test/continuous-test-suite-system-messages.ts",
     "test:test-stubs": "npx tsx test/continuous-test-suite-test-stubs.ts",
     "test:tool-routing-semantic": "npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:proxy-usage-refresh && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:proxy-usage-refresh && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding && pnpm run test:archive:security",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",
@@ -245,7 +245,8 @@
     "test:sampling-params": "npx tsx test/continuous-test-suite-sampling-params.ts",
     "test:structured-recovery": "npx tsx test/continuous-test-suite-structured-recovery.ts",
     "test:prompt-redaction": "npx tsx test/continuous-test-suite-prompt-redaction.ts",
-    "test:mcp-result-cache": "npx tsx test/continuous-test-suite-mcp-result-cache.ts"
+    "test:mcp-result-cache": "npx tsx test/continuous-test-suite-mcp-result-cache.ts",
+    "test:archive:security": "npx tsx test/continuous-test-suite-archive-security.ts"
   },
   "files": [
     "dist",