@juspay/neurolink 12.17.1 → 12.17.3

package/dist/proxy/proxyFailureDetails.js

@@ -0,0 +1,96 @@
+import { sanitizeForLog } from "../utils/logSanitize.js";
+/** Shared provider terminal codes across native and SDK transports. */
+export function classifyProxyFailureCode(code) {
+    if ([
+        "cyber_policy",
+        "content_policy_violation",
+        "content_filter",
+        "safety_violation",
+    ].includes(code ?? "")) {
+        return { status: 403, retryable: false };
+    }
+    if ([
+        "max_output_tokens",
+        "context_length_exceeded",
+        "invalid_request_error",
+        "empty_response",
+    ].includes(code ?? "")) {
+        return { status: undefined, retryable: false };
+    }
+    return {
+        status: code === "rate_limit_exceeded" ? 429 : undefined,
+        retryable: undefined,
+    };
+}
+/** Read explicit SDK/API failure evidence without guessing from free-form text.
+ * Bounded traversal covers common error/cause/data and JSON response envelopes. */
+export function getProxyUpstreamFailure(error) {
+    let status;
+    let code;
+    let retryable;
+    let message;
+    const queue = [error];
+    const seen = new Set();
+    for (let index = 0; index < queue.length && index < 16; index++) {
+        const item = queue[index];
+        if (!item ||
+            typeof item !== "object" ||
+            Array.isArray(item) ||
+            seen.has(item)) {
+            continue;
+        }
+        seen.add(item);
+        const value = item;
+        const candidateStatus = value.status ?? value.statusCode;
+        if (typeof candidateStatus === "number" &&
+            Number.isInteger(candidateStatus) &&
+            candidateStatus >= 400 &&
+            candidateStatus <= 599) {
+            status ??= candidateStatus;
+        }
+        if (code === undefined && typeof value.code === "string" && value.code) {
+            code = sanitizeForLog(value.code, 200);
+            if (typeof value.message === "string") {
+                message = sanitizeForLog(value.message, 500);
+            }
+        }
+        const candidateRetry = value.retryable ?? value.isRetryable;
+        if (candidateRetry === false) {
+            retryable = false;
+        }
+        else if (candidateRetry === true) {
+            retryable ??= true;
+        }
+        if (typeof value.message === "string" && message === undefined) {
+            message = sanitizeForLog(value.message, 500);
+        }
+        for (const key of ["error", "cause", "data", "response"]) {
+            if (value[key] !== undefined && queue.length < 16) {
+                queue.push(value[key]);
+            }
+        }
+        if (typeof value.responseBody === "string" &&
+            value.responseBody.length <= 65536 &&
+            queue.length < 16) {
+            try {
+                queue.push(JSON.parse(value.responseBody));
+            }
+            catch {
+                /* Plain text is not structured evidence. */
+            }
+        }
+    }
+    if (error instanceof Error && error.name === "TimeoutError") {
+        status ??= 504;
+    }
+    if (status === undefined && code === undefined && retryable === undefined) {
+        return undefined;
+    }
+    const known = classifyProxyFailureCode(code);
+    return {
+        status: status ?? known.status ?? 502,
+        code,
+        retryable: known.retryable ?? retryable,
+        message,
+    };
+}

package/dist/proxy/proxyLifecycle.js

@@ -378,6 +378,8 @@ function enqueueLifecycleEvent(input, onPersisted) {
         const observedBodyBytes = nonNegativeInteger(input.observedBodyBytes);
         const responseChunks = nonNegativeInteger(input.responseChunks);
         const elapsedMs = finiteNonNegative(input.elapsedMs);
+        const requestTimeoutMs = finiteNonNegative(input.requestTimeoutMs);
+        const parentRequestId = clip(input.parentRequestId);
         const model = clip(input.model);
         const sessionHash = clip(input.sessionHash);
         const terminalOutcome = clip(input.terminalOutcome);
@@ -391,6 +393,11 @@ function enqueueLifecycleEvent(input, onPersisted) {
             sequence,
             event: clip(input.event) ?? "unknown",
             requestId: clip(input.requestId) ?? "unknown",
+            ...(parentRequestId !== undefined ? { parentRequestId } : {}),
+            ...(input.accountingScope !== undefined
+                ? { accountingScope: input.accountingScope }
+                : {}),
+            ...(requestTimeoutMs !== undefined ? { requestTimeoutMs } : {}),
             method: clip(input.method) ?? "unknown",
             path: clip(input.path) ?? "unknown",
             ...(model !== undefined ? { model } : {}),

package/dist/proxy/proxyRouteBodyCapture.d.ts

@@ -0,0 +1,13 @@
+import type { ProxyBodyCaptureInput, ServerContext } from "../types/index.js";
+/** Capture serialized client output and explicitly labelled SDK observations.
+ * This observer never reads a stream or creates a second consumer. */
+export declare function createProxyRouteBodyCapture(ctx: ServerContext, model: string, stream: boolean, startedAt: number): {
+    log: (capture: ProxyBodyCaptureInput) => void;
+    request(): void;
+    json(body: unknown, responseStatus: number): void;
+    accumulator(phase: string, contentType: string, attempt?: number): {
+        append: (value: Uint8Array) => void;
+        appendEvent(value: unknown): void;
+        finish(responseStatus: number): void;
+    };
+};

package/dist/proxy/proxyRouteBodyCapture.js

@@ -0,0 +1,112 @@
+import { isProxyBodyCaptureEnabled, logBodyCapture } from "./requestLogger.js";
+const MAX_PREFIX_BYTES = 1024 * 1024;
+const MAX_ACTIVE_PREFIX_BYTES = 16 * 1024 * 1024;
+let activePrefixBytes = 0;
+/** Capture serialized client output and explicitly labelled SDK observations.
+ * This observer never reads a stream or creates a second consumer. */
+export function createProxyRouteBodyCapture(ctx, model, stream, startedAt) {
+    const log = (capture) => {
+        void logBodyCapture({
+            timestamp: new Date().toISOString(),
+            requestId: ctx.requestId,
+            model,
+            stream,
+            durationMs: Date.now() - startedAt,
+            ...capture,
+        });
+    };
+    return {
+        log,
+        request() {
+            log({
+                phase: "client_request",
+                headers: ctx.headers,
+                body: ctx.body,
+                contentType: "application/json",
+            });
+        },
+        json(body, responseStatus) {
+            log({
+                phase: "client_response",
+                headers: { "content-type": "application/json" },
+                body,
+                contentType: "application/json",
+                responseStatus,
+            });
+        },
+        accumulator(phase, contentType, attempt) {
+            const enabled = isProxyBodyCaptureEnabled();
+            const chunks = [];
+            let totalBytes = 0;
+            let retainedBytes = 0;
+            let truncated = false;
+            let finished = false;
+            const append = (value) => {
+                if (finished || !enabled) {
+                    return;
+                }
+                totalBytes += value.byteLength;
+                const remaining = Math.min(MAX_PREFIX_BYTES - retainedBytes, MAX_ACTIVE_PREFIX_BYTES - activePrefixBytes);
+                if (!truncated && remaining > 0) {
+                    const prefix = Uint8Array.from(value.subarray(0, remaining));
+                    chunks.push(prefix);
+                    retainedBytes += prefix.byteLength;
+                    activePrefixBytes += prefix.byteLength;
+                    truncated = prefix.byteLength !== value.byteLength;
+                }
+                else {
+                    truncated ||= value.byteLength > 0;
+                }
+            };
+            return {
+                append,
+                appendEvent(value) {
+                    if (finished || !enabled) {
+                        return;
+                    }
+                    try {
+                        append(new TextEncoder().encode(`data: ${JSON.stringify(value) ?? "null"}\n\n`));
+                    }
+                    catch {
+                        // Diagnostic serialization cannot fail a provider request. Mark
+                        // unavailable bytes as an explicitly incomplete capture instead.
+                        truncated = true;
+                    }
+                },
+                finish(responseStatus) {
+                    if (finished) {
+                        return;
+                    }
+                    finished = true;
+                    if (!enabled) {
+                        return;
+                    }
+                    const decoder = new TextDecoder();
+                    const body = chunks
+                        .map((chunk) => decoder.decode(chunk, { stream: true }))
+                        .join("") + (truncated ? "" : decoder.decode());
+                    activePrefixBytes -= retainedBytes;
+                    chunks.length = 0;
+                    log({
+                        phase,
+                        headers: { "content-type": contentType },
+                        body,
+                        bodySize: totalBytes,
+                        sourceTruncated: truncated,
+                        contentType,
+                        responseStatus,
+                        attempt,
+                        ...(phase.startsWith("sdk_")
+                            ? {
+                                metadata: {
+                                    representation: "neurolink_sdk_events",
+                                    wireCapture: false,
+                                },
+                            }
+                            : {}),
+                    });
+                },
+            };
+        },
+    };
+}

package/dist/proxy/proxyTokenBudget.d.ts

@@ -0,0 +1,40 @@
+import type { ProxyTokenBudgetLease, ProxyTokenBudgetPolicy, ProxyTokenBudgetReservation, ProxyTokenBudgetRpcResponse, ProxyTokenBudgetSnapshot } from "../types/index.js";
+/** Shared private session scope across every protocol and provider fallback. */
+export declare function getProxyTokenBudgetSessionKey(headers: Pick<Headers, "get">): string;
+/** Local admission failures must not be hidden by automatic provider fallback. */
+export declare function getProxyTokenBudgetError(error: unknown): {
+    code: string;
+    status: 400 | 429 | 503;
+    retryable: false;
+    message: string;
+} | null;
+/** Invalid configured limits fail closed instead of silently disabling protection. */
+export declare function parseProxyTokenBudgetPolicy(value: unknown): ProxyTokenBudgetPolicy;
+export declare function getProxyTokenBudgetPolicy(): ProxyTokenBudgetPolicy | undefined;
+/** One atomic coordinator per supervisor; requests never write budget state to disk. */
+export declare class ProxyTokenBudgetCoordinator {
+    private readonly scope;
+    private readonly now;
+    private readonly maxKeys;
+    private readonly maxLeases;
+    private readonly buckets;
+    private readonly leases;
+    constructor(scope?: "process" | "supervisor", now?: () => number, maxKeys?: number, maxLeases?: number);
+    private bucket;
+    reserve(input: ProxyTokenBudgetReservation, owner?: string): {
+        leaseId: string;
+        snapshot: ProxyTokenBudgetSnapshot;
+    };
+    settle(leaseId: string, owner: string, actualTotalTokens?: number, cancelled?: boolean): ProxyTokenBudgetSnapshot | undefined;
+    ownerExited(owner: string): void;
+}
+/** Parent-side IPC hook is shared by every active and draining generation. */
+export declare function handleProxyTokenBudgetMessage(value: unknown, owner: {
+    pid: number;
+    generation: number;
+}, reply: (response: ProxyTokenBudgetRpcResponse) => void): boolean;
+export declare function releaseProxyTokenBudgetOwner(pid: number, generation: number): void;
+/** Reserve before each upstream attempt; unknown provider usage retains its estimate. */
+export declare function reserveProxyTokenBudget(input: ProxyTokenBudgetReservation): Promise<ProxyTokenBudgetLease>;
+/** Accounting acknowledgement loss must not turn delivered provider success into a stream failure. */
+export declare function settleProxyTokenBudget(lease: ProxyTokenBudgetLease, actualTotalTokens?: number): Promise<void>;