@juspay/neurolink 12.14.3 → 12.14.5

package/dist/cli/commands/proxy.js

@@ -1079,6 +1079,8 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
         requestMetadata.set(c.req.raw, metadata);
         const stopObservingFinalLog = observeProxyFinalLog(metadata.requestId, (entry) => {
             metadata.terminalResult = entry;
+        }, (entry) => {
+            metadata.lastUpstreamAttempt = { ...entry };
         });
         const finishActivity = metadata.rejectForUpdate
             ? () => undefined
@@ -1306,7 +1308,8 @@ export async function createProxyStartApp(params) {
     const recordRuntimeError = async (metadata, status, errorType, errorMessage, options) => {
         const clientMessage = options?.clientMessage ?? errorMessage;
         const clientErrorType = options?.clientErrorType ?? errorType;
-        recordFinalError(status, PROXY_INTERNAL_ACCOUNT_LABEL, PROXY_INTERNAL_ACCOUNT_TYPE, {
+        const attempt = metadata.lastUpstreamAttempt;
+        recordFinalError(status, attempt?.account ?? PROXY_INTERNAL_ACCOUNT_LABEL, attempt?.accountType ?? PROXY_INTERNAL_ACCOUNT_TYPE, {
             requestId: metadata.requestId,
             errorType,
             errorCode: options?.errorCode,
@@ -1322,8 +1325,13 @@ export async function createProxyStartApp(params) {
                 model: metadata.model,
                 stream: metadata.stream,
                 toolCount: metadata.toolCount,
-                account: "",
-                accountType: "proxy-runtime",
+                account: attempt?.account ?? "",
+                accountType: attempt?.accountType ?? "proxy-runtime",
+                accountKey: attempt?.accountKey,
+                provider: attempt?.provider,
+                transportScope: attempt?.transportScope,
+                traceId: attempt?.traceId,
+                spanId: attempt?.spanId,
                 responseStatus: status,
                 responseTimeMs: Date.now() - metadata.startedAt,
                 errorType,

package/dist/mcp/caching/toolCache.d.ts

@@ -38,10 +38,18 @@ export declare class ToolCache<T = unknown> extends EventEmitter {
     constructor(config: McpCacheConfig);
     /**
      * Get a value from the cache
+     *
+     * Returns an isolated copy of the stored value (see `cloneCachedValue`), so
+     * a caller mutating what it gets back cannot corrupt the entry for later
+     * hits or for other concurrent callers of the same key.
      */
     get(key: string): T | undefined;
     /**
      * Set a value in the cache
+     *
+     * Stores an isolated copy of `value` (see `cloneCachedValue`), so mutating
+     * the caller's original object after this call cannot reach into the
+     * cache entry.
      */
     set(key: string, value: T, ttl?: number): void;
     /**
@@ -89,6 +97,28 @@ export declare class ToolCache<T = unknown> extends EventEmitter {
      * Stop the auto-cleanup timer
      */
     destroy(): void;
+    /**
+     * Isolate a value crossing the cache boundary (on write into the entry,
+     * and on read back out of it) so no two callers — nor a caller and the
+     * stored entry itself — ever share object identity.
+     *
+     * Without this, `set()` stored the caller's object by reference and
+     * `get()` returned `entry.value` by the same reference on every hit: one
+     * caller mutating a result it got back (e.g. an in-place truncation or
+     * normalization pass) silently corrupted the entry for every later
+     * caller of the same key for the rest of the TTL.
+     *
+     * `structuredClone` is the primary path — it is a deep copy, has no
+     * caller-visible side effects, and (unlike a JSON round-trip) tolerates
+     * circular references, which a sufficiently deep or recursive tool
+     * result could contain. It throws on values it cannot clone (functions,
+     * some non-plain class instances); the JSON round-trip fallback covers
+     * that case for the plain-data shapes MCP tool results actually have
+     * (text/JSON content arrays), at the cost of silently dropping
+     * `undefined`, functions and symbol keys — acceptable for a cache that
+     * only ever holds serializable tool results.
+     */
+    private cloneCachedValue;
     private getFullKey;
     private isExpired;
     /**

package/dist/mcp/caching/toolCache.js

@@ -60,6 +60,10 @@ export class ToolCache extends EventEmitter {
     }
     /**
      * Get a value from the cache
+     *
+     * Returns an isolated copy of the stored value (see `cloneCachedValue`), so
+     * a caller mutating what it gets back cannot corrupt the entry for later
+     * hits or for other concurrent callers of the same key.
      */
     get(key) {
         const fullKey = this.getFullKey(key);
@@ -83,11 +87,24 @@ export class ToolCache extends EventEmitter {
         entry.accessCount++;
         this.stats.hits++;
         this.updateHitRate();
-        this.emit("hit", { key: fullKey, value: entry.value });
-        return entry.value;
+        const returnedValue = this.cloneCachedValue(entry.value);
+        if (this.listenerCount("hit") > 0) {
+            // Listeners get their own copy. `emit` is synchronous, so a listener
+            // that mutates `event.value` would otherwise be mutating the very object
+            // the caller is about to receive.
+            this.emit("hit", {
+                key: fullKey,
+                value: this.cloneCachedValue(entry.value),
+            });
+        }
+        return returnedValue;
     }
     /**
      * Set a value in the cache
+     *
+     * Stores an isolated copy of `value` (see `cloneCachedValue`), so mutating
+     * the caller's original object after this call cannot reach into the
+     * cache entry.
      */
     set(key, value, ttl) {
         const fullKey = this.getFullKey(key);
@@ -98,7 +115,7 @@ export class ToolCache extends EventEmitter {
             this.evictOne();
         }
         const entry = {
-            value,
+            value: this.cloneCachedValue(value),
             expires: now + effectiveTtl,
             createdAt: now,
             accessedAt: now,
@@ -250,6 +267,38 @@ export class ToolCache extends EventEmitter {
         this.clear();
     }
     // ==================== Private Methods ====================
+    /**
+     * Isolate a value crossing the cache boundary (on write into the entry,
+     * and on read back out of it) so no two callers — nor a caller and the
+     * stored entry itself — ever share object identity.
+     *
+     * Without this, `set()` stored the caller's object by reference and
+     * `get()` returned `entry.value` by the same reference on every hit: one
+     * caller mutating a result it got back (e.g. an in-place truncation or
+     * normalization pass) silently corrupted the entry for every later
+     * caller of the same key for the rest of the TTL.
+     *
+     * `structuredClone` is the primary path — it is a deep copy, has no
+     * caller-visible side effects, and (unlike a JSON round-trip) tolerates
+     * circular references, which a sufficiently deep or recursive tool
+     * result could contain. It throws on values it cannot clone (functions,
+     * some non-plain class instances); the JSON round-trip fallback covers
+     * that case for the plain-data shapes MCP tool results actually have
+     * (text/JSON content arrays), at the cost of silently dropping
+     * `undefined`, functions and symbol keys — acceptable for a cache that
+     * only ever holds serializable tool results.
+     */
+    cloneCachedValue(value) {
+        if (value === null || typeof value !== "object") {
+            return value;
+        }
+        try {
+            return structuredClone(value);
+        }
+        catch {
+            return JSON.parse(JSON.stringify(value));
+        }
+    }
     getFullKey(key) {
         return this.config.namespace ? `${this.config.namespace}:${key}` : key;
     }

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -9,6 +9,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     value?: string;
     bytes?: number;
     truncated: boolean;
+    originalBytes?: number;
 };
 /**
  * Expose the same header-redaction policy to replay and metadata

package/dist/proxy/bodyCaptureProcessing.js

@@ -6,6 +6,7 @@ import { gzip as gzipCallback } from "node:zlib";
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
 /** Maximum redacted body bytes persisted per capture entry. */
 const MAX_CAPTURED_BODY_BYTES = 1024 * 1024;
+const MAX_OTEL_CAPTURED_BODY_BYTES = 8 * 1024 * 1024;
 const BODY_TRUNCATION_MARKER = "\n...[TRUNCATED]";
 const gzip = promisify(gzipCallback);
 /** Headers whose values must always be redacted. */
@@ -130,12 +131,15 @@ export function splitUtf8StringByBytes(input, maxBytes) {
  * Apply structural redaction before enforcing the per-artifact byte
  * ceiling.
  */
-function prepareRedactedBody(body) {
+function prepareRedactedBody(body, maxBytes = MAX_CAPTURED_BODY_BYTES) {
     const redacted = redactBody(body);
     if (redacted === undefined) {
         return { truncated: false };
     }
-    return truncateUtf8String(redacted, MAX_CAPTURED_BODY_BYTES);
+    return {
+        ...truncateUtf8String(redacted, maxBytes),
+        originalBytes: utf8ByteLength(redacted),
+    };
 }
 /**
  * Write a private gzip artifact with a unique name and return its
@@ -202,7 +206,8 @@ export function redactProxyHeadersForLogging(headers) {
  */
 export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
-    const prepared = prepareRedactedBody(entry.body);
+    const limit = logDir === null ? MAX_OTEL_CAPTURED_BODY_BYTES : MAX_CAPTURED_BODY_BYTES;
+    const prepared = prepareRedactedBody(entry.body, limit);
     if (logDir === null) {
         return {
             headers,
@@ -210,6 +215,9 @@ export async function processProxyBodyCapture(entry, logDir) {
                 redactedBody: prepared.value,
                 redactedBodyBytes: prepared.bytes,
                 bodyTruncated: prepared.truncated,
+                bodyCaptureLimitBytes: limit,
+                originalRedactedBodyBytes: prepared.originalBytes,
+                bodySha256: prepared.value === undefined ? undefined : sha256(prepared.value),
             },
         };
     }
@@ -225,5 +233,12 @@ export async function processProxyBodyCapture(entry, logDir) {
             bodyWriteFailed: true,
         };
     }
-    return { headers, stored };
+    return {
+        headers,
+        stored: {
+            ...stored,
+            bodyCaptureLimitBytes: limit,
+            originalRedactedBodyBytes: prepared.originalBytes,
+        },
+    };
 }

package/dist/proxy/bodyCaptureWorker.js

@@ -1,7 +1,9 @@
 import { Worker } from "node:worker_threads";
 const MAX_PENDING = 16;
 const MAX_PENDING_BYTES = 32 * 1024 * 1024;
-const MAX_ENTRY_BYTES = 8 * 1024 * 1024;
+// 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;
 export const PROXY_BODY_CAPTURE_DEADLINE_MS = 20_000;
 let worker;
 let workerUrl;
@@ -16,6 +18,7 @@ const snapshot = {
     pendingBytes: 0,
     maxPending: MAX_PENDING,
     maxPendingBytes: MAX_PENDING_BYTES,
+    rejectionReasons: {},
 };
 const pending = new Map();
 // Bound traversal as well as the structured clone sent to the worker. Never
@@ -29,12 +32,15 @@ function estimateCloneBytes(value) {
     const seen = new Set();
     let bytes = 0, nodes = 0;
     while (stack.length) {
-        if (++nodes > 100_000 || bytes > MAX_ENTRY_BYTES) {
-            return Infinity;
+        if (++nodes > 100_000) {
+            throw new Error("body_capture_traversal_limit");
+        }
+        if (bytes > MAX_ENTRY_BYTES) {
+            throw new Error("body_capture_entry_too_large");
         }
         const item = stack.pop();
         if (typeof item === "string") {
-            bytes += item.length * 3;
+            bytes += 16 + item.length * 2;
             continue;
         }
         bytes += 16;
@@ -42,23 +48,26 @@ function estimateCloneBytes(value) {
             continue;
         }
         if (seen.has(item)) {
-            return Infinity;
+            throw new Error("body_capture_unsupported_value");
         }
         seen.add(item);
         if (!Array.isArray(item) &&
             Object.getPrototypeOf(item) !== Object.prototype &&
             Object.getPrototypeOf(item) !== null) {
-            return Infinity;
+            throw new Error("body_capture_unsupported_value");
         }
         for (const key of Object.keys(item)) {
-            bytes += key.length * 3;
+            bytes += 16 + key.length * 2;
             const descriptor = Object.getOwnPropertyDescriptor(item, key);
             if (!descriptor || descriptor.get || descriptor.set) {
-                return Infinity;
+                throw new Error("body_capture_unsupported_value");
             }
             stack.push(descriptor.value);
-            if (stack.length > 100_000 || bytes > MAX_ENTRY_BYTES) {
-                return Infinity;
+            if (stack.length > 100_000) {
+                throw new Error("body_capture_traversal_limit");
+            }
+            if (bytes > MAX_ENTRY_BYTES) {
+                throw new Error("body_capture_entry_too_large");
             }
         }
     }
@@ -125,11 +134,21 @@ function getWorker() {
 export async function captureProxyBody(entry, logDir, consume) {
     snapshot.attempted += 1;
     let bytes;
+    let admissionError;
     try {
         bytes = estimateCloneBytes(entry);
     }
-    catch {
+    catch (error) {
         bytes = Infinity;
+        admissionError =
+            error instanceof Error &&
+                [
+                    "body_capture_entry_too_large",
+                    "body_capture_traversal_limit",
+                    "body_capture_unsupported_value",
+                ].includes(error.message)
+                ? error.message
+                : "body_capture_unsupported_value";
     }
     if (bytes > MAX_ENTRY_BYTES ||
         snapshot.pending >= MAX_PENDING ||
@@ -137,11 +156,13 @@ export async function captureProxyBody(entry, logDir, consume) {
         Date.now() < retryAfter) {
         snapshot.rejected += 1;
         const error = bytes > MAX_ENTRY_BYTES
-            ? "body_capture_too_large_or_non_json"
+            ? (admissionError ?? "body_capture_entry_too_large")
             : Date.now() < retryAfter
                 ? "body_worker_backoff"
                 : "body_capture_queue_full";
         snapshot.lastError = error;
+        snapshot.rejectionReasons[error] =
+            (snapshot.rejectionReasons[error] ?? 0) + 1;
         return consume({ error, stored: { bodyWriteFailed: true } });
     }
     let current;
@@ -204,7 +225,7 @@ export async function captureProxyBody(entry, logDir, consume) {
  * retained publication work.
  */
 export function getBodyCaptureWorkerSnapshot() {
-    return { ...snapshot };
+    return { ...snapshot, rejectionReasons: { ...snapshot.rejectionReasons } };
 }
 /** Isolated tests point at a separately executed built worker. */
 export const __bodyCaptureWorkerTestHooks = {
@@ -227,6 +248,7 @@ export const __bodyCaptureWorkerTestHooks = {
             pending: 0,
             pendingBytes: 0,
             lastError: undefined,
+            rejectionReasons: {},
         });
     },
 };

package/dist/proxy/otelLogSink.d.ts

@@ -1,6 +1,13 @@
 import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { ProxyBodyChunkEmitter, ProxyBodyDeliveryResult } from "../types/index.js";
 /** Explicit opt-in; configuration never silently falls back to file logging. */
 export declare function isProxyOtelOnly(): boolean;
+/**
+ * Own a whole capture within byte/count bounds, then pace its chunks by actual
+ * export callbacks. SDK forceFlush alone does not await an automatic export
+ * already in flight. Serial publication prevents bursts from dropping tails.
+ */
+export declare function publishProxyOtelBody(captureId: string, body: string, emit: ProxyBodyChunkEmitter): Promise<ProxyBodyDeliveryResult>;
 /** Initialize a log-only provider in every proxy process, including the supervisor. */
 export declare function initializeProxyOtelLogs(role?: string): LoggerProvider | undefined;
 /** Structured evidence without final-request dashboard fields on auxiliary events. */
@@ -13,6 +20,19 @@ export declare function getProxyOtelLogSnapshot(): {
     initialized: boolean;
     deliveryGuarantee: string;
     invalidRecords: number;
+    bodyDelivery: {
+        attempted: number;
+        transportAcknowledged: number;
+        exportUnconfirmed: number;
+        rejected: number;
+        partial: number;
+        pending: number;
+        pendingBytes: number;
+        highWaterPending: number;
+        highWaterBytes: number;
+        maxPending: number;
+        maxPendingBytes: number;
+    };
     queues: {
         attempted: number;
         submitted: number;
@@ -22,7 +42,8 @@ export declare function getProxyOtelLogSnapshot(): {
         outstanding: number;
         lastAcknowledgedAt: string | undefined;
         lastFailureAt: string | undefined;
-        kind: string;
+        highWaterOutstanding: number;
+        kind: "metadata" | "bodies";
         capacity: number;
     }[];
 };