@juspay/neurolink 9.42.0 → 9.43.0

package/dist/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,12 +488,18 @@ export async function logBodyCapture(entry) {
         ? { traceId: entry.traceId, spanId: entry.spanId }
         : bridge.getCurrentTraceContext();
     const redactedHeaders = redactHeaders(entry.headers);
-    let stored = {};
+    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.
+    catch (writeError) {
+        logger.warn("[RequestLogger] writeBodyArtifact failed, falling back to in-memory body for OTLP", { error: writeError });
+        stored = {
+            redactedBody: preparedBody.value,
+            redactedBodyBytes: preparedBody.bytes,
+            bodyTruncated: preparedBody.truncated,
+        };
     }
     const dateStr = new Date(entry.timestamp).toISOString().split("T")[0];
     const logFile = join(logDir, `proxy-debug-${dateStr}.jsonl`);
@@ -396,8 +520,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 +622,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 +640,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 +655,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/proxy/routingPolicy.d.ts

@@ -0,0 +1,33 @@
+import type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
+export type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, ProxyTranslationAttempt, ProxyTranslationPlan, };
+export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProxyModelTier;
+export declare function classifyClaudeProxyRequest(requestedModel: string, parsed: ParsedClaudeRequest): ClaudeProxyRequestProfile;
+export declare function getRequestClassCooldownKey(profile: ClaudeProxyRequestProfile): string;
+export declare function getModelTierCooldownKey(profile: ClaudeProxyRequestProfile): string;
+export declare function evaluateFallbackEligibility(profile: ClaudeProxyRequestProfile, candidate: {
+    provider?: string;
+    model?: string;
+}): FallbackEligibilityDecision;
+export declare function buildProxyTranslationPlan(primary: {
+    provider: string;
+    model?: string;
+}, fallbackChain: FallbackEntry[], requestedModel: string, parsed: ParsedClaudeRequest): ProxyTranslationPlan;
+export declare function summarizeSkippedFallbacks(plan: Pick<ProxyTranslationPlan, "profile" | "skipped">): string | null;
+export declare function getActiveCooldownScope(state: RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): CooldownScope | null;
+export declare function partitionAccountsByCooldown<T extends {
+    key: string;
+}>(accounts: T[], getState: (account: T) => RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): {
+    eligible: T[];
+    skipped: CooldownSkippedAccount<T>[];
+};
+export declare function applyRateLimitCooldownScope(args: {
+    state: RuntimeAccountState;
+    profile: ClaudeProxyRequestProfile;
+    retryAfterMs?: number;
+    now?: number;
+    capMs: number;
+}): {
+    backoffMs: number;
+    requestClassKey: string;
+    modelTierKey: string;
+};

package/dist/proxy/routingPolicy.js

@@ -0,0 +1,254 @@
+const STREAMING_CONVERSATIONAL_TOOL_THRESHOLD = 4;
+const STRONG_TOOL_FIDELITY_THRESHOLD = 8;
+const HIGH_TOOL_COUNT_THRESHOLD = 24;
+const DEFAULT_COOLDOWN_FLOOR_MS = 1_000;
+const HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS = 120_000;
+const HIGH_FIDELITY_COOLDOWN_FLOOR_MS = 300_000;
+export function inferClaudeProxyModelTier(modelName) {
+    const normalized = modelName.toLowerCase();
+    if (normalized.includes("opus")) {
+        return "opus";
+    }
+    if (normalized.includes("sonnet")) {
+        return "sonnet";
+    }
+    if (normalized.includes("haiku")) {
+        return "haiku";
+    }
+    return "other";
+}
+function detectToolHistory(parsed) {
+    return parsed.conversationMessages.some((message) => {
+        return (message.content.includes("[tool_use:") ||
+            message.content.includes("[tool_result:"));
+    });
+}
+export function classifyClaudeProxyRequest(requestedModel, parsed) {
+    const toolCount = Object.keys(parsed.tools).length;
+    const hasImages = parsed.images.length > 0;
+    const hasThinking = !!parsed.thinkingConfig?.enabled;
+    const hasToolHistory = detectToolHistory(parsed);
+    const requiresSpecificTool = !!parsed.toolChoiceName;
+    const requiresToolUse = parsed.toolChoice === "required" || requiresSpecificTool || hasToolHistory;
+    const requiresStrongToolFidelity = toolCount >= STRONG_TOOL_FIDELITY_THRESHOLD ||
+        requiresSpecificTool ||
+        hasToolHistory;
+    const isHighToolCountNonStream = !parsed.stream && toolCount >= HIGH_TOOL_COUNT_THRESHOLD;
+    const isStreamingConversational = parsed.stream &&
+        !hasImages &&
+        toolCount <= STREAMING_CONVERSATIONAL_TOOL_THRESHOLD &&
+        !requiresStrongToolFidelity;
+    const classes = [];
+    if (hasImages) {
+        classes.push("multimodal");
+    }
+    if (isHighToolCountNonStream) {
+        classes.push("high-tool-count-non-stream-structured");
+    }
+    if (requiresStrongToolFidelity) {
+        classes.push("strong-tool-fidelity");
+    }
+    if (isStreamingConversational) {
+        classes.push("streaming-conversational");
+    }
+    if (classes.length === 0) {
+        classes.push("standard");
+    }
+    return {
+        requestedModel,
+        modelTier: inferClaudeProxyModelTier(requestedModel),
+        primaryClass: classes[0],
+        classes,
+        stream: parsed.stream,
+        toolCount,
+        hasImages,
+        hasThinking,
+        hasToolHistory,
+        requiresToolUse,
+        requiresSpecificTool,
+        requiresStrongToolFidelity,
+        isHighToolCountNonStream,
+        isStreamingConversational,
+        isMultimodal: hasImages,
+    };
+}
+export function getRequestClassCooldownKey(profile) {
+    return `${profile.primaryClass}:${profile.requestedModel.toLowerCase()}`;
+}
+export function getModelTierCooldownKey(profile) {
+    return profile.modelTier;
+}
+function getQualityGuardReason(profile, provider, _model) {
+    // Only gate auto-provider fallback (no explicit provider).
+    // Configured fallback-chain entries are always allowed through —
+    // let them attempt the request and fail naturally if the provider
+    // cannot handle it.
+    if (!provider) {
+        if (profile.modelTier === "opus" ||
+            profile.requiresStrongToolFidelity ||
+            profile.isHighToolCountNonStream) {
+            return "auto-provider fallback is disabled for requests that require contract preservation";
+        }
+        return null;
+    }
+    return null;
+}
+export function evaluateFallbackEligibility(profile, candidate) {
+    const policyBlockReason = getQualityGuardReason(profile, candidate.provider, candidate.model);
+    if (policyBlockReason) {
+        return {
+            provider: candidate.provider,
+            model: candidate.model,
+            eligible: false,
+            reason: policyBlockReason,
+        };
+    }
+    return {
+        provider: candidate.provider,
+        model: candidate.model,
+        eligible: true,
+        reason: "eligible",
+    };
+}
+export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel, parsed) {
+    const profile = classifyClaudeProxyRequest(requestedModel, parsed);
+    const attempts = [
+        {
+            provider: primary.provider,
+            model: primary.model,
+            label: `${primary.provider}/${primary.model ?? "unknown"}`,
+        },
+    ];
+    const skipped = [];
+    for (const fallback of fallbackChain) {
+        if (fallback.provider === primary.provider &&
+            fallback.model === primary.model) {
+            continue;
+        }
+        const decision = evaluateFallbackEligibility(profile, fallback);
+        if (!decision.eligible) {
+            skipped.push(decision);
+            continue;
+        }
+        attempts.push({
+            provider: fallback.provider,
+            model: fallback.model,
+            label: `${fallback.provider}/${fallback.model}`,
+        });
+    }
+    if (fallbackChain.length === 0) {
+        const autoDecision = evaluateFallbackEligibility(profile, {});
+        if (autoDecision.eligible) {
+            attempts.push({ label: "auto-provider" });
+        }
+        else {
+            skipped.push(autoDecision);
+        }
+    }
+    return {
+        profile,
+        attempts,
+        skipped,
+    };
+}
+export function summarizeSkippedFallbacks(plan) {
+    if (plan.skipped.length === 0) {
+        return null;
+    }
+    const summary = plan.skipped
+        .map((decision) => {
+        const label = decision.provider
+            ? `${decision.provider}/${decision.model ?? "unknown"}`
+            : "auto-provider";
+        return `${label}: ${decision.reason}`;
+    })
+        .join("; ");
+    return `Fallback policy preserved the requested ${plan.profile.primaryClass} contract by skipping ineligible targets. ${summary}`;
+}
+export function getActiveCooldownScope(state, profile, now = Date.now()) {
+    let longest = null;
+    const requestClassKey = getRequestClassCooldownKey(profile);
+    const requestClassUntil = state.requestClassCooldowns?.[requestClassKey] ?? undefined;
+    if (requestClassUntil && requestClassUntil > now) {
+        longest = {
+            scope: "request_class",
+            key: requestClassKey,
+            until: requestClassUntil,
+        };
+    }
+    const modelTierKey = getModelTierCooldownKey(profile);
+    const modelTierUntil = state.modelTierCooldowns?.[modelTierKey] ?? undefined;
+    if (modelTierUntil &&
+        modelTierUntil > now &&
+        modelTierUntil > (longest?.until ?? 0)) {
+        longest = {
+            scope: "model_tier",
+            key: modelTierKey,
+            until: modelTierUntil,
+        };
+    }
+    if (state.coolingUntil &&
+        state.coolingUntil > now &&
+        state.coolingUntil > (longest?.until ?? 0)) {
+        longest = {
+            scope: "generic",
+            key: "generic",
+            until: state.coolingUntil,
+        };
+    }
+    return longest;
+}
+export function partitionAccountsByCooldown(accounts, getState, profile, now = Date.now()) {
+    const eligible = [];
+    const skipped = [];
+    for (const account of accounts) {
+        const cooldown = getActiveCooldownScope(getState(account), profile, now);
+        if (cooldown) {
+            skipped.push({ account, cooldown });
+            continue;
+        }
+        eligible.push(account);
+    }
+    return {
+        eligible,
+        skipped,
+    };
+}
+export function applyRateLimitCooldownScope(args) {
+    const now = args.now ?? Date.now();
+    const requestClassKey = getRequestClassCooldownKey(args.profile);
+    const modelTierKey = getModelTierCooldownKey(args.profile);
+    const rcBackoffLevels = args.state.requestClassBackoffLevels ?? {};
+    const mtBackoffLevels = args.state.modelTierBackoffLevels ?? {};
+    const scopedBackoffLevel = Math.max(rcBackoffLevels[requestClassKey] ?? 0, mtBackoffLevels[modelTierKey] ?? 0);
+    const floorMs = args.profile.modelTier === "opus" || args.profile.requiresStrongToolFidelity
+        ? HIGH_FIDELITY_COOLDOWN_FLOOR_MS
+        : args.profile.isHighToolCountNonStream
+            ? HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS
+            : DEFAULT_COOLDOWN_FLOOR_MS;
+    const baseCooldownMs = Math.max(args.retryAfterMs ?? 0, floorMs);
+    const backoffMs = Math.min(baseCooldownMs * 2 ** scopedBackoffLevel, args.capMs);
+    const until = now + backoffMs;
+    args.state.requestClassCooldowns = {
+        ...(args.state.requestClassCooldowns ?? {}),
+        [requestClassKey]: Math.max(args.state.requestClassCooldowns?.[requestClassKey] ?? 0, until),
+    };
+    args.state.modelTierCooldowns = {
+        ...(args.state.modelTierCooldowns ?? {}),
+        [modelTierKey]: Math.max(args.state.modelTierCooldowns?.[modelTierKey] ?? 0, until),
+    };
+    args.state.requestClassBackoffLevels = {
+        ...rcBackoffLevels,
+        [requestClassKey]: (rcBackoffLevels[requestClassKey] ?? 0) + 1,
+    };
+    args.state.modelTierBackoffLevels = {
+        ...mtBackoffLevels,
+        [modelTierKey]: (mtBackoffLevels[modelTierKey] ?? 0) + 1,
+    };
+    args.state.backoffLevel += 1;
+    return {
+        backoffMs,
+        requestClassKey,
+        modelTierKey,
+    };
+}

package/dist/proxy/snapshotPersistence.d.ts

@@ -0,0 +1,2 @@
+export declare function writeJsonSnapshotAtomically(targetPath: string, data: unknown, mode?: number): Promise<void>;
+export declare function clearSnapshotWriteLocksForTests(): void;

package/dist/proxy/snapshotPersistence.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+const writeLocks = new Map();
+async function writeSnapshotFile(targetPath, payload, mode) {
+    const dir = dirname(targetPath);
+    const baseName = basename(targetPath);
+    await mkdir(dir, { recursive: true });
+    const tempPath = join(dir, `.${baseName}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(tempPath, payload, { mode });
+        await rename(tempPath, targetPath);
+    }
+    finally {
+        await rm(tempPath, { force: true }).catch(() => {
+            // Best-effort cleanup only.
+        });
+    }
+}
+export async function writeJsonSnapshotAtomically(targetPath, data, mode = 0o600) {
+    const payload = JSON.stringify(data, null, 2);
+    const previous = writeLocks.get(targetPath) ?? Promise.resolve();
+    const next = previous
+        .catch(() => {
+        // Preserve the queue even if a previous write failed.
+    })
+        .then(() => writeSnapshotFile(targetPath, payload, mode));
+    writeLocks.set(targetPath, next);
+    try {
+        await next;
+    }
+    finally {
+        if (writeLocks.get(targetPath) === next) {
+            writeLocks.delete(targetPath);
+        }
+    }
+}
+export function clearSnapshotWriteLocksForTests() {
+    writeLocks.clear();
+}

package/dist/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;