@juspay/neurolink 10.0.1 → 10.1.0

package/dist/lib/proxy/requestLogger.d.ts

@@ -15,6 +15,19 @@ export declare function logRequest(entry: RequestLogEntry): Promise<void>;
  */
 export declare function logRequestAttempt(entry: RequestAttemptLogEntry): Promise<void>;
 export declare function getLogDir(): string | null;
+/** Shared redaction used by offline replay exports and direct comparisons. */
+export declare function redactProxyHeadersForLogging(headers: Record<string, string> | undefined): Record<string, string> | undefined;
+/**
+ * Apply the same bounded body redaction used by persisted proxy captures.
+ * `value` and `bytes` are omitted only when the input is null or undefined.
+ * This performs serialization immediately, so callers must keep it off proxy
+ * hot paths unless body processing has already been explicitly requested.
+ */
+export declare function prepareProxyBodyForLogging(body: unknown): {
+    value?: string;
+    bytes?: number;
+    truncated: boolean;
+};
 export declare function logBodyCapture(entry: ProxyBodyCaptureEntry): Promise<void>;
 /**
  * Log the FULL raw request and response for debugging.

package/dist/lib/proxy/requestLogger.js

@@ -330,6 +330,19 @@ function prepareRedactedBody(body) {
     }
     return truncateUtf8String(redacted, MAX_CAPTURED_BODY_BYTES);
 }
+/** Shared redaction used by offline replay exports and direct comparisons. */
+export function redactProxyHeadersForLogging(headers) {
+    return redactHeaders(headers);
+}
+/**
+ * Apply the same bounded body redaction used by persisted proxy captures.
+ * `value` and `bytes` are omitted only when the input is null or undefined.
+ * This performs serialization immediately, so callers must keep it off proxy
+ * hot paths unless body processing has already been explicitly requested.
+ */
+export function prepareProxyBodyForLogging(body) {
+    return prepareRedactedBody(body);
+}
 function collectManagedLogFiles(rootDir) {
     const managedFiles = [];
     const walk = (directory) => {

package/dist/lib/server/routes/claudeProxyRoutes.d.ts

@@ -167,6 +167,7 @@ declare function handleAnthropicAuthRetry(args: {
         bodyStr: string;
         sessionId?: string;
     };
+    url: string;
     enabledAccounts: ProxyPassthroughAccount[];
     orderedAccounts: ProxyPassthroughAccount[];
     tracer?: ProxyTracer;

package/dist/lib/server/routes/claudeProxyRoutes.js

@@ -1011,6 +1011,10 @@ async function handleClaudePassthroughRequest(args) {
         account: "passthrough",
         accountType: "passthrough",
         attempt: 1,
+        metadata: {
+            upstreamMethod: "POST",
+            upstreamUrl: "https://api.anthropic.com/v1/messages?beta=true",
+        },
     });
     let response;
     try {
@@ -2914,7 +2918,7 @@ async function handleAnthropicSuccessfulRetryResponse(args) {
     return retryJson;
 }
 async function handleAnthropicAuthRetry(args) {
-    const { ctx, body, account, accountState, headers, buildUpstreamBody, enabledAccounts, orderedAccounts, tracer, requestStartTime, allocateAttemptNumber, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, lastError, authFailureMessage, sawRateLimit, sawTransientFailure, sawNetworkError, } = args;
+    const { ctx, body, account, accountState, headers, buildUpstreamBody, url, enabledAccounts, orderedAccounts, tracer, requestStartTime, allocateAttemptNumber, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, lastError, authFailureMessage, sawRateLimit, sawTransientFailure, sawNetworkError, } = args;
     recordAttemptError(account.label, account.type, 401);
     logAttempt(401, "authentication_error", "received 401 from Anthropic", {
         retryable: true,
@@ -2969,9 +2973,10 @@ async function handleAnthropicAuthRetry(args) {
             account: account.label,
             accountType: account.type,
             attempt: retryAttemptNumber,
+            metadata: { upstreamMethod: "POST", upstreamUrl: url },
         });
         try {
-            const retryResp = await fetch("https://api.anthropic.com/v1/messages?beta=true", {
+            const retryResp = await fetch(url, {
                 method: "POST",
                 headers,
                 body: retryBodyStr,
@@ -3692,6 +3697,7 @@ async function prepareAnthropicAccountAttempt(args) {
         account: account.label,
         accountType: account.type,
         attempt: attemptNumber,
+        metadata: { upstreamMethod: "POST", upstreamUrl: url },
     });
     return {
         continueLoop: false,
@@ -4087,6 +4093,7 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                     accountState,
                     headers: preparedAttempt.headers,
                     buildUpstreamBody: preparedAttempt.buildUpstreamBody,
+                    url,
                     enabledAccounts,
                     orderedAccounts,
                     tracer,

package/dist/lib/types/cli.d.ts

@@ -798,6 +798,22 @@ export type ProxyAnalyzeArgs = {
     format?: "text" | "json";
     quiet?: boolean;
 };
+/** Arguments accepted by `neurolink proxy replay <export|compare>`. */
+export type ProxyReplayArgs = {
+    action?: "export" | "compare";
+    requestId?: string;
+    attempt?: number;
+    logsDir?: string;
+    bundle?: string;
+    output?: string;
+    execute?: boolean;
+    headerEnv?: string[];
+    bodyFile?: string;
+    url?: string;
+    timeoutMs?: number;
+    format?: "text" | "json";
+    quiet?: boolean;
+};
 /** Arguments accepted by hidden `neurolink proxy guard` command */
 export type ProxyGuardArgs = {
     host?: string;

package/dist/lib/types/proxy.d.ts

@@ -1227,6 +1227,127 @@ export type ProxyBodyCaptureEntry = {
     spanId?: string;
     metadata?: Record<string, unknown>;
 };
+/** JSON object retained in deterministic proxy replay artifacts. */
+export type ProxyReplayJsonRecord = Record<string, unknown>;
+/** One verified body-capture record in a proxy replay bundle. */
+export type ProxyReplayCapture = {
+    timestamp: string;
+    phase: string;
+    attempt: number | null;
+    model: string | null;
+    stream: boolean | null;
+    account: string | null;
+    accountType: string | null;
+    responseStatus: number | null;
+    durationMs: number | null;
+    contentType: string | null;
+    headers: Record<string, string>;
+    body: string | null;
+    bodySha256: string | null;
+    bodyTruncated: boolean;
+    observedBodyBytes: number | null;
+    metadata: ProxyReplayJsonRecord | null;
+    source: {
+        indexFile: string;
+        indexLine: number;
+        artifactPath: string | null;
+    };
+    issues: string[];
+};
+/** Deterministic, redacted reconstruction of one captured proxy request. */
+export type ProxyReplayBundle = {
+    schemaVersion: 1;
+    kind: "neurolink.proxy.replay-bundle";
+    requestId: string;
+    selectedAttempt: number;
+    source: {
+        logsDirectory: string;
+        indexFiles: string[];
+    };
+    completeness: {
+        captures: number;
+        phasesPresent: string[];
+        missingRequiredPhases: string[];
+        truncatedCaptures: number;
+        artifactsWithIssues: number;
+        replayable: boolean;
+        blockers: string[];
+    };
+    request: {
+        method: string;
+        url: string | null;
+        headers: Record<string, string>;
+        requiredHeaderInputs: string[];
+        body: string | null;
+        bodySha256: string | null;
+        bodyTruncated: boolean;
+        contentType: string | null;
+        account: string | null;
+        accountType: string | null;
+        model: string | null;
+        stream: boolean | null;
+    };
+    capturedResponse: ProxyReplayCapture | null;
+    captures: ProxyReplayCapture[];
+};
+/** Redacted direct-upstream response and comparison with captured evidence. */
+export type ProxyReplayComparison = {
+    schemaVersion: 1;
+    kind: "neurolink.proxy.replay-comparison";
+    requestId: string;
+    selectedAttempt: number;
+    endpoint: string;
+    request: {
+        method: string;
+        headers: Record<string, string>;
+        bodySha256: string;
+        bodyBytes: number;
+        usedBodyOverride: boolean;
+    };
+    captured: {
+        status: number | null;
+        contentType: string | null;
+        bodySha256: string | null;
+        bodyBytes: number | null;
+        bodyTruncated: boolean;
+        jsonShape: string[] | null;
+    } | null;
+    direct: {
+        status: number;
+        headers: Record<string, string>;
+        contentType: string | null;
+        body: string;
+        bodySha256: string;
+        observedBodyBytes: number;
+        storedBodyBytes: number;
+        bodyTruncated: boolean;
+        timeToHeadersMs: number;
+        totalMs: number;
+        jsonShape: string[] | null;
+    };
+    comparison: {
+        statusMatches: boolean | null;
+        contentTypeMatches: boolean | null;
+        bodyHashMatches: boolean | null;
+        jsonShapeMatches: boolean | null;
+    };
+};
+/** Inputs for deterministic proxy replay bundle export. */
+export type ExportProxyReplayOptions = {
+    requestId: string;
+    logsDir?: string;
+    attempt?: number;
+};
+/** Inputs for an explicitly authorized direct-upstream comparison. */
+export type CompareProxyReplayOptions = {
+    execute: boolean;
+    headerValues?: Record<string, string>;
+    bodyOverride?: string;
+    urlOverride?: string;
+    timeoutMs?: number;
+    now?: () => number;
+    fetchImpl?: typeof fetch;
+};
 /** Persisted artifact produced when a body is stored to disk. */
 export type StoredBodyArtifact = {
     bodyPath?: string;

package/dist/proxy/proxyReplay.d.ts

@@ -0,0 +1,10 @@
+import type { CompareProxyReplayOptions, ExportProxyReplayOptions, ProxyReplayBundle, ProxyReplayComparison } from "../types/index.js";
+export declare function isValidProxyReplayHeaderName(name: string): boolean;
+export declare function serializeProxyReplayDocument(value: unknown): string;
+export declare function exportProxyReplayBundle(options: ExportProxyReplayOptions): Promise<ProxyReplayBundle>;
+export declare function writeProxyReplayDocument(outputPath: string, document: unknown): Promise<{
+    path: string;
+    sha256: string;
+}>;
+export declare function readProxyReplayBundle(bundlePath: string): Promise<ProxyReplayBundle>;
+export declare function compareProxyReplayBundle(bundle: ProxyReplayBundle, options: CompareProxyReplayOptions): Promise<ProxyReplayComparison>;