@juspay/neurolink 12.14.19 → 12.14.21

package/dist/cli/commands/proxy.js

@@ -31,7 +31,7 @@ import { isProxyAuxiliaryRequest } from "../../proxy/proxyRequestKind.js";
 import { spawnProxySocketWorker } from "../../proxy/rollingWorkerProcess.js";
 import { PROXY_ROLLING_SUPERVISOR_ENV, PROXY_SOCKET_WORKER_ENV, } from "../../proxy/rollingWorkerProtocol.js";
 import { attachSocketWorkerProcess } from "../../proxy/socketWorkerRuntime.js";
-import { waitForProxyUpdateWindow } from "../../proxy/updateCoordinator.js";
+import { shouldRefreshStaleSupervisor, waitForProxyUpdateWindow, } from "../../proxy/updateCoordinator.js";
 import { abandonPendingUpdate, clearUpdateDeferral, isVersionSuppressed, loadUpdateState, recordCheck, recordSuccessfulUpdate, recordUpdateDeferred, recordUpdateFailure, recordUpdateInstalled, suppressVersion, } from "../../proxy/updateState.js";
 import { loadProxyEnvFile, resolveProxyEnvFile, } from "../../proxy/proxyEnv.js";
 import { createRequire } from "node:module";
@@ -3865,14 +3865,35 @@ export const proxyGuardCommand = {
                 let result = await checkForUpdate(runningVersion);
                 updateVersion = result.latestVersion;
                 persistUpdaterState("record update check", () => recordCheck(result.latestVersion));
+                let supervisorRefreshOnly = false;
                 if (!result.updateAvailable) {
-                    updateRetryAttempts = 0;
-                    updateRetryVersion = null;
-                    persistUpdaterState("clear update deferral", () => clearUpdateDeferral());
-                    return;
+                    const activeVersions = rollingSupervisor
+                        ? await fetchProxyRuntimeVersions(host, port).catch(() => ({}))
+                        : {};
+                    if (rollingSupervisor &&
+                        (!activeVersions.workerVersion || !activeVersions.supervisorVersion)) {
+                        logger.always(`[updater] WARNING: runtime version probe incomplete (worker=${activeVersions.workerVersion ?? "unknown"}, supervisor=${activeVersions.supervisorVersion ?? "unknown"}); stale-supervisor reconciliation deferred`);
+                        scheduleUpdateRetry("runtime version probe incomplete", result.latestVersion);
+                        return;
+                    }
+                    supervisorRefreshOnly = shouldRefreshStaleSupervisor({
+                        updateAvailable: result.updateAvailable,
+                        rollingSupervisor,
+                        runningVersion,
+                        workerVersion: activeVersions.workerVersion,
+                        supervisorVersion: activeVersions.supervisorVersion,
+                    });
+                    if (!supervisorRefreshOnly) {
+                        updateRetryAttempts = 0;
+                        updateRetryVersion = null;
+                        persistUpdaterState("clear update deferral", () => clearUpdateDeferral());
+                        return;
+                    }
+                    logger.always(`[updater] worker v${runningVersion} is current; reconciling stale supervisor v${activeVersions.supervisorVersion}`);
                 }
                 const initiallyPendingRestart = loadUpdateState()?.pendingRestartVersion === result.latestVersion;
-                if (isVersionSuppressed(result.latestVersion) &&
+                if (!supervisorRefreshOnly &&
+                    isVersionSuppressed(result.latestVersion) &&
                     !initiallyPendingRestart) {
                     logger.debug(`[guard] version ${result.latestVersion} is suppressed, skipping`);
                     return;
@@ -3932,26 +3953,30 @@ export const proxyGuardCommand = {
                         }
                     }
                 }
-                else {
+                else if (!supervisorRefreshOnly) {
                     logger.always(`[updater] rolling supervisor will keep v${runningVersion} serving during installation`);
                 }
                 // Refresh after waiting so a long deferral can never install a stale
                 // target while a newer release is already available.
-                const refreshedResult = await checkForUpdate(runningVersion);
-                result = refreshedResult;
-                updateVersion = result.latestVersion;
-                persistUpdaterState("record refreshed update check", () => recordCheck(result.latestVersion));
-                if (!result.updateAvailable) {
-                    persistUpdaterState("clear update deferral", () => clearUpdateDeferral());
-                    return;
-                }
-                const pendingRestart = loadUpdateState()?.pendingRestartVersion === result.latestVersion;
-                if (isVersionSuppressed(result.latestVersion) && !pendingRestart) {
-                    logger.debug(`[guard] refreshed version ${result.latestVersion} is suppressed, skipping`);
-                    return;
+                let pendingRestart = initiallyPendingRestart;
+                if (!supervisorRefreshOnly) {
+                    const refreshedResult = await checkForUpdate(runningVersion);
+                    result = refreshedResult;
+                    updateVersion = result.latestVersion;
+                    persistUpdaterState("record refreshed update check", () => recordCheck(result.latestVersion));
+                    if (!result.updateAvailable) {
+                        persistUpdaterState("clear update deferral", () => clearUpdateDeferral());
+                        return;
+                    }
+                    pendingRestart =
+                        loadUpdateState()?.pendingRestartVersion === result.latestVersion;
+                    if (isVersionSuppressed(result.latestVersion) && !pendingRestart) {
+                        logger.debug(`[guard] refreshed version ${result.latestVersion} is suppressed, skipping`);
+                        return;
+                    }
                 }
                 persistUpdaterState("clear update deferral", () => clearUpdateDeferral());
-                logger.always(`[updater] ${rollingSupervisor ? "rolling activation prepared" : "safe update window acquired"} for v${result.latestVersion}`);
+                logger.always(`[updater] ${supervisorRefreshOnly ? "supervisor reconciliation prepared" : rollingSupervisor ? "rolling activation prepared" : "safe update window acquired"} for v${result.latestVersion}`);
                 // 3. Install update (validate version string before passing to shell)
                 if (!/^\d+\.\d+\.\d+$/.test(result.latestVersion)) {
                     const message = `invalid version format: ${result.latestVersion}`;
@@ -3960,7 +3985,7 @@ export const proxyGuardCommand = {
                     return;
                 }
                 const { execFileSync } = await import("node:child_process");
-                if (!pendingRestart) {
+                if (!supervisorRefreshOnly && !pendingRestart) {
                     const installerResolution = resolveGlobalInstaller({
                         entryScript: process.argv[1],
                     });
@@ -3994,35 +4019,37 @@ export const proxyGuardCommand = {
                         return;
                     }
                 }
-                else {
+                else if (!supervisorRefreshOnly) {
                     logger.always(`[updater] resuming pending restart for already-installed v${result.latestVersion}`);
                 }
                 // 4. Refresh and validate the stable trampoline. The plist already
                 // points at this path, so it must not be unloaded or rewritten here.
-                try {
-                    writeTrampoline();
-                    const validation = await validateInstalledVersion({
-                        binPath: TRAMPOLINE_PATH,
-                        expectedVersion: result.latestVersion,
-                    });
-                    if (validation.version !== result.latestVersion) {
-                        const message = `trampoline validation failed after ${validation.attempts} attempts: ${validation.failure ?? "unknown failure"}`;
-                        logger.always(`[updater] WARNING: ${message}; restart deferred`);
+                if (!supervisorRefreshOnly) {
+                    try {
+                        writeTrampoline();
+                        const validation = await validateInstalledVersion({
+                            binPath: TRAMPOLINE_PATH,
+                            expectedVersion: result.latestVersion,
+                        });
+                        if (validation.version !== result.latestVersion) {
+                            const message = `trampoline validation failed after ${validation.attempts} attempts: ${validation.failure ?? "unknown failure"}`;
+                            logger.always(`[updater] WARNING: ${message}; restart deferred`);
+                            persistUpdaterState("record update failure", () => recordUpdateFailure(result.latestVersion, "validation", message));
+                            persistUpdaterState("abandon invalid pending update", () => abandonPendingUpdate(result.latestVersion));
+                            return;
+                        }
+                        persistUpdaterState("record installed update", () => recordUpdateInstalled(result.latestVersion));
+                        logger.always(`[updater] trampoline validated at v${validation.version} after ${validation.attempts} attempt(s)`);
+                    }
+                    catch (trampolineError) {
+                        const message = trampolineError instanceof Error
+                            ? trampolineError.message
+                            : String(trampolineError);
+                        logger.always(`[updater] WARNING: failed to refresh trampoline; refusing restart: ${message}`);
                         persistUpdaterState("record update failure", () => recordUpdateFailure(result.latestVersion, "validation", message));
                         persistUpdaterState("abandon invalid pending update", () => abandonPendingUpdate(result.latestVersion));
                         return;
                     }
-                    persistUpdaterState("record installed update", () => recordUpdateInstalled(result.latestVersion));
-                    logger.always(`[updater] trampoline validated at v${validation.version} after ${validation.attempts} attempt(s)`);
-                }
-                catch (trampolineError) {
-                    const message = trampolineError instanceof Error
-                        ? trampolineError.message
-                        : String(trampolineError);
-                    logger.always(`[updater] WARNING: failed to refresh trampoline; refusing restart: ${message}`);
-                    persistUpdaterState("record update failure", () => recordUpdateFailure(result.latestVersion, "validation", message));
-                    persistUpdaterState("abandon invalid pending update", () => abandonPendingUpdate(result.latestVersion));
-                    return;
                 }
                 if (guardStopping || getProcessStatus(parentPid) === "not_running") {
                     return;
@@ -4200,11 +4227,11 @@ export const proxyGuardCommand = {
                     process.exit(0);
                 }
                 else {
-                    logger.always(`[updater] WARNING: proxy unhealthy after update to ${result.latestVersion}`);
+                    logger.always(`[updater] WARNING: proxy unhealthy after ${supervisorRefreshOnly ? "supervisor reconciliation at" : "update to"} ${result.latestVersion}`);
                     let failureMessage = rollingFailure
                         ? `rolling candidate failed: ${rollingFailure}`
                         : `proxy did not report v${result.latestVersion} healthy within ${UPDATE_TIMEOUT_MS}ms`;
-                    if (rollingSupervisor) {
+                    if (rollingSupervisor && !supervisorRefreshOnly) {
                         try {
                             const rollbackResolution = resolveGlobalInstaller({
                                 entryScript: process.argv[1],
@@ -4244,8 +4271,13 @@ export const proxyGuardCommand = {
                         }
                     }
                     persistUpdaterState("record update failure", () => recordUpdateFailure(result.latestVersion, "health", failureMessage));
-                    persistUpdaterState("abandon unhealthy pending update", () => abandonPendingUpdate(result.latestVersion));
-                    persistUpdaterState("suppress unhealthy update", () => suppressVersion(result.latestVersion, "unhealthy_after_restart"));
+                    if (supervisorRefreshOnly) {
+                        scheduleUpdateRetry("stale supervisor reconciliation health unavailable", result.latestVersion);
+                    }
+                    else {
+                        persistUpdaterState("abandon unhealthy pending update", () => abandonPendingUpdate(result.latestVersion));
+                        persistUpdaterState("suppress unhealthy update", () => suppressVersion(result.latestVersion, "unhealthy_after_restart"));
+                    }
                     updateRestartInProgress = false;
                 }
             }

package/dist/proxy/bodyCaptureWorker.js

@@ -1,6 +1,12 @@
 import { Worker } from "node:worker_threads";
 const MAX_PENDING = 64;
 const MAX_PENDING_BYTES = 32 * 1024 * 1024;
+// OTel publication is asynchronous. Absorb one additional bounded burst
+// without expanding the active structured-clone pool or blocking model
+// responses; sustained overload still expires with an explicit index failure.
+const MAX_OTEL_WAITING = 64;
+const MAX_OTEL_WAITING_BYTES = 32 * 1024 * 1024;
+const OTEL_ADMISSION_WAIT_MS = 20_000;
 // Bound retained UTF-16 strings rather than a 3x UTF-8 guess. This accommodates
 // the observed 7.3 MB JSON requests while retaining a 32 MiB aggregate pool.
 const MAX_ENTRY_BYTES = 16 * 1024 * 1024;
@@ -20,9 +26,99 @@ const snapshot = {
     maxPendingBytes: MAX_PENDING_BYTES,
     highWaterPending: 0,
     highWaterBytes: 0,
+    waiting: 0,
+    waitingBytes: 0,
+    maxWaiting: MAX_OTEL_WAITING,
+    maxWaitingBytes: MAX_OTEL_WAITING_BYTES,
+    highWaterWaiting: 0,
+    highWaterWaitingBytes: 0,
+    admissionWaits: 0,
+    admissionTimeouts: 0,
     rejectionReasons: {},
 };
 const pending = new Map();
+const otelAdmissionWaiters = [];
+let admissionRetryTimer;
+/** Atomically reserve the active clone/publication lease. */
+function reserveCapture(bytes) {
+    if (Date.now() < retryAfter ||
+        snapshot.pending >= MAX_PENDING ||
+        snapshot.pendingBytes + bytes > MAX_PENDING_BYTES) {
+        return false;
+    }
+    snapshot.pending += 1;
+    snapshot.pendingBytes += bytes;
+    snapshot.highWaterPending = Math.max(snapshot.highWaterPending, snapshot.pending);
+    snapshot.highWaterBytes = Math.max(snapshot.highWaterBytes, snapshot.pendingBytes);
+    return true;
+}
+/** Admit every compatible OTel waiter as active leases settle. */
+function drainOtelAdmissionWaiters() {
+    if (!otelAdmissionWaiters.length) {
+        return;
+    }
+    if (Date.now() < retryAfter) {
+        if (!admissionRetryTimer) {
+            admissionRetryTimer = setTimeout(() => {
+                admissionRetryTimer = undefined;
+                drainOtelAdmissionWaiters();
+            }, Math.max(1, retryAfter - Date.now()));
+            admissionRetryTimer.unref?.();
+        }
+        return;
+    }
+    for (let index = 0; index < otelAdmissionWaiters.length;) {
+        if (snapshot.pending >= MAX_PENDING) {
+            break;
+        }
+        const waiter = otelAdmissionWaiters[index];
+        if (!reserveCapture(waiter.bytes)) {
+            // Byte pressure can block a large capture while a later small capture
+            // still fits. Keep the large capture's original timeout and scan the
+            // rest of the bounded queue once.
+            index += 1;
+            continue;
+        }
+        otelAdmissionWaiters.splice(index, 1);
+        clearTimeout(waiter.timer);
+        snapshot.waiting -= 1;
+        snapshot.waitingBytes -= waiter.bytes;
+        waiter.resolve("admitted");
+    }
+}
+/** Retain bounded OTel overflow instead of dropping a transient burst. */
+function waitForOtelAdmission(bytes) {
+    if (snapshot.waiting >= MAX_OTEL_WAITING ||
+        snapshot.waitingBytes + bytes > MAX_OTEL_WAITING_BYTES) {
+        return Promise.resolve("queue_full");
+    }
+    snapshot.admissionWaits += 1;
+    snapshot.waiting += 1;
+    snapshot.waitingBytes += bytes;
+    snapshot.highWaterWaiting = Math.max(snapshot.highWaterWaiting, snapshot.waiting);
+    snapshot.highWaterWaitingBytes = Math.max(snapshot.highWaterWaitingBytes, snapshot.waitingBytes);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            const index = otelAdmissionWaiters.findIndex((waiter) => waiter.timer === timer);
+            if (index < 0) {
+                return;
+            }
+            otelAdmissionWaiters.splice(index, 1);
+            snapshot.waiting -= 1;
+            snapshot.waitingBytes -= bytes;
+            snapshot.admissionTimeouts += 1;
+            resolve("timeout");
+            drainOtelAdmissionWaiters();
+        }, OTEL_ADMISSION_WAIT_MS);
+        timer.unref?.();
+        otelAdmissionWaiters.push({ bytes, resolve, timer });
+    });
+}
+function releaseCapture(bytes) {
+    snapshot.pending -= 1;
+    snapshot.pendingBytes -= bytes;
+    drainOtelAdmissionWaiters();
+}
 // Bound traversal as well as the structured clone sent to the worker. Never
 // invoke getters/toJSON or stringify a large body on the serving event loop.
 /**
@@ -135,6 +231,7 @@ function getWorker() {
 /** Bounded bulk capture. Failures are indexed; never fall back to blocking work. */
 export async function captureProxyBody(entry, logDir, consume) {
     snapshot.attempted += 1;
+    const queuedAt = Date.now();
     // An OTel capture can use the existing byte pool when it is otherwise idle.
     // Raising the slot count does not raise the aggregate retained-memory bound.
     const maxEntryBytes = logDir === null ? MAX_PENDING_BYTES : MAX_ENTRY_BYTES;
@@ -155,16 +252,23 @@ export async function captureProxyBody(entry, logDir, consume) {
                 ? error.message
                 : "body_capture_unsupported_value";
     }
-    if (bytes > maxEntryBytes ||
-        snapshot.pending >= MAX_PENDING ||
-        snapshot.pendingBytes + bytes > MAX_PENDING_BYTES ||
-        Date.now() < retryAfter) {
+    let admission = "queue_full";
+    if (bytes <= maxEntryBytes && Date.now() >= retryAfter) {
+        admission = reserveCapture(bytes)
+            ? "admitted"
+            : logDir === null
+                ? await waitForOtelAdmission(bytes)
+                : "queue_full";
+    }
+    if (admission !== "admitted") {
         snapshot.rejected += 1;
         const error = bytes > maxEntryBytes
             ? (admissionError ?? "body_capture_entry_too_large")
             : Date.now() < retryAfter
                 ? "body_worker_backoff"
-                : "body_capture_queue_full";
+                : admission === "timeout"
+                    ? "body_capture_admission_timeout"
+                    : "body_capture_queue_full";
         snapshot.lastError = error;
         snapshot.lastRejectedAt = new Date().toISOString();
         snapshot.rejectionReasons[error] =
@@ -194,8 +298,9 @@ export async function captureProxyBody(entry, logDir, consume) {
         current = getWorker();
     }
     catch {
-        snapshot.failed += 1;
         retryAfter = Date.now() + 5_000;
+        releaseCapture(bytes);
+        snapshot.failed += 1;
         return consume({
             error: "body_worker_start_failed",
             stored: { bodyWriteFailed: true },
@@ -215,8 +320,7 @@ export async function captureProxyBody(entry, logDir, consume) {
                     result.error ??= "body_capture_publication_failed";
                 })
                     .finally(() => {
-                    snapshot.pending -= 1;
-                    snapshot.pendingBytes -= bytes;
+                    releaseCapture(bytes);
                     if (result.error || result.stored.bodyWriteFailed) {
                         snapshot.failed += 1;
                     }
@@ -230,13 +334,9 @@ export async function captureProxyBody(entry, logDir, consume) {
                 });
             },
         });
-        snapshot.pending += 1;
-        snapshot.highWaterPending = Math.max(snapshot.highWaterPending, snapshot.pending);
-        snapshot.pendingBytes += bytes;
-        snapshot.highWaterBytes = Math.max(snapshot.highWaterBytes, snapshot.pendingBytes);
         current.ref();
         try {
-            current.postMessage({ id, entry, logDir, queuedAt: Date.now() });
+            current.postMessage({ id, entry, logDir, queuedAt });
         }
         catch {
             settle(id, {
@@ -259,6 +359,9 @@ export const __bodyCaptureWorkerTestHooks = {
      * Reset an isolated worker after capture publications drain, optionally selecting a fixture entry.
      */
     async reset(url) {
+        if (otelAdmissionWaiters.length) {
+            throw new Error("Cannot reset body capture worker with admission waiters");
+        }
         if (worker) {
             const current = worker;
             failWorker(current, "body_worker_test_reset");
@@ -266,6 +369,10 @@ export const __bodyCaptureWorkerTestHooks = {
         }
         workerUrl = url;
         retryAfter = 0;
+        if (admissionRetryTimer) {
+            clearTimeout(admissionRetryTimer);
+            admissionRetryTimer = undefined;
+        }
         Object.assign(snapshot, {
             attempted: 0,
             completed: 0,
@@ -277,6 +384,12 @@ export const __bodyCaptureWorkerTestHooks = {
             lastRejectedAt: undefined,
             highWaterPending: 0,
             highWaterBytes: 0,
+            waiting: 0,
+            waitingBytes: 0,
+            highWaterWaiting: 0,
+            highWaterWaitingBytes: 0,
+            admissionWaits: 0,
+            admissionTimeouts: 0,
             rejectionReasons: {},
         });
     },

package/dist/proxy/requestLogger.d.ts

@@ -10,7 +10,10 @@ import type { ProxyBodyCaptureEntry, RequestAttemptLogEntry, RequestLogEntry, Pr
  * Expose independent metadata-sink and body-capture counters for incident reconciliation.
  */
 export declare function getRequestLoggerSnapshot(): ProxyRequestLoggerSnapshot;
-/** Wait, up to a bounded deadline, for admitted request/body writes to settle. */
+/**
+ * Wait through bounded OTel admission, worker processing, and publication
+ * deadlines so a clean shutdown does not abandon an accepted overflow capture.
+ */
 export declare function flushRequestLogs(timeoutMs?: number): Promise<void>;
 /**
  * Initialize private request logs and preserve required lifecycle admission on startup failures.

package/dist/proxy/requestLogger.js

@@ -26,6 +26,10 @@ let logDir = null;
 let logEnabled = false;
 const pendingLogOperations = new Set();
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
+// launchd gives the service 45 seconds after SIGTERM. Leave fifteen seconds
+// for listener drain and exporter shutdown instead of advertising a flush
+// deadline the service manager can terminate before it reaches.
+const REQUEST_LOG_FLUSH_TIMEOUT_MS = PROXY_BODY_CAPTURE_DEADLINE_MS + 2 * REQUEST_LOG_IO_TIMEOUT_MS;
 const MAX_PENDING_METADATA_RECORDS = 4_096;
 const appendChains = new Map();
 let appendMetadataFile = writeFile;
@@ -114,9 +118,11 @@ function trackLogOperation(operation) {
     void operation.then(() => pendingLogOperations.delete(operation), () => pendingLogOperations.delete(operation));
     return operation;
 }
-/** Wait, up to a bounded deadline, for admitted request/body writes to settle. */
-export async function flushRequestLogs(timeoutMs = PROXY_BODY_CAPTURE_DEADLINE_MS +
-    2 * REQUEST_LOG_IO_TIMEOUT_MS) {
+/**
+ * Wait through bounded OTel admission, worker processing, and publication
+ * deadlines so a clean shutdown does not abandon an accepted overflow capture.
+ */
+export async function flushRequestLogs(timeoutMs = REQUEST_LOG_FLUSH_TIMEOUT_MS) {
     const deadline = Date.now() + Math.max(1, timeoutMs);
     while (pendingLogOperations.size > 0) {
         const admitted = [...pendingLogOperations];
@@ -130,6 +136,7 @@ export async function flushRequestLogs(timeoutMs = PROXY_BODY_CAPTURE_DEADLINE_M
 }
 /** @internal Test-only hook for exercising shutdown behavior without real I/O. */
 export const __requestLoggerTestHooks = {
+    defaultFlushTimeoutMs: REQUEST_LOG_FLUSH_TIMEOUT_MS,
     pendingOperationCount: () => pendingLogOperations.size,
     trackLogOperation,
     setAppendFileForTests: (writer) => {

package/dist/proxy/updateCoordinator.d.ts

@@ -1,4 +1,17 @@
 import type { ProxyUpdateWindowOptions, ProxyUpdateWindowResult } from "../types/index.js";
+/**
+ * A replacement updater starts from the newly installed package. The registry
+ * then reports no newer version even when its launchd parent still runs the
+ * old package, so parent reconciliation must be decided from both live
+ * generations instead of `updateAvailable` alone.
+ */
+export declare function shouldRefreshStaleSupervisor(options: {
+    updateAvailable: boolean;
+    rollingSupervisor: boolean;
+    runningVersion: string;
+    workerVersion?: string;
+    supervisorVersion?: string;
+}): boolean;
 /**
  * Prefer a naturally quiet window, then briefly drain new inference traffic.
  * Existing requests are never interrupted; a bounded drain failure is returned

package/dist/proxy/updateCoordinator.js

@@ -1,3 +1,16 @@
+/**
+ * A replacement updater starts from the newly installed package. The registry
+ * then reports no newer version even when its launchd parent still runs the
+ * old package, so parent reconciliation must be decided from both live
+ * generations instead of `updateAvailable` alone.
+ */
+export function shouldRefreshStaleSupervisor(options) {
+    return (!options.updateAvailable &&
+        options.rollingSupervisor &&
+        options.workerVersion === options.runningVersion &&
+        typeof options.supervisorVersion === "string" &&
+        options.supervisorVersion !== options.runningVersion);
+}
 function isQuiet(activity, quietThresholdMs, nowMs) {
     if (activity.activeRequests > 0) {
         return false;

package/dist/types/generate.d.ts

@@ -1131,6 +1131,15 @@ export type TextGenerationOptions = {
          */
         images?: Array<Buffer | string | ImageWithAltText>;
         pdfFiles?: Array<Buffer | string>;
+        /**
+         * CSV files to inline as tabular text, with tool instructions appended.
+         *
+         * Declared here because `processExplicitCsvFiles` has always read it and
+         * the internal `GenerateOptions` has always carried it — it was missing
+         * only from the public type, so callers reaching the shipped behaviour had
+         * to widen the type themselves to do it.
+         */
+        csvFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string | FileWithMetadata>;
         /** Director Mode segments (2-10). When provided, Director Mode is activated. */
         segments?: DirectorSegment[];

package/dist/types/proxy.d.ts

@@ -669,7 +669,7 @@ export type ProxyBodyCaptureWorkerSnapshot = {
     rejectionReasons: Record<string, number>;
     lastError?: string;
     lastRejectedAt?: string;
-};
+} & ProxyBodyCaptureWaitingSnapshot;
 /** Collector transport evidence; acknowledgement does not prove backend storage. */
 export type ProxyBodyDeliveryResult = {
     status: "transport_acknowledged" | "export_unconfirmed" | "rejected" | "partial";
@@ -4000,3 +4000,15 @@ export type ProxyLogTraceContext = {
     spanId: string;
     traceFlags: number;
 };
+/** OTel-only captures waiting for bounded worker capacity. */
+type ProxyBodyCaptureWaitingSnapshot = {
+    waiting: number;
+    waitingBytes: number;
+    maxWaiting: number;
+    maxWaitingBytes: number;
+    highWaterWaiting: number;
+    highWaterWaitingBytes: number;
+    admissionWaits: number;
+    admissionTimeouts: number;
+};
+export {};

package/dist/utils/fileDetector.d.ts

@@ -187,6 +187,10 @@ export declare class FileDetector {
      * Load file from URL with automatic retry on transient network errors
      */
     private static loadFromURL;
+    /**
+     * Fetch a URL once and retain its response MIME type for detection.
+     */
+    private static loadUrl;
     /**
      * Load file from filesystem path
      */