@juspay/neurolink 9.93.0 → 9.93.2

package/dist/proxy/proxyAnalysis.js

@@ -0,0 +1,453 @@
+import { createReadStream } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline";
+import { join, resolve } from "node:path";
+const LIFECYCLE_FILE_PATTERN = /^proxy-lifecycle-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const ATTEMPT_FILE_PATTERN = /^proxy-attempts-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const LIFECYCLE_EVENTS = new Set([
+    "request_accepted",
+    "response_headers",
+    "response_first_chunk",
+    "request_terminal",
+]);
+function increment(counter, key) {
+    counter[key] = (counter[key] ?? 0) + 1;
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function percentile(sorted, fraction) {
+    if (sorted.length === 0) {
+        return null;
+    }
+    const index = Math.max(0, Math.ceil(sorted.length * fraction) - 1);
+    return Number(sorted[index].toFixed(3));
+}
+function summarizeLatency(values) {
+    const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+    return {
+        count: sorted.length,
+        p50: percentile(sorted, 0.5),
+        p95: percentile(sorted, 0.95),
+        p99: percentile(sorted, 0.99),
+        max: sorted.length ? Number(sorted[sorted.length - 1].toFixed(3)) : null,
+    };
+}
+function parseSince(value, nowMs) {
+    const relative = /^(\d+(?:\.\d+)?)(m|h|d|w)$/i.exec(value.trim());
+    if (relative) {
+        const amount = Number(relative[1]);
+        const unitMs = {
+            m: 60_000,
+            h: 3_600_000,
+            d: 86_400_000,
+            w: 604_800_000,
+        };
+        return nowMs - amount * unitMs[relative[2].toLowerCase()];
+    }
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid --since value "${value}". Use an ISO timestamp or a duration such as 6h, 1d, or 1w.`);
+    }
+    return parsed;
+}
+async function readJsonLines(filePath, onRecord, onMalformed) {
+    let linesRead = 0;
+    const lines = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of lines) {
+        if (!line.trim()) {
+            continue;
+        }
+        linesRead += 1;
+        try {
+            const parsed = JSON.parse(line);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                onMalformed();
+                continue;
+            }
+            onRecord(parsed);
+        }
+        catch {
+            onMalformed();
+        }
+    }
+    return linesRead;
+}
+function accountEntry(accounts, account, accountType) {
+    const key = `${accountType}:${account}`;
+    const existing = accounts.get(key);
+    if (existing) {
+        return existing;
+    }
+    const created = {
+        account,
+        accountType,
+        attempts: 0,
+        attemptErrors: 0,
+        finalRequests: 0,
+        finalErrors: 0,
+        transientRateLimits: 0,
+        quotaRateLimits: 0,
+        unclassifiedRateLimits: 0,
+    };
+    accounts.set(key, created);
+    return created;
+}
+function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByRequest, accounts) {
+    let success = 0;
+    let errors = 0;
+    let finalRateLimits = 0;
+    let recoveredAfterRetry = 0;
+    let requestsWithUsage = 0;
+    let requestsWithCacheRead = 0;
+    let cacheReadTokens = 0;
+    let cacheCreationTokens = 0;
+    let inputTokens = 0;
+    const finalRequestLatency = [];
+    const singleAttemptDelta = [];
+    const errorTypes = {};
+    const errorCodes = {};
+    for (const [requestId, request] of finalRequests) {
+        const failed = request.status >= 400 || terminalStreamErrors.has(requestId);
+        if (failed) {
+            errors += 1;
+        }
+        else {
+            success += 1;
+        }
+        finalRateLimits += request.status === 429 ? 1 : 0;
+        const accountStats = accountEntry(accounts, request.account, request.accountType);
+        accountStats.finalRequests += 1;
+        accountStats.finalErrors += failed ? 1 : 0;
+        if (failed) {
+            increment(errorTypes, terminalStreamErrors.has(requestId)
+                ? "stream_error"
+                : (request.errorType ?? `http_${request.status}`));
+            if (request.errorCode) {
+                increment(errorCodes, request.errorCode);
+            }
+        }
+        if (request.durationMs !== null && request.durationMs >= 0) {
+            finalRequestLatency.push(request.durationMs);
+        }
+        const requestAttempts = attemptsByRequest.get(requestId);
+        recoveredAfterRetry += !failed && requestAttempts?.hadError ? 1 : 0;
+        if (requestAttempts?.count === 1 &&
+            requestAttempts.durationCount === 1 &&
+            request.durationMs !== null &&
+            Number.isFinite(requestAttempts.totalDurationMs)) {
+            singleAttemptDelta.push(request.durationMs - requestAttempts.totalDurationMs);
+        }
+        if (request.inputTokens !== null ||
+            request.cacheReadTokens !== null ||
+            request.cacheCreationTokens !== null) {
+            requestsWithUsage += 1;
+            inputTokens += request.inputTokens ?? 0;
+            cacheReadTokens += request.cacheReadTokens ?? 0;
+            cacheCreationTokens += request.cacheCreationTokens ?? 0;
+            requestsWithCacheRead += (request.cacheReadTokens ?? 0) > 0 ? 1 : 0;
+        }
+    }
+    return {
+        requestTotals: {
+            completed: finalRequests.size,
+            success,
+            errors,
+            finalRateLimits,
+            recoveredAfterRetry,
+            errorTypes,
+            errorCodes,
+        },
+        cache: {
+            requestsWithUsage,
+            requestsWithCacheRead,
+            cacheReadTokens,
+            cacheCreationTokens,
+            inputTokens,
+            requestHitRate: requestsWithUsage > 0
+                ? Number((requestsWithCacheRead / requestsWithUsage).toFixed(4))
+                : null,
+        },
+        finalRequestLatency,
+        singleAttemptDelta,
+    };
+}
+async function discoverLogFiles(logsDir) {
+    const entries = await readdir(logsDir, { withFileTypes: true }).catch((error) => {
+        throw new Error(`Unable to read proxy logs at ${logsDir}: ${error.message}`);
+    });
+    const matching = (pattern) => entries
+        .filter((entry) => entry.isFile() && pattern.test(entry.name))
+        .map((entry) => join(logsDir, entry.name))
+        .sort();
+    return {
+        lifecycleFiles: matching(LIFECYCLE_FILE_PATTERN),
+        requestFiles: matching(REQUEST_FILE_PATTERN),
+        attemptFiles: matching(ATTEMPT_FILE_PATTERN),
+    };
+}
+/** Analyze local proxy logs without reading request or response body artifacts. */
+export async function analyzeProxyLogs(options) {
+    const nowMs = options?.nowMs ?? Date.now();
+    const sinceMs = parseSince(options?.since ?? "24h", nowMs);
+    const logsDir = resolve(options?.logsDir ?? join(homedir(), ".neurolink", "logs"));
+    const { lifecycleFiles, requestFiles, attemptFiles } = await discoverLogFiles(logsDir);
+    let linesRead = 0;
+    let malformedLines = 0;
+    let unsupportedLifecycleLines = 0;
+    const accepted = new Set();
+    const headers = new Set();
+    const firstChunks = new Set();
+    const terminal = new Set();
+    const terminalOutcomes = {};
+    const lifecycleErrorTypes = {};
+    const lifecycleErrorCodes = {};
+    const headersLatency = [];
+    const firstChunkLatency = [];
+    const terminalLatency = [];
+    const sequences = new Map();
+    for (const filePath of lifecycleFiles) {
+        linesRead += await readJsonLines(filePath, (record) => {
+            const timestamp = Date.parse(String(record.timestamp ?? ""));
+            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+                return;
+            }
+            const event = stringValue(record.event);
+            const requestId = stringValue(record.requestId);
+            if (record.schemaVersion !== 1 ||
+                !event ||
+                !LIFECYCLE_EVENTS.has(event) ||
+                !requestId) {
+                unsupportedLifecycleLines += 1;
+                return;
+            }
+            const processId = stringValue(record.processInstanceId);
+            const sequence = finiteNumber(record.sequence);
+            if (processId && sequence !== null && Number.isInteger(sequence)) {
+                const values = sequences.get(processId) ?? [];
+                values.push(sequence);
+                sequences.set(processId, values);
+            }
+            const elapsed = finiteNumber(record.elapsedMs);
+            if (event === "request_accepted") {
+                accepted.add(requestId);
+            }
+            else if (event === "response_headers") {
+                headers.add(requestId);
+                if (elapsed !== null && elapsed >= 0) {
+                    headersLatency.push(elapsed);
+                }
+            }
+            else if (event === "response_first_chunk") {
+                firstChunks.add(requestId);
+                if (elapsed !== null && elapsed >= 0) {
+                    firstChunkLatency.push(elapsed);
+                }
+            }
+            else {
+                terminal.add(requestId);
+                if (elapsed !== null && elapsed >= 0) {
+                    terminalLatency.push(elapsed);
+                }
+                increment(terminalOutcomes, stringValue(record.terminalOutcome) ?? "unknown");
+                const errorType = stringValue(record.errorType);
+                const errorCode = stringValue(record.errorCode);
+                if (errorType) {
+                    increment(lifecycleErrorTypes, errorType);
+                }
+                if (errorCode) {
+                    increment(lifecycleErrorCodes, errorCode);
+                }
+            }
+        }, () => {
+            malformedLines += 1;
+        });
+    }
+    let lifecycleSequenceGaps = 0;
+    let lifecycleSequenceDuplicates = 0;
+    for (const values of sequences.values()) {
+        values.sort((a, b) => a - b);
+        for (let index = 1; index < values.length; index += 1) {
+            const difference = values[index] - values[index - 1];
+            if (difference === 0) {
+                lifecycleSequenceDuplicates += 1;
+            }
+            else if (difference > 1) {
+                lifecycleSequenceGaps += difference - 1;
+            }
+        }
+    }
+    const accounts = new Map();
+    const attemptsByRequest = new Map();
+    const attemptLatency = [];
+    let totalAttempts = 0;
+    let totalAttemptErrors = 0;
+    const attemptErrorTypes = {};
+    const attemptErrorCodes = {};
+    let attemptRateLimits = 0;
+    let transientRateLimits = 0;
+    let quotaRateLimits = 0;
+    let unclassifiedRateLimits = 0;
+    for (const filePath of attemptFiles) {
+        linesRead += await readJsonLines(filePath, (record) => {
+            const timestamp = Date.parse(String(record.timestamp ?? ""));
+            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+                return;
+            }
+            const requestId = stringValue(record.requestId);
+            const status = finiteNumber(record.responseStatus);
+            const duration = finiteNumber(record.attemptDurationMs);
+            if (!requestId || status === null) {
+                return;
+            }
+            const account = stringValue(record.account) ?? "unknown";
+            const accountType = stringValue(record.accountType) ?? "unknown";
+            const accountStats = accountEntry(accounts, account, accountType);
+            totalAttempts += 1;
+            accountStats.attempts += 1;
+            const hadError = status >= 400 || !!stringValue(record.errorType);
+            if (hadError) {
+                totalAttemptErrors += 1;
+                accountStats.attemptErrors += 1;
+                increment(attemptErrorTypes, stringValue(record.errorType) ?? `http_${status}`);
+                const errorCode = stringValue(record.errorCode);
+                if (errorCode) {
+                    increment(attemptErrorCodes, errorCode);
+                }
+            }
+            const requestAttempts = attemptsByRequest.get(requestId) ?? {
+                count: 0,
+                hadError: false,
+                totalDurationMs: 0,
+                durationCount: 0,
+            };
+            requestAttempts.count += 1;
+            requestAttempts.hadError = requestAttempts.hadError || hadError;
+            if (duration !== null && duration >= 0) {
+                requestAttempts.totalDurationMs += duration;
+                requestAttempts.durationCount += 1;
+                attemptLatency.push(duration);
+            }
+            attemptsByRequest.set(requestId, requestAttempts);
+            if (status === 429) {
+                attemptRateLimits += 1;
+                if (record.rateLimitKind === "transient") {
+                    transientRateLimits += 1;
+                    accountStats.transientRateLimits += 1;
+                }
+                else if (record.rateLimitKind === "quota") {
+                    quotaRateLimits += 1;
+                    accountStats.quotaRateLimits += 1;
+                }
+                else {
+                    unclassifiedRateLimits += 1;
+                    accountStats.unclassifiedRateLimits += 1;
+                }
+            }
+        }, () => {
+            malformedLines += 1;
+        });
+    }
+    const finalRequests = new Map();
+    const terminalStreamErrors = new Set();
+    for (const filePath of requestFiles) {
+        linesRead += await readJsonLines(filePath, (record) => {
+            const timestamp = Date.parse(String(record.timestamp ?? ""));
+            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+                return;
+            }
+            const requestId = stringValue(record.requestId);
+            if (!requestId) {
+                return;
+            }
+            if (finiteNumber(record.terminalStatus) !== null) {
+                terminalStreamErrors.add(requestId);
+                return;
+            }
+            const status = finiteNumber(record.responseStatus);
+            if (status === null || !stringValue(record.method)) {
+                return;
+            }
+            finalRequests.set(requestId, {
+                status,
+                durationMs: finiteNumber(record.responseTimeMs),
+                account: stringValue(record.account) ?? "unknown",
+                accountType: stringValue(record.accountType) ?? "unknown",
+                inputTokens: finiteNumber(record.inputTokens),
+                cacheReadTokens: finiteNumber(record.cacheReadTokens),
+                cacheCreationTokens: finiteNumber(record.cacheCreationTokens),
+                errorType: stringValue(record.errorType),
+                errorCode: stringValue(record.errorCode),
+            });
+        }, () => {
+            malformedLines += 1;
+        });
+    }
+    const finalSummary = summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByRequest, accounts);
+    return {
+        generatedAt: new Date(nowMs).toISOString(),
+        since: new Date(sinceMs).toISOString(),
+        logsDir,
+        files: {
+            lifecycle: lifecycleFiles.length,
+            requests: requestFiles.length,
+            attempts: attemptFiles.length,
+        },
+        coverage: {
+            lifecycle: lifecycleFiles.length > 0,
+            finalRequests: requestFiles.length > 0,
+            attempts: attemptFiles.length > 0,
+            attemptLatency: attemptLatency.length > 0,
+            cacheUsage: finalSummary.cache.requestsWithUsage > 0,
+        },
+        dataQuality: {
+            linesRead,
+            malformedLines,
+            unsupportedLifecycleLines,
+            lifecycleSequenceGaps,
+            lifecycleSequenceDuplicates,
+        },
+        lifecycle: {
+            accepted: accepted.size,
+            headers: headers.size,
+            firstChunks: firstChunks.size,
+            terminal: terminal.size,
+            unsettled: [...accepted].filter((requestId) => !terminal.has(requestId))
+                .length,
+            terminalOutcomes,
+            errorTypes: lifecycleErrorTypes,
+            errorCodes: lifecycleErrorCodes,
+        },
+        requests: finalSummary.requestTotals,
+        attempts: {
+            total: totalAttempts,
+            errors: totalAttemptErrors,
+            errorTypes: attemptErrorTypes,
+            errorCodes: attemptErrorCodes,
+        },
+        rateLimits: {
+            attemptRateLimits,
+            transient: transientRateLimits,
+            quota: quotaRateLimits,
+            unclassified: unclassifiedRateLimits,
+        },
+        latencyMs: {
+            headers: summarizeLatency(headersLatency),
+            firstChunk: summarizeLatency(firstChunkLatency),
+            terminal: summarizeLatency(terminalLatency),
+            finalRequest: summarizeLatency(finalSummary.finalRequestLatency),
+            attempt: summarizeLatency(attemptLatency),
+            singleAttemptDelta: summarizeLatency(finalSummary.singleAttemptDelta),
+        },
+        cache: finalSummary.cache,
+        accounts: [...accounts.values()].sort((left, right) => right.attempts - left.attempts),
+    };
+}

package/dist/proxy/proxyHealth.d.ts

@@ -1,6 +1,10 @@
 import type { ProxyHealthResponse, ProxyReadinessState } from "../types/index.js";
 export declare function createProxyReadinessState(startTimeMs?: number): ProxyReadinessState;
 export declare function markProxyReady(state: ProxyReadinessState, readyAtMs?: number): void;
+/** Stop admitting new inference requests while existing responses drain. */
+export declare function markProxyDrainingForUpdate(state: ProxyReadinessState): boolean;
+/** Reopen inference admission after a deferred or failed update attempt. */
+export declare function resumeProxyConnections(state: ProxyReadinessState): boolean;
 export declare function buildProxyHealthResponse(state: ProxyReadinessState, options: {
     strategy: string;
     passthrough: boolean;

package/dist/proxy/proxyHealth.js

@@ -3,19 +3,40 @@ export function createProxyReadinessState(startTimeMs = Date.now()) {
         startTimeMs,
         acceptingConnections: false,
         ready: false,
+        drainingForUpdate: false,
     };
 }
 export function markProxyReady(state, readyAtMs = Date.now()) {
     state.acceptingConnections = true;
     state.ready = true;
+    state.drainingForUpdate = false;
     state.readyAtMs = readyAtMs;
 }
+/** Stop admitting new inference requests while existing responses drain. */
+export function markProxyDrainingForUpdate(state) {
+    if (!state.ready) {
+        return false;
+    }
+    state.acceptingConnections = false;
+    state.drainingForUpdate = true;
+    return true;
+}
+/** Reopen inference admission after a deferred or failed update attempt. */
+export function resumeProxyConnections(state) {
+    if (!state.ready) {
+        return false;
+    }
+    state.acceptingConnections = true;
+    state.drainingForUpdate = false;
+    return true;
+}
 export function buildProxyHealthResponse(state, options) {
     const now = options.now ?? Date.now();
     return {
         status: state.ready ? "ok" : "starting",
         ready: state.ready,
         acceptingConnections: state.acceptingConnections,
+        drainingForUpdate: state.drainingForUpdate,
         strategy: options.strategy,
         passthrough: options.passthrough,
         version: options.version,

package/dist/proxy/sseInterceptor.d.ts

@@ -15,7 +15,15 @@
  *   upstreamResponse.body.pipeThrough(stream).pipeTo(clientWritable);
  *   const data = await telemetry; // resolves on stream end
  */
-import type { SSEInterceptorOptions, SSEInterceptorResult } from "../types/index.js";
+import type { SSEInterceptorOptions, SSEInterceptorResult, ParsedSSEBuffer } from "../types/index.js";
+/**
+ * Incrementally parse SSE events from a growing buffer of text.
+ *
+ * SSE events are separated by a blank line (`\n\n`). Each event consists of
+ * field lines (`event: ...`, `data: ...`). We consume complete events and
+ * return them, leaving any trailing partial event in the buffer.
+ */
+export declare function extractSSEEvents(buffer: string): ParsedSSEBuffer;
 /**
  * Create an SSE interceptor that extracts telemetry from an Anthropic
  * streaming response while passing all bytes through unmodified.

package/dist/proxy/sseInterceptor.js

@@ -35,22 +35,23 @@ const TRUNCATION_MARKER = "...[TRUNCATED]";
  * field lines (`event: ...`, `data: ...`). We consume complete events and
  * return them, leaving any trailing partial event in the buffer.
  */
-function extractSSEEvents(buffer) {
+export function extractSSEEvents(buffer) {
     const events = [];
     // Split on double-newline boundaries. The last segment may be an
     // incomplete event if the chunk was split mid-event.
     let cursor = 0;
     while (cursor < buffer.length) {
-        const boundary = buffer.indexOf("\n\n", cursor);
-        if (boundary === -1) {
+        const boundaryMatch = /\r\n\r\n|\n\n|\r\r/.exec(buffer.slice(cursor));
+        if (!boundaryMatch || boundaryMatch.index === undefined) {
             // No more complete events — everything from cursor onward is partial.
             break;
         }
+        const boundary = cursor + boundaryMatch.index;
         const rawBlock = buffer.slice(cursor, boundary);
-        cursor = boundary + 2; // skip past the \n\n
+        cursor = boundary + boundaryMatch[0].length;
         let eventType = "";
         let dataValue = "";
-        const lines = rawBlock.split("\n");
+        const lines = rawBlock.split(/\r\n|\n|\r/);
         for (const line of lines) {
             if (line.startsWith("event: ")) {
                 eventType = line.slice(7).trim();
@@ -336,7 +337,7 @@ function processEvent(acc, event) {
         const message = nestedError?.message ?? payload.message;
         acc.streamErrorMessage =
             typeof message === "string" && message.trim()
-                ? message.trim()
+                ? truncateString(message.trim(), MAX_EVENT_DATA_BYTES)
                 : truncateString(event.data, MAX_EVENT_DATA_BYTES);
     }
     switch (event.event) {

package/dist/proxy/streamOutcome.d.ts

@@ -1,3 +1,5 @@
-import type { StreamTerminalOutcome, StreamTerminalOutcomeTracker } from "../types/index.js";
+import type { AnthropicStreamPreflightResult, StreamTerminalOutcome, StreamTerminalOutcomeTracker } from "../types/index.js";
+/** Hold only pre-commit SSE frames so immediate upstream errors remain retryable. */
+export declare function preflightAnthropicStream(reader: ReadableStreamDefaultReader<Uint8Array>): Promise<AnthropicStreamPreflightResult>;
 export declare function createStreamTerminalOutcomeTracker(): StreamTerminalOutcomeTracker;
 export declare function mergeStreamTerminalOutcome(outcome: StreamTerminalOutcome, sseErrorMessage?: string): StreamTerminalOutcome;

package/dist/proxy/streamOutcome.js

@@ -1,3 +1,80 @@
+import { extractSSEEvents } from "./sseInterceptor.js";
+const STREAM_PREFLIGHT_MAX_BYTES = 64 * 1024;
+const STREAM_PREFLIGHT_MAX_CHUNKS = 32;
+function parseSSEError(data) {
+    try {
+        const parsed = JSON.parse(data);
+        return {
+            errorType: parsed.error?.type ?? parsed.type ?? "stream_error",
+            message: parsed.error?.message ?? parsed.message ?? "Upstream SSE error",
+        };
+    }
+    catch {
+        return {
+            errorType: "stream_error",
+            message: data.trim() || "Upstream SSE error",
+        };
+    }
+}
+function isSSEErrorEvent(event) {
+    if (event.event === "error") {
+        return true;
+    }
+    try {
+        const parsed = JSON.parse(event.data);
+        return parsed.type === "error" || parsed.error !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/** Hold only pre-commit SSE frames so immediate upstream errors remain retryable. */
+export async function preflightAnthropicStream(reader) {
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let parseBuffer = "";
+    let totalBytes = 0;
+    while (totalBytes < STREAM_PREFLIGHT_MAX_BYTES &&
+        chunks.length < STREAM_PREFLIGHT_MAX_CHUNKS) {
+        let result;
+        try {
+            result = await reader.read();
+        }
+        catch (error) {
+            return { kind: "transport_error", chunks, error };
+        }
+        if (result.done) {
+            parseBuffer += decoder.decode();
+            const { events } = extractSSEEvents(parseBuffer);
+            const errorEvent = events.find(isSSEErrorEvent);
+            if (errorEvent) {
+                return { kind: "sse_error", chunks, ...parseSSEError(errorEvent.data) };
+            }
+            return chunks.length > 0
+                ? { kind: "ready", chunks }
+                : { kind: "empty", chunks };
+        }
+        if (!result.value || result.value.length === 0) {
+            continue;
+        }
+        chunks.push(result.value);
+        totalBytes += result.value.byteLength;
+        parseBuffer += decoder.decode(result.value, { stream: true });
+        const parsed = extractSSEEvents(parseBuffer);
+        parseBuffer = parsed.remainder;
+        for (const event of parsed.events) {
+            if (isSSEErrorEvent(event)) {
+                return { kind: "sse_error", chunks, ...parseSSEError(event.data) };
+            }
+            if (event.event !== "ping" && (event.event || event.data)) {
+                return { kind: "ready", chunks };
+            }
+        }
+    }
+    return chunks.length > 0
+        ? { kind: "ready", chunks }
+        : { kind: "empty", chunks };
+}
 export function createStreamTerminalOutcomeTracker() {
     let settled = false;
     let resolveOutcome;

package/dist/proxy/updateCoordinator.d.ts

@@ -0,0 +1,7 @@
+import type { ProxyUpdateWindowOptions, ProxyUpdateWindowResult } from "../types/index.js";
+/**
+ * Prefer a naturally quiet window, then briefly drain new inference traffic.
+ * Existing requests are never interrupted; a bounded drain failure is returned
+ * to the caller so admission can be reopened and retried later.
+ */
+export declare function waitForProxyUpdateWindow(options: ProxyUpdateWindowOptions): Promise<ProxyUpdateWindowResult>;