@juspay/neurolink 9.42.0 → 9.42.1

package/dist/lib/proxy/requestLogger.js

@@ -28,6 +28,9 @@ let otelResolveAttempts = 0;
 const MAX_RESOLVE_ATTEMPTS = 10;
 /** Maximum body chunk size emitted to OTLP logs. */
 const BODY_OTLP_CHUNK_SIZE = 16_000;
+/** Maximum redacted body bytes persisted per capture entry. */
+const MAX_CAPTURED_BODY_BYTES = 1024 * 1024;
+const BODY_TRUNCATION_MARKER = "\n...[TRUNCATED]";
 const gzip = promisify(gzipCallback);
 /** Headers whose values must always be redacted. */
 const SENSITIVE_HEADER_NAMES = new Set([
@@ -262,7 +265,117 @@ function sanitizePhase(phase) {
 function sha256(value) {
     return createHash("sha256").update(value).digest("hex");
 }
-async function writeBodyArtifact(entry, redactedHeaders, redactedBody) {
+function utf8ByteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+function truncateUtf8String(input, maxBytes, marker = BODY_TRUNCATION_MARKER) {
+    const inputBytes = utf8ByteLength(input);
+    if (inputBytes <= maxBytes) {
+        return { value: input, bytes: inputBytes, truncated: false };
+    }
+    const markerBytes = utf8ByteLength(marker);
+    if (maxBytes <= markerBytes) {
+        return { value: marker, bytes: markerBytes, truncated: true };
+    }
+    let value = "";
+    let bytes = 0;
+    for (const char of input) {
+        const charBytes = utf8ByteLength(char);
+        if (bytes + charBytes + markerBytes > maxBytes) {
+            break;
+        }
+        value += char;
+        bytes += charBytes;
+    }
+    const truncatedValue = `${value}${marker}`;
+    return {
+        value: truncatedValue,
+        bytes: utf8ByteLength(truncatedValue),
+        truncated: true,
+    };
+}
+function splitUtf8StringByBytes(input, maxBytes) {
+    if (!input) {
+        return [""];
+    }
+    const chunks = [];
+    let currentChunk = "";
+    let currentBytes = 0;
+    for (const char of input) {
+        const charBytes = utf8ByteLength(char);
+        if (currentChunk && currentBytes + charBytes > maxBytes) {
+            chunks.push(currentChunk);
+            currentChunk = char;
+            currentBytes = charBytes;
+            continue;
+        }
+        currentChunk += char;
+        currentBytes += charBytes;
+    }
+    if (currentChunk) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+function prepareRedactedBody(body) {
+    const redacted = redactBody(body);
+    if (redacted === undefined) {
+        return { truncated: false };
+    }
+    return truncateUtf8String(redacted, MAX_CAPTURED_BODY_BYTES);
+}
+function collectManagedLogFiles(rootDir) {
+    const managedFiles = [];
+    const walk = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const entryPath = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                walk(entryPath);
+                continue;
+            }
+            const isTopLevelProxyLog = directory === rootDir &&
+                /^proxy(?:-attempts|-debug)?-.*\.jsonl$/.test(entry.name);
+            const isBodyArtifact = entry.name.endsWith(".json.gz") &&
+                entryPath.includes(`${join(rootDir, "bodies")}`);
+            if (!isTopLevelProxyLog && !isBodyArtifact) {
+                continue;
+            }
+            try {
+                const stat = statSync(entryPath);
+                managedFiles.push({
+                    path: entryPath,
+                    mtime: stat.mtimeMs,
+                    size: stat.size,
+                });
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+    };
+    walk(rootDir);
+    return managedFiles;
+}
+function pruneEmptyDirectories(directory, stopAt) {
+    if (!existsSync(directory)) {
+        return;
+    }
+    try {
+        const entries = readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                pruneEmptyDirectories(join(directory, entry.name), stopAt);
+            }
+        }
+        if (directory !== stopAt && readdirSync(directory).length === 0) {
+            rmSync(directory, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}
+async function writeBodyArtifact(entry, redactedHeaders, redactedBody, bodyTruncated) {
     if (!logDir || redactedBody === undefined) {
         return {};
     }
@@ -299,9 +412,10 @@ async function writeBodyArtifact(entry, redactedHeaders, redactedBody) {
     return {
         bodyPath,
         bodySha256: sha256(redactedBody),
-        redactedBodyBytes: Buffer.byteLength(redactedBody, "utf8"),
+        redactedBodyBytes: utf8ByteLength(redactedBody),
         storedFileBytes: compressed.byteLength,
         redactedBody,
+        bodyTruncated,
     };
 }
 function emitOtlpBodyLogRecord(entry, stored) {
@@ -311,9 +425,10 @@ function emitOtlpBodyLogRecord(entry, stored) {
             return;
         }
         const otelLogger = provider.getLogger("neurolink-proxy-bodies", "1.0.0");
-        const totalChunks = Math.max(1, Math.ceil(stored.redactedBody.length / BODY_OTLP_CHUNK_SIZE));
+        const chunks = splitUtf8StringByBytes(stored.redactedBody, BODY_OTLP_CHUNK_SIZE);
+        const totalChunks = Math.max(1, chunks.length);
         for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
-            const chunk = stored.redactedBody.slice(chunkIndex * BODY_OTLP_CHUNK_SIZE, (chunkIndex + 1) * BODY_OTLP_CHUNK_SIZE);
+            const chunk = chunks[chunkIndex] ?? "";
             otelLogger.emit({
                 severityNumber: (entry.responseStatus ?? 0) >= 400
                     ? SeverityNumber.WARN
@@ -347,6 +462,9 @@ function emitOtlpBodyLogRecord(entry, stored) {
                     ...(stored.redactedBodyBytes !== undefined && {
                         "body.bytes": stored.redactedBodyBytes,
                     }),
+                    ...(stored.bodyTruncated !== undefined && {
+                        "body.truncated": stored.bodyTruncated,
+                    }),
                     ...(entry.traceId && { "trace.id": entry.traceId }),
                     ...(entry.spanId && { "span.id": entry.spanId }),
                     ...(entry.metadata && {
@@ -370,9 +488,10 @@ export async function logBodyCapture(entry) {
         ? { traceId: entry.traceId, spanId: entry.spanId }
         : bridge.getCurrentTraceContext();
     const redactedHeaders = redactHeaders(entry.headers);
+    const preparedBody = prepareRedactedBody(entry.body);
     let stored = {};
     try {
-        stored = await writeBodyArtifact(entry, redactedHeaders, redactBody(entry.body));
+        stored = await writeBodyArtifact(entry, redactedHeaders, preparedBody.value, preparedBody.truncated);
     }
     catch {
         // Best-effort artifact persistence; continue with in-memory metadata only.
@@ -396,8 +515,9 @@ export async function logBodyCapture(entry) {
         bodyPath: stored.bodyPath,
         bodySha256: stored.bodySha256,
         observedBodyBytes: entry.bodySize,
-        redactedBodyBytes: stored.redactedBodyBytes,
+        redactedBodyBytes: stored.redactedBodyBytes ?? preparedBody.bytes,
         storedFileBytes: stored.storedFileBytes,
+        bodyTruncated: stored.bodyTruncated ?? preparedBody.truncated,
         metadata: entry.metadata,
     };
     if (traceCtx) {
@@ -497,20 +617,7 @@ export function cleanupLogs(maxAgeDays = 7, maxSizeMb = 500) {
     }
     try {
         const activeLogDir = logDir;
-        const files = readdirSync(logDir)
-            .filter((f) => (f.startsWith("proxy-") || f.startsWith("proxy-attempts-")) &&
-            f.endsWith(".jsonl"))
-            .map((f) => {
-            const filePath = join(activeLogDir, f);
-            const stat = statSync(filePath);
-            return {
-                name: f,
-                path: filePath,
-                mtime: stat.mtimeMs,
-                size: stat.size,
-            };
-        })
-            .sort((a, b) => a.mtime - b.mtime); // oldest first
+        const files = collectManagedLogFiles(activeLogDir).sort((a, b) => a.mtime - b.mtime); // oldest first
         const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
         let deletedCount = 0;
         let freedBytes = 0;
@@ -528,34 +635,11 @@ export function cleanupLogs(maxAgeDays = 7, maxSizeMb = 500) {
         }
         const bodiesDir = join(logDir, "bodies");
         if (existsSync(bodiesDir)) {
-            for (const entry of readdirSync(bodiesDir)) {
-                const bodyPath = join(bodiesDir, entry);
-                try {
-                    if (statSync(bodyPath).mtimeMs < cutoff) {
-                        rmSync(bodyPath, { recursive: true, force: true });
-                    }
-                }
-                catch {
-                    // Non-fatal
-                }
-            }
-        }
-        // Include body artifacts in total size calculation
-        const bodiesDirForSize = join(logDir, "bodies");
-        let bodiesSize = 0;
-        if (existsSync(bodiesDirForSize)) {
-            for (const entry of readdirSync(bodiesDirForSize)) {
-                try {
-                    bodiesSize += statSync(join(bodiesDirForSize, entry)).size;
-                }
-                catch {
-                    // Non-fatal
-                }
-            }
+            pruneEmptyDirectories(bodiesDir, bodiesDir);
         }
         // Pass 2: if total size exceeds maxSizeMb, delete oldest until under limit
         const maxBytes = maxSizeMb * 1024 * 1024;
-        let totalSize = remaining.reduce((sum, f) => sum + f.size, 0) + bodiesSize;
+        let totalSize = remaining.reduce((sum, f) => sum + f.size, 0);
         while (totalSize > maxBytes && remaining.length > 0) {
             const oldest = remaining.shift();
             if (!oldest) {
@@ -566,6 +650,9 @@ export function cleanupLogs(maxAgeDays = 7, maxSizeMb = 500) {
             deletedCount++;
             freedBytes += oldest.size;
         }
+        if (existsSync(bodiesDir)) {
+            pruneEmptyDirectories(bodiesDir, bodiesDir);
+        }
         if (deletedCount > 0) {
             logger.info(`[proxy] log cleanup: deleted ${deletedCount} file(s), freed ${(freedBytes / 1024 / 1024).toFixed(1)} MB`);
         }

package/dist/lib/proxy/sseInterceptor.js

@@ -91,31 +91,52 @@ function createAccumulator(captureRawText) {
         eventLogTruncated: false,
     };
 }
-function truncateString(input, maxBytes) {
-    if (input.length <= maxBytes) {
+function utf8ByteLength(input) {
+    return Buffer.byteLength(input, "utf8");
+}
+function truncateUtf8String(input, maxBytes) {
+    if (utf8ByteLength(input) <= maxBytes) {
         return input;
     }
-    return `${input.slice(0, maxBytes)}${TRUNCATION_MARKER}`;
+    const markerBytes = utf8ByteLength(TRUNCATION_MARKER);
+    if (maxBytes <= 0 || maxBytes < markerBytes) {
+        return "";
+    }
+    let output = "";
+    let usedBytes = 0;
+    for (const char of input) {
+        const charBytes = utf8ByteLength(char);
+        if (usedBytes + charBytes + markerBytes > maxBytes) {
+            break;
+        }
+        output += char;
+        usedBytes += charBytes;
+    }
+    return `${output}${TRUNCATION_MARKER}`;
+}
+function truncateString(input, maxBytes) {
+    return truncateUtf8String(input, maxBytes);
 }
 function appendCappedFragment(current, fragment, currentBytes, maxBytes) {
+    const fragmentBytes = utf8ByteLength(fragment);
     if (currentBytes >= maxBytes) {
         return {
             value: current && current.endsWith(TRUNCATION_MARKER)
                 ? current
                 : `${current ?? ""}${TRUNCATION_MARKER}`,
-            nextBytes: currentBytes + fragment.length,
+            nextBytes: currentBytes + fragmentBytes,
         };
     }
     const remainingBytes = maxBytes - currentBytes;
-    const nextBytes = currentBytes + fragment.length;
-    if (fragment.length <= remainingBytes) {
+    const nextBytes = currentBytes + fragmentBytes;
+    if (fragmentBytes <= remainingBytes) {
         return {
             value: `${current ?? ""}${fragment}`,
             nextBytes,
         };
     }
     return {
-        value: `${current ?? ""}${fragment.slice(0, remainingBytes)}${TRUNCATION_MARKER}`,
+        value: `${current ?? ""}${truncateUtf8String(fragment, remainingBytes)}`,
         nextBytes,
     };
 }
@@ -129,15 +150,19 @@ function appendRawTextChunk(acc, chunk) {
         acc.rawTextTruncated = true;
         return;
     }
-    if (chunk.length <= remainingBytes) {
+    const chunkBytes = utf8ByteLength(chunk);
+    if (chunkBytes <= remainingBytes) {
         acc.rawTextChunks.push(chunk);
-        acc.rawTextBytes += chunk.length;
+        acc.rawTextBytes += chunkBytes;
         return;
     }
-    acc.rawTextChunks.push(chunk.slice(0, remainingBytes), TRUNCATION_MARKER);
+    acc.rawTextChunks.push(truncateUtf8String(chunk, remainingBytes));
     acc.rawTextBytes = MAX_RAW_TEXT_BYTES;
     acc.rawTextTruncated = true;
 }
+function getBlockContentBytes(block) {
+    return utf8ByteLength(block.text ?? block.thinking ?? block.toolInput ?? "");
+}
 function finalize(acc) {
     const totalTokens = acc.inputTokens + acc.outputTokens;
     return {
@@ -199,7 +224,7 @@ function processContentBlockStart(acc, parsed) {
         entry.toolInput = "";
     }
     acc.contentBlocks.push(entry);
-    acc.blockByteCounts.set(index, 0);
+    acc.blockByteCounts.set(index, getBlockContentBytes(entry));
 }
 function processContentBlockDelta(acc, parsed) {
     const index = parsed.index ?? 0;

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

@@ -12,7 +12,11 @@
 import type { ModelRouter } from "../../proxy/modelRouter.js";
 import type { ParsedClaudeRequest } from "../../types/index.js";
 import type { RouteGroup } from "../types.js";
-export type { ClaudeProxyDeps } from "../../types/index.js";
+type ProxyTranslationAttempt = {
+    provider?: string;
+    model?: string;
+    label: string;
+};
 /**
  * Create Claude-compatible proxy routes.
  *
@@ -40,6 +44,10 @@ export declare function buildProxyFallbackOptions(parsed: ParsedClaudeRequest, o
     provider?: string;
     model?: string;
 }): Record<string, unknown>;
+export declare function buildProxyTranslationAttempts(primary: {
+    provider: string;
+    model?: string;
+}, modelRouter?: ModelRouter, parsed?: Pick<ParsedClaudeRequest, "images" | "thinkingConfig">): ProxyTranslationAttempt[];
 /**
  * Detect transient upstream failures that should trigger account/provider failover.
  *
@@ -47,3 +55,4 @@ export declare function buildProxyFallbackOptions(parsed: ParsedClaudeRequest, o
  * carry transient HTML responses (e.g. 520 pages) inside `error.message`.
  */
 export declare function isTransientHttpFailure(status: number, errBody: string): boolean;
+export {};