@juspay/neurolink 9.93.0 → 9.93.2

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

package/dist/lib/proxy/updateCoordinator.js

@@ -0,0 +1,60 @@
+function isQuiet(activity, quietThresholdMs, nowMs) {
+    if (activity.activeRequests > 0) {
+        return false;
+    }
+    if (!activity.lastActivityAt) {
+        return true;
+    }
+    const lastActivityMs = Date.parse(activity.lastActivityAt);
+    return (Number.isFinite(lastActivityMs) &&
+        nowMs - lastActivityMs >= quietThresholdMs);
+}
+/**
+ * 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 async function waitForProxyUpdateWindow(options) {
+    const now = options.now ?? Date.now;
+    const wait = options.sleep ??
+        ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const quietDeadline = now() + options.quietWaitMs;
+    while (now() < quietDeadline) {
+        if (options.isStopping()) {
+            return { ready: false, draining: false, reason: "stopping" };
+        }
+        if (!options.isParentAlive()) {
+            return { ready: false, draining: false, reason: "parent_stopped" };
+        }
+        const activity = await options.getActivity();
+        if (activity && isQuiet(activity, options.quietThresholdMs, now())) {
+            return { ready: true, draining: false };
+        }
+        options.onPhase?.("waiting_for_quiet", activity);
+        await wait(options.pollIntervalMs);
+    }
+    if (!(await options.setDraining(true))) {
+        // The control response may have been lost after the parent applied it.
+        // Treat state as unknown/draining so the caller always attempts resume.
+        return { ready: false, draining: true, reason: "drain_failed" };
+    }
+    const drainDeadline = now() + options.drainWaitMs;
+    while (now() < drainDeadline) {
+        if (options.isStopping()) {
+            return { ready: false, draining: true, reason: "stopping" };
+        }
+        if (!options.isParentAlive()) {
+            return { ready: false, draining: true, reason: "parent_stopped" };
+        }
+        const activity = await options.getActivity();
+        options.onPhase?.("draining", activity);
+        if (activity?.activeRequests === 0) {
+            return { ready: true, draining: true };
+        }
+        await wait(options.pollIntervalMs);
+    }
+    const activity = await options.getActivity();
+    options.onPhase?.("drain_timeout", activity);
+    return { ready: false, draining: true, reason: "drain_timeout" };
+}
+//# sourceMappingURL=updateCoordinator.js.map

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

@@ -54,6 +54,10 @@ export declare function recordUpdateInstalled(version: string, stateFilePath?: s
 export declare function abandonPendingUpdate(version: string, stateFilePath?: string): boolean;
 /** Persist a stage-specific updater failure so status remains actionable. */
 export declare function recordUpdateFailure(version: string, stage: NonNullable<UpdateState["lastFailure"]>["stage"], message: string, stateFilePath?: string): void;
+/** Persist why a discovered update is waiting without treating it as a failure. */
+export declare function recordUpdateDeferred(version: string, reason: NonNullable<UpdateState["deferredUpdate"]>["reason"], activeRequests: number | null, stateFilePath?: string): void;
+/** Clear matching updater deferral metadata once work can proceed. */
+export declare function clearUpdateDeferral(version?: string, stateFilePath?: string): boolean;
 /** Complete an updater-managed install after a manual or automatic restart. */
 export declare function reconcileRunningUpdate(runningVersion: string, stateFilePath?: string): boolean;
 /**

package/dist/lib/proxy/updateState.js

@@ -56,6 +56,26 @@ function isValidLastFailure(value) {
         UPDATE_FAILURE_STAGES.has(candidate.stage) &&
         typeof candidate.message === "string");
 }
+function isValidDeferredUpdate(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.version === "string" &&
+        typeof candidate.since === "string" &&
+        typeof candidate.updatedAt === "string" &&
+        [
+            "waiting_for_quiet",
+            "draining",
+            "drain_timeout",
+            "drain_unavailable",
+            "activity_unavailable",
+        ].includes(String(candidate.reason)) &&
+        (candidate.activeRequests === null ||
+            (typeof candidate.activeRequests === "number" &&
+                Number.isInteger(candidate.activeRequests) &&
+                candidate.activeRequests >= 0)));
+}
 // ============================================
 // Exported Functions
 // ============================================
@@ -70,6 +90,7 @@ export function getDefaultUpdateState() {
         lastUpdateAt: null,
         lastUpdateVersion: null,
         pendingRestartVersion: null,
+        deferredUpdate: null,
         lastFailure: null,
     };
 }
@@ -106,6 +127,9 @@ export function loadUpdateState(stateFilePath) {
             pendingRestartVersion: typeof candidate.pendingRestartVersion === "string"
                 ? candidate.pendingRestartVersion
                 : null,
+            deferredUpdate: isValidDeferredUpdate(candidate.deferredUpdate)
+                ? candidate.deferredUpdate
+                : null,
             lastFailure: isValidLastFailure(candidate.lastFailure)
                 ? candidate.lastFailure
                 : null,
@@ -185,6 +209,7 @@ export function recordSuccessfulUpdate(version, stateFilePath) {
     state.lastUpdateAt = new Date().toISOString();
     state.lastUpdateVersion = version;
     state.pendingRestartVersion = null;
+    state.deferredUpdate = null;
     state.lastFailure = null;
     delete state.suppressedVersions[version];
     saveUpdateState(state, stateFilePath);
@@ -217,6 +242,32 @@ export function recordUpdateFailure(version, stage, message, stateFilePath) {
     };
     saveUpdateState(state, stateFilePath);
 }
+/** Persist why a discovered update is waiting without treating it as a failure. */
+export function recordUpdateDeferred(version, reason, activeRequests, stateFilePath) {
+    const state = loadUpdateState(stateFilePath) ?? getDefaultUpdateState();
+    const now = new Date().toISOString();
+    state.deferredUpdate = {
+        version,
+        since: state.deferredUpdate?.version === version
+            ? state.deferredUpdate.since
+            : now,
+        updatedAt: now,
+        reason,
+        activeRequests,
+    };
+    saveUpdateState(state, stateFilePath);
+}
+/** Clear matching updater deferral metadata once work can proceed. */
+export function clearUpdateDeferral(version, stateFilePath) {
+    const state = loadUpdateState(stateFilePath);
+    if (!state?.deferredUpdate ||
+        (version !== undefined && state.deferredUpdate.version !== version)) {
+        return false;
+    }
+    state.deferredUpdate = null;
+    saveUpdateState(state, stateFilePath);
+    return true;
+}
 /** Complete an updater-managed install after a manual or automatic restart. */
 export function reconcileRunningUpdate(runningVersion, stateFilePath) {
     const state = loadUpdateState(stateFilePath);

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

@@ -0,0 +1,6 @@
+/** Open a restrictive worker log without making proxy startup depend on it. */
+export declare function openProxyWorkerLog(filename: string, logDir?: string): {
+    stdio: number | "ignore";
+    close: () => void;
+    error?: string;
+};

package/dist/lib/proxy/workerLog.js

@@ -0,0 +1,42 @@
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+/** Open a restrictive worker log without making proxy startup depend on it. */
+export function openProxyWorkerLog(filename, logDir = join(homedir(), ".neurolink", "logs")) {
+    let fd;
+    try {
+        if (basename(filename) !== filename) {
+            throw new Error("worker log filename must not contain a path");
+        }
+        if (!existsSync(logDir)) {
+            mkdirSync(logDir, { recursive: true, mode: 0o700 });
+        }
+        else if (!statSync(logDir).isDirectory()) {
+            throw new Error("worker log path exists but is not a directory");
+        }
+        chmodSync(logDir, 0o700);
+        const path = join(logDir, filename);
+        fd = openSync(path, "a", 0o600);
+        chmodSync(path, 0o600);
+        return {
+            stdio: fd,
+            close: () => closeSync(fd),
+        };
+    }
+    catch (error) {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // The log is optional and startup must remain fail-open.
+            }
+        }
+        return {
+            stdio: "ignore",
+            close: () => undefined,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=workerLog.js.map

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

@@ -143,6 +143,7 @@ declare function handleAnthropicStreamingSuccessResponse(args: {
     attemptNumber: number;
     finalBodyStr: string;
     upstreamSpan?: import("@opentelemetry/api").Span;
+    logAttempt: AnthropicAttemptLogger;
     logProxyBody: ProxyBodyCaptureLogger;
     logFinalRequest: (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
         inputTokens?: number;

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

@@ -25,7 +25,7 @@ import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
 import { relocateClientSystemIntoMessages } from "../../proxy/systemRelocation.js";
 import { logBodyCapture, logRequest, logRequestAttempt, } from "../../proxy/requestLogger.js";
 import { createSSEInterceptor } from "../../proxy/sseInterceptor.js";
-import { createStreamTerminalOutcomeTracker, mergeStreamTerminalOutcome, } from "../../proxy/streamOutcome.js";
+import { createStreamTerminalOutcomeTracker, mergeStreamTerminalOutcome, preflightAnthropicStream, } from "../../proxy/streamOutcome.js";
 import { isPermanentRefreshFailure, needsRefresh, persistTokens, refreshToken, } from "../../proxy/tokenRefresh.js";
 import { buildProxyTranslationPlan, parseRetryAfterMs, } from "../../proxy/routingPolicy.js";
 import { writeJsonSnapshotAtomically } from "../../proxy/snapshotPersistence.js";
@@ -2182,7 +2182,7 @@ function buildClaudeAnthropicFailureResponse(args) {
     });
 }
 async function handleAnthropicSuccessfulResponse(args) {
-    const { ctx, body, account, accountState, response, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
+    const { ctx, body, account, accountState, response, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     accountState.consecutiveRefreshFailures = 0;
     logger.always(`[proxy] ← ${response.status} account=${account.label}`);
     const quota = parseQuotaHeaders(response.headers);
@@ -2222,6 +2222,7 @@ async function handleAnthropicSuccessfulResponse(args) {
             attemptNumber,
             finalBodyStr,
             upstreamSpan,
+            logAttempt,
             logProxyBody,
             logFinalRequest,
         });
@@ -2241,7 +2242,7 @@ async function handleAnthropicSuccessfulResponse(args) {
     });
 }
 async function handleAnthropicStreamingSuccessResponse(args) {
-    const { account, accountState: _accountState, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
+    const { account, accountState, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     if (!response.body) {
         upstreamSpan?.end();
         tracer?.setError("stream_error", "No response body from upstream");
@@ -2265,44 +2266,129 @@ async function handleAnthropicStreamingSuccessResponse(args) {
         return { response: clientError };
     }
     const reader = response.body.getReader();
-    let firstChunk;
-    try {
-        firstChunk = await reader.read();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+    const preflight = await preflightAnthropicStream(reader);
+    if (preflight.kind === "transport_error") {
+        const message = describeTransportError(preflight.error);
+        const partialBody = Buffer.concat(preflight.chunks.map((chunk) => Buffer.from(chunk))).toString("utf8");
         logger.always(`[proxy] stream failed before first chunk account=${account.label}: ${message}; trying next account`);
         recordAttemptError(account.label, account.type, 502);
+        logAttempt(502, "stream_error", message, { retryable: true });
         tracer?.recordRetry(account.label, "stream_before_first_chunk");
         upstreamSpan?.end();
         logProxyBody({
             phase: "upstream_response",
             headers: responseHeaders,
-            body: message,
-            bodySize: Buffer.byteLength(message, "utf8"),
+            body: partialBody,
+            bodySize: Buffer.byteLength(partialBody, "utf8"),
             contentType: responseHeaders["content-type"] ?? "text/event-stream",
             account: account.label,
             accountType: account.type,
             attempt: attemptNumber,
-            responseStatus: 502,
+            responseStatus: response.status,
             durationMs: Date.now() - fetchStartMs,
+            metadata: { logicalStatus: 502, transportError: message },
         });
-        return { retryNextAccount: true };
+        return {
+            retryNextAccount: true,
+            failure: { message, rateLimit: false },
+        };
     }
-    if (firstChunk.done || !firstChunk.value || firstChunk.value.length === 0) {
+    if (preflight.kind === "empty") {
         await reader.cancel().catch(() => {
             // Best-effort release before rotating to another account.
         });
         logger.always(`[proxy] ← empty stream from account=${account.label}, trying next`);
+        recordAttemptError(account.label, account.type, 502);
+        logAttempt(502, "empty_stream", "Empty upstream stream", {
+            retryable: true,
+        });
         tracer?.recordRetry(account.label, "empty_stream");
         upstreamSpan?.end();
-        return { retryNextAccount: true };
+        logProxyBody({
+            phase: "upstream_response",
+            headers: responseHeaders,
+            body: "",
+            bodySize: 0,
+            contentType: responseHeaders["content-type"] ?? "text/event-stream",
+            account: account.label,
+            accountType: account.type,
+            attempt: attemptNumber,
+            responseStatus: response.status,
+            durationMs: Date.now() - fetchStartMs,
+            metadata: { logicalStatus: 502, upstreamErrorType: "empty_stream" },
+        });
+        return {
+            retryNextAccount: true,
+            failure: { message: "Empty upstream stream", rateLimit: false },
+        };
+    }
+    if (preflight.kind === "sse_error") {
+        await reader.cancel().catch(() => {
+            // Best-effort release before rotating to another account.
+        });
+        const bodyText = Buffer.concat(preflight.chunks.map((chunk) => Buffer.from(chunk))).toString("utf8");
+        const isRateLimit = preflight.errorType === "rate_limit_error";
+        const logicalStatus = isRateLimit ? 429 : 502;
+        const quota = parseQuotaHeaders(responseHeaders);
+        const now = Date.now();
+        if (isRateLimit) {
+            const cooldownPlan = planCooldownFor429(quota, parseRetryAfterMs(responseHeaders["retry-after"] ?? null), now, getUnifiedRateLimitStatus(responseHeaders));
+            accountState.quota = quota ?? accountState.quota;
+            const rateLimitKind = cooldownPlan.reason === "transient" ? "transient" : "quota";
+            if (!accountState.coolingUntil ||
+                cooldownPlan.coolingUntil > accountState.coolingUntil) {
+                accountState.coolingUntil = cooldownPlan.coolingUntil;
+                accountState.coolingReason = cooldownPlan.reason;
+                await saveAccountCooldown(account.key, cooldownPlan.coolingUntil, cooldownPlan.reason).catch(() => {
+                    // Non-fatal: routing already has the in-memory cooldown.
+                });
+            }
+            recordAttemptError(account.label, account.type, 429, rateLimitKind);
+            logAttempt(429, "rate_limit_error", preflight.message, {
+                retryable: true,
+                rateLimitKind,
+                cooldownReason: cooldownPlan.reason,
+            });
+        }
+        else {
+            recordAttemptError(account.label, account.type, logicalStatus);
+            logAttempt(logicalStatus, preflight.errorType, preflight.message, {
+                retryable: true,
+            });
+        }
+        logger.always(`[proxy] immediate SSE ${preflight.errorType} account=${account.label}: ${preflight.message}; rotating before client commit`);
+        tracer?.recordRetry(account.label, isRateLimit
+            ? "stream_rate_limit_before_commit"
+            : "stream_error_before_commit");
+        upstreamSpan?.end();
+        logProxyBody({
+            phase: "upstream_response",
+            headers: responseHeaders,
+            body: bodyText,
+            bodySize: Buffer.byteLength(bodyText, "utf8"),
+            contentType: responseHeaders["content-type"] ?? "text/event-stream",
+            account: account.label,
+            accountType: account.type,
+            attempt: attemptNumber,
+            responseStatus: response.status,
+            durationMs: Date.now() - fetchStartMs,
+            metadata: {
+                logicalStatus,
+                upstreamErrorType: preflight.errorType,
+            },
+        });
+        return {
+            retryNextAccount: true,
+            failure: { message: preflight.message, rateLimit: isRateLimit },
+        };
     }
     const streamOutcomeTracker = createStreamTerminalOutcomeTracker();
     let mainStreamClosed = false;
     const remainingStream = new ReadableStream({
         start(controller) {
-            controller.enqueue(firstChunk.value);
+            for (const chunk of preflight.chunks) {
+                controller.enqueue(chunk);
+            }
         },
         async pull(controller) {
             if (mainStreamClosed) {
@@ -2865,10 +2951,12 @@ async function handleAnthropicAuthRetry(args) {
         await clearAuthCooldownAfterRefresh(account, accountState);
         headers.authorization = `Bearer ${account.token}`;
         const retryAttemptNumber = allocateAttemptNumber();
+        const retryAttemptStartedAt = Date.now();
         recordAttempt(account.label, account.type);
         const retryLogAttempt = (status, errorType, errorMessage, extra) => logAttempt(status, errorType, errorMessage, {
             ...extra,
             attempt: retryAttemptNumber,
+            attemptDurationMs: Date.now() - retryAttemptStartedAt,
         });
         const retryBodyStr = buildUpstreamBody(account.token).bodyStr;
         const retryFetchStartMs = Date.now();
@@ -3423,7 +3511,9 @@ function createClaudeRequestRuntimeContext(args) {
 }
 function createAnthropicAttemptLogger(args) {
     const { ctx, body, toolCount, requestStart, tracer, account, attemptNumber } = args;
+    const attemptStartedAt = Date.now();
     return (status, errorType, errorMessage, extra) => {
+        const attemptCompletedAt = Date.now();
         const traceCtx = tracer?.getTraceContext();
         logRequestAttempt({
             timestamp: new Date().toISOString(),
@@ -3437,7 +3527,8 @@ function createAnthropicAttemptLogger(args) {
             account: account.label,
             accountType: account.type,
             responseStatus: status,
-            responseTimeMs: Date.now() - requestStart,
+            responseTimeMs: attemptCompletedAt - requestStart,
+            attemptDurationMs: extra?.attemptDurationMs ?? attemptCompletedAt - attemptStartedAt,
             ...(errorType ? { errorType } : {}),
             ...(errorMessage ? { errorMessage } : {}),
             ...(extra?.errorCode ? { errorCode: extra.errorCode } : {}),
@@ -4095,10 +4186,16 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                 attemptNumber: loopState.attemptNumber,
                 finalBodyStr: preparedAttempt.finalBodyStr,
                 upstreamSpan,
+                logAttempt,
                 logProxyBody,
                 logFinalRequest,
             });
             if ("retryNextAccount" in successResult) {
+                if (successResult.failure) {
+                    loopState.lastError = successResult.failure.message;
+                    loopState.sawRateLimit ||= successResult.failure.rateLimit;
+                    loopState.sawTransientFailure ||= !successResult.failure.rateLimit;
+                }
                 continue accountLoop;
             }
             return successResult.response;

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

@@ -12,6 +12,11 @@
  * provider/model pairs (e.g. "gpt-4o" -> vertex/gemini-2.5-pro).
  */
 import type { ModelRouterInterface, ProxyRuntimeConfigProvider, RouteGroup } from "../../types/index.js";
+declare function resolveStreamCancellationLifecycle(terminalStreamError: string | undefined): {
+    status: number;
+    errorType: string;
+    errorMessage: string;
+};
 /**
  * Create OpenAI-compatible proxy routes.
  *
@@ -27,3 +32,7 @@ import type { ModelRouterInterface, ProxyRuntimeConfigProvider, RouteGroup } fro
  * @returns RouteGroup with OpenAI-compatible endpoints.
  */
 export declare function createOpenAIProxyRoutes(modelRouter?: ModelRouterInterface, basePath?: string, loopbackPort?: number, runtimeConfigProvider?: ProxyRuntimeConfigProvider): RouteGroup;
+export declare const __testHooks: {
+    resolveStreamCancellationLifecycle: typeof resolveStreamCancellationLifecycle;
+};
+export {};

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

@@ -27,6 +27,19 @@ const LOOPBACK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes — long enough for slow
 // `createOpenAIProxyRoutes`'s third argument when the actual listener port is
 // known (e.g. when started from the CLI handler).
 const DEFAULT_LOOPBACK_PORT = 55669;
+function resolveStreamCancellationLifecycle(terminalStreamError) {
+    return terminalStreamError
+        ? {
+            status: 502,
+            errorType: "loopback_stream_error",
+            errorMessage: terminalStreamError,
+        }
+        : {
+            status: 499,
+            errorType: "client_cancelled",
+            errorMessage: "Client cancelled the OpenAI-compatible stream",
+        };
+}
 /**
  * Build an OpenAI-shaped error as a typed Response with the intended status.
  *
@@ -188,7 +201,8 @@ async function handleOpenAIToAnthropicBridge(args) {
                     await reader.cancel(reason);
                 }
                 finally {
-                    await finishLifecycle(499, "client_cancelled", "Client cancelled the OpenAI-compatible stream");
+                    const cancellation = resolveStreamCancellationLifecycle(terminalStreamError);
+                    await finishLifecycle(cancellation.status, cancellation.errorType, cancellation.errorMessage);
                 }
             },
         });
@@ -381,4 +395,5 @@ export function createOpenAIProxyRoutes(modelRouter, basePath = "", loopbackPort
         ],
     };
 }
+export const __testHooks = { resolveStreamCancellationLifecycle };
 //# sourceMappingURL=openaiProxyRoutes.js.map

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

@@ -791,6 +791,13 @@ export type ProxyStatusArgs = {
     format?: "text" | "json";
     quiet?: boolean;
 };
+/** Arguments accepted by `neurolink proxy analyze` */
+export type ProxyAnalyzeArgs = {
+    logsDir?: string;
+    since?: string;
+    format?: "text" | "json";
+    quiet?: boolean;
+};
 /** Arguments accepted by hidden `neurolink proxy guard` command */
 export type ProxyGuardArgs = {
     host?: string;