@juspay/neurolink 9.86.3 → 9.86.5

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

@@ -69,7 +69,7 @@ export type StoredProviderTokens = {
     disabled?: boolean;
     /** When the tokens were disabled (Unix ms) */
     disabledAt?: number;
-    /** Reason the tokens were disabled (e.g., "refresh_failed") */
+    /** Reason the tokens were disabled (e.g., "refresh_invalid") */
     disabledReason?: string;
 };
 /**

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

@@ -825,6 +825,8 @@ export type ProxyState = {
     envFile?: string;
     /** Fallback chain from proxy config (persisted at start time) */
     fallbackChain?: FallbackInfo[];
+    /** Normalized Anthropic account keys allowed for this proxy process. */
+    accountAllowlist?: string[];
     /** Optional fail-open guard PID that reverts Claude settings if proxy dies */
     guardPid?: number;
     /** How the proxy was launched — "launchd" if installed as service, "manual" otherwise */

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

@@ -517,6 +517,7 @@ export type AnthropicLoopState = {
         contentType?: string;
     } | null;
     authFailureMessage: string | null;
+    authCooldownMessage: string | null;
     attemptNumber: number;
 };
 export type AnthropicUpstreamBody = {
@@ -580,9 +581,9 @@ export type AccountCooldownPlan = {
     reason: AccountCoolingReason;
     /** Epoch-ms until which the account should not be used. */
     coolingUntil: number;
-    /** When true (5h/7d window rejected), rotate immediately — retrying the same
-     *  account is futile until its window resets. When false (transient burst),
-     *  a small number of jittered same-account retries is allowed first. */
+    /** When true (unified/5h/7d rejected), rotate immediately — retrying the
+     *  same account is futile until its window resets. When false (transient
+     *  burst), a small number of jittered same-account retries is allowed first. */
     rotateImmediately: boolean;
 };
 export type AnthropicUpstreamFetchResult = {
@@ -630,12 +631,22 @@ export type RefreshResult = {
     error?: string;
     status?: number;
 };
+/** Result shared by callers waiting on the same rotating refresh token. */
+export type SharedRefreshResult = {
+    result: RefreshResult;
+    token: string;
+    refreshToken?: string;
+    expiresAt?: number;
+};
 export type TokenPersistTarget = string | {
     credPath: string;
 } | {
     providerKey: string;
 };
 export type AccountQuota = {
+    /** Top-level unified status. A rejected value can be authoritative even
+     *  while both 5h and 7d sub-window statuses still report allowed. */
+    unifiedStatus?: string;
     /** 0.0-1.0  (from unified-5h-utilization) */
     sessionUsed: number;
     /** "allowed" | "throttled" | "rejected" */
@@ -658,9 +669,18 @@ export type AccountQuota = {
 /** Why an account is currently cooling. Drives cooldown duration and logging.
  *  - "weekly"    : 7d unified limit rejected — cool until the weekly reset.
  *  - "session"   : 5h unified limit rejected — cool until the session reset.
+ *  - "unified"   : top-level unified limit rejected — cool for retry-after.
  *  - "transient" : short per-minute/burst 429 — cool for retry-after only.
- *  - "auth"      : auth/refresh failures (reserved; currently rotate-only). */
-export type AccountCoolingReason = "weekly" | "session" | "transient" | "auth";
+ *  - "auth"      : transient refresh failure with bounded backoff. */
+export type AccountCoolingReason = "weekly" | "session" | "unified" | "transient" | "auth";
+/** Restart-safe cooldown snapshot for one account. */
+export type PersistedAccountCooldown = {
+    coolingUntil: number;
+    reason: AccountCoolingReason;
+    updatedAt: number;
+};
+/** Normalized Anthropic account keys eligible for proxy routing. */
+export type AccountAllowlist = ReadonlySet<string>;
 /** Runtime state for a proxy account. */
 export type RuntimeAccountState = {
     consecutiveRefreshFailures: number;
@@ -668,9 +688,9 @@ export type RuntimeAccountState = {
     lastToken?: string;
     lastRefreshToken?: string;
     /** Epoch-ms timestamp until which the account should not be used for new
-     *  requests. Set from the ACTUAL Anthropic reset window (5h/7d) on an
-     *  exhaustion 429, or from retry-after on a transient burst. Other requests
-     *  arriving during this window skip the account rather than hammering it. */
+     *  requests. Set from the actual Anthropic reset/retry window or from
+     *  bounded refresh backoff. Other requests arriving during this window skip
+     *  the account rather than hammering it. */
     coolingUntil?: number;
     /** Why the account is cooling (set alongside coolingUntil). */
     coolingReason?: AccountCoolingReason;
@@ -769,6 +789,8 @@ export type ProxyPaths = {
     logsDir: string;
     /** account-quotas.json — per-account rate limit state */
     quotaFile: string;
+    /** account-cooldowns.json — restart-safe account cooldown state */
+    cooldownFile: string;
     /** Whether this is a dev-mode isolated instance */
     isDev: boolean;
 };
@@ -958,8 +980,26 @@ export type SSETelemetry = {
         timestamp: number;
         data: string;
     }>;
+    /** Error carried as a terminal SSE `event: error`, if one was observed. */
+    streamErrorMessage?: string;
     rawText?: string;
 };
+/** Terminal outcome of a response body after the HTTP headers were sent. */
+export type StreamTerminalOutcome = {
+    kind: "completed";
+} | {
+    kind: "upstream_error";
+    message: string;
+} | {
+    kind: "client_cancelled";
+};
+/** First-writer-wins tracker for an upstream streaming response. */
+export type StreamTerminalOutcomeTracker = {
+    outcome: Promise<StreamTerminalOutcome>;
+    complete: () => void;
+    fail: (message: string) => void;
+    cancel: () => void;
+};
 /** Mutable accumulator the SSE interceptor uses internally. */
 export type TelemetryAccumulator = {
     messageId: string;
@@ -984,6 +1024,7 @@ export type TelemetryAccumulator = {
     rawTextBytes: number;
     rawTextTruncated: boolean;
     eventLogTruncated: boolean;
+    streamErrorMessage?: string;
 };
 /** Result of createSSEInterceptor: the pass-through stream and a telemetry promise. */
 export type SSEInterceptorResult = {

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

@@ -914,6 +914,11 @@ export type ProxyRoutingConfig = {
      *  Resolved per-request to a stable key (anthropic:<email>); does not
      *  encode an index. */
     primaryAccount?: string;
+    /** Anthropic account emails/labels that may be loaded by the proxy. When
+     *  present, every token-store, legacy, and environment credential outside
+     *  this set is excluded before refresh or routing. An empty list denies all
+     *  stored credentials. */
+    accountAllowlist?: string[];
 };
 /** Cloaking plugin config */
 export type CloakingConfig = {

package/dist/neurolink.js

@@ -3858,7 +3858,15 @@ Current user's request: ${currentInput}`;
             else {
                 try {
                     const scalar = JSON.parse(textResult.content);
-                    if (scalar !== null && scalar !== undefined) {
+                    if (scalar === "") {
+                        // A JSON-encoded empty string is an EMPTY completion, not a
+                        // recovered scalar — normalize to a true empty so callers'
+                        // empty-response handling fires instead of a literal '""'
+                        // reaching the user. `structuredData` stays undefined.
+                        textResult.content = "";
+                        logger.warn("[NeuroLink] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: textResult.provider, model: textResult.model });
+                    }
+                    else if (scalar !== null && scalar !== undefined) {
                         textResult.structuredData = scalar;
                     }
                 }

package/dist/proxy/accountCooldown.d.ts

@@ -0,0 +1,5 @@
+import type { AccountCoolingReason, PersistedAccountCooldown } from "../types/index.js";
+export declare function initAccountCooldown(cooldownFilePath: string): void;
+export declare function loadAccountCooldowns(): Promise<Record<string, PersistedAccountCooldown>>;
+export declare function saveAccountCooldown(accountKey: string, coolingUntil: number, reason: AccountCoolingReason): Promise<void>;
+export declare function clearAccountCooldown(accountKey: string, expectedCoolingUntil?: number): Promise<void>;

package/dist/proxy/accountCooldown.js

@@ -0,0 +1,92 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { AsyncMutex } from "../utils/asyncMutex.js";
+import { writeJsonSnapshotAtomically } from "./snapshotPersistence.js";
+const COOLDOWN_FILE = "account-cooldowns.json";
+const VALID_REASONS = new Set([
+    "weekly",
+    "session",
+    "unified",
+    "transient",
+    "auth",
+]);
+let customCooldownFilePath = null;
+let cacheLoaded = false;
+let cacheLoadPromise = null;
+let memoryCache = {};
+const mutationMutex = new AsyncMutex();
+export function initAccountCooldown(cooldownFilePath) {
+    customCooldownFilePath = cooldownFilePath;
+    cacheLoaded = false;
+    cacheLoadPromise = null;
+    memoryCache = {};
+}
+function getCooldownFilePath() {
+    return customCooldownFilePath ?? join(homedir(), ".neurolink", COOLDOWN_FILE);
+}
+function isPersistedCooldown(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.coolingUntil === "number" &&
+        Number.isFinite(candidate.coolingUntil) &&
+        typeof candidate.updatedAt === "number" &&
+        Number.isFinite(candidate.updatedAt) &&
+        typeof candidate.reason === "string" &&
+        VALID_REASONS.has(candidate.reason));
+}
+async function ensureAccountCooldownsLoaded() {
+    if (!cacheLoaded) {
+        if (!cacheLoadPromise) {
+            cacheLoadPromise = (async () => {
+                try {
+                    const parsed = JSON.parse(await readFile(getCooldownFilePath(), "utf8"));
+                    memoryCache = Object.fromEntries(Object.entries(parsed).filter((entry) => isPersistedCooldown(entry[1])));
+                }
+                catch {
+                    memoryCache = {};
+                }
+                cacheLoaded = true;
+            })().finally(() => {
+                cacheLoadPromise = null;
+            });
+        }
+        await cacheLoadPromise;
+    }
+}
+export async function loadAccountCooldowns() {
+    await ensureAccountCooldownsLoaded();
+    return mutationMutex.runExclusive(async () => ({ ...memoryCache }));
+}
+export async function saveAccountCooldown(accountKey, coolingUntil, reason) {
+    await mutationMutex.runExclusive(async () => {
+        await ensureAccountCooldownsLoaded();
+        const current = memoryCache[accountKey];
+        if (current && current.coolingUntil > coolingUntil) {
+            return;
+        }
+        memoryCache[accountKey] = {
+            coolingUntil,
+            reason,
+            updatedAt: Date.now(),
+        };
+        await writeJsonSnapshotAtomically(getCooldownFilePath(), memoryCache);
+    });
+}
+export async function clearAccountCooldown(accountKey, expectedCoolingUntil) {
+    await mutationMutex.runExclusive(async () => {
+        await ensureAccountCooldownsLoaded();
+        const current = memoryCache[accountKey];
+        if (!current) {
+            return;
+        }
+        if (expectedCoolingUntil !== undefined &&
+            current.coolingUntil !== expectedCoolingUntil) {
+            return;
+        }
+        delete memoryCache[accountKey];
+        await writeJsonSnapshotAtomically(getCooldownFilePath(), memoryCache);
+    });
+}

package/dist/proxy/accountQuota.d.ts

@@ -10,6 +10,8 @@
  * path is never blocked by file I/O.
  */
 import type { AccountQuota } from "../types/index.js";
+/** Read and normalize Anthropic's authoritative top-level unified status. */
+export declare function getUnifiedRateLimitStatus(headers: Headers | Record<string, string>): string | undefined;
 /**
  * Parse Anthropic rate-limit / quota headers into an `AccountQuota`.
  * Returns `null` when key headers are absent.
@@ -22,10 +24,6 @@ export declare function parseQuotaHeaders(headers: Headers | Record<string, stri
  * ~/.neurolink/account-quotas.json. Call before the first load/save.
  */
 export declare function initAccountQuota(quotaFilePath: string): void;
-/**
- * Load all persisted account quotas.
- * First call reads from disk; subsequent calls return the in-memory cache.
- */
 export declare function loadAccountQuotas(): Promise<Record<string, AccountQuota>>;
 /**
  * Load quota for a single account.
@@ -42,3 +40,4 @@ export declare function loadAccountQuota(accountKey: string): Promise<AccountQuo
  * other accounts' snapshots and blinded quota-aware routing to them).
  */
 export declare function saveAccountQuota(accountKey: string, quota: AccountQuota): Promise<void>;
+export declare function flushAccountQuotaStateForTests(): Promise<void>;

package/dist/proxy/accountQuota.js

@@ -9,9 +9,11 @@
  * updates an in-memory cache and debounces disk writes so the request/response
  * path is never blocked by file I/O.
  */
-import { dirname, join } from "path";
+import { join } from "path";
 import { homedir } from "os";
 import { promises as fs } from "fs";
+import { AsyncMutex } from "../utils/asyncMutex.js";
+import { writeJsonSnapshotAtomically } from "./snapshotPersistence.js";
 // ---------------------------------------------------------------------------
 // Header parsing (pure CPU — no I/O, safe for hot path)
 // ---------------------------------------------------------------------------
@@ -31,6 +33,12 @@ function getHeader(headers, name) {
     }
     return undefined;
 }
+/** Read and normalize Anthropic's authoritative top-level unified status. */
+export function getUnifiedRateLimitStatus(headers) {
+    const value = getHeader(headers, "anthropic-ratelimit-unified-status");
+    const normalized = value?.trim().toLowerCase();
+    return normalized || undefined;
+}
 /**
  * Parse Anthropic rate-limit / quota headers into an `AccountQuota`.
  * Returns `null` when key headers are absent.
@@ -53,6 +61,7 @@ export function parseQuotaHeaders(headers) {
     const weeklyResetRaw = getHeader(headers, `${P}unified-7d-reset`);
     const fallbackRaw = getHeader(headers, `${P}unified-fallback-percentage`);
     return {
+        unifiedStatus: getUnifiedRateLimitStatus(headers),
         sessionUsed,
         sessionStatus: getHeader(headers, `${P}unified-5h-status`) ?? "unknown",
         sessionResetAt: sessionResetRaw ? parseInt(sessionResetRaw, 10) || 0 : 0,
@@ -71,8 +80,12 @@ const QUOTA_FILE = "account-quotas.json";
 const FLUSH_INTERVAL_MS = 5_000; // write to disk at most every 5 seconds
 let memoryCache = {};
 let cacheLoaded = false;
+let cacheLoadPromise = null;
 let dirty = false;
+let cacheVersion = 0;
 let flushTimer = null;
+const stateMutex = new AsyncMutex();
+const flushMutex = new AsyncMutex();
 /** Custom quota file path set via initAccountQuota(). */
 let customQuotaFilePath = null;
 /**
@@ -91,41 +104,42 @@ export function initAccountQuota(quotaFilePath) {
     // Reset cache so the new path is picked up on next load
     memoryCache = {};
     cacheLoaded = false;
+    cacheLoadPromise = null;
     dirty = false;
+    cacheVersion = 0;
 }
 function getQuotaFilePath() {
     return customQuotaFilePath ?? join(homedir(), ".neurolink", QUOTA_FILE);
 }
-async function ensureDir() {
-    const filePath = getQuotaFilePath();
-    const dir = dirname(filePath);
-    await fs.mkdir(dir, { recursive: true, mode: 0o700 }).catch(() => {
-        // Non-fatal: directory may already exist
-    });
-}
 /** Flush the in-memory cache to disk (async, non-blocking). */
 async function flushToDisk() {
-    if (!dirty) {
-        return;
-    }
-    try {
-        // Snapshot before async I/O so we only clear dirty if nothing changed
-        const snapshot = JSON.stringify(memoryCache, null, 2);
-        await ensureDir();
-        const filePath = getQuotaFilePath();
-        const tmpPath = `${filePath}.tmp`;
-        await fs.writeFile(tmpPath, snapshot, {
-            mode: 0o600,
+    await flushMutex.runExclusive(async () => {
+        let snapshot;
+        let snapshotVersion = 0;
+        let filePath = "";
+        await stateMutex.runExclusive(async () => {
+            if (!dirty) {
+                return;
+            }
+            snapshot = Object.fromEntries(Object.entries(memoryCache).map(([key, quota]) => [key, { ...quota }]));
+            snapshotVersion = cacheVersion;
+            filePath = getQuotaFilePath();
         });
-        await fs.rename(tmpPath, filePath);
-        // Only clear dirty if the cache hasn't changed during the write
-        if (JSON.stringify(memoryCache, null, 2) === snapshot) {
-            dirty = false;
+        if (!snapshot) {
+            return;
         }
-    }
-    catch {
-        // Non-fatal — quota is best-effort telemetry
-    }
+        try {
+            await writeJsonSnapshotAtomically(filePath, snapshot, 0o600);
+            await stateMutex.runExclusive(async () => {
+                if (cacheVersion === snapshotVersion) {
+                    dirty = false;
+                }
+            });
+        }
+        catch {
+            // Non-fatal — quota is best-effort telemetry
+        }
+    });
 }
 function scheduleFlush() {
     if (flushTimer) {
@@ -149,19 +163,28 @@ function scheduleFlush() {
  * Load all persisted account quotas.
  * First call reads from disk; subsequent calls return the in-memory cache.
  */
-export async function loadAccountQuotas() {
-    if (cacheLoaded) {
-        return { ...memoryCache };
-    }
-    try {
-        const raw = await fs.readFile(getQuotaFilePath(), "utf-8");
-        memoryCache = JSON.parse(raw);
-    }
-    catch {
-        memoryCache = {};
+async function ensureAccountQuotasLoaded() {
+    if (!cacheLoaded) {
+        if (!cacheLoadPromise) {
+            cacheLoadPromise = (async () => {
+                try {
+                    const raw = await fs.readFile(getQuotaFilePath(), "utf-8");
+                    memoryCache = JSON.parse(raw);
+                }
+                catch {
+                    memoryCache = {};
+                }
+                cacheLoaded = true;
+            })().finally(() => {
+                cacheLoadPromise = null;
+            });
+        }
+        await cacheLoadPromise;
     }
-    cacheLoaded = true;
-    return { ...memoryCache };
+}
+export async function loadAccountQuotas() {
+    await ensureAccountQuotasLoaded();
+    return stateMutex.runExclusive(async () => ({ ...memoryCache }));
 }
 /**
  * Load quota for a single account.
@@ -181,10 +204,18 @@ export async function loadAccountQuota(accountKey) {
  * other accounts' snapshots and blinded quota-aware routing to them).
  */
 export async function saveAccountQuota(accountKey, quota) {
-    if (!cacheLoaded) {
-        await loadAccountQuotas();
-    }
-    memoryCache[accountKey] = quota;
-    dirty = true;
+    await stateMutex.runExclusive(async () => {
+        await ensureAccountQuotasLoaded();
+        memoryCache[accountKey] = { ...quota };
+        dirty = true;
+        cacheVersion += 1;
+    });
     scheduleFlush();
 }
+export async function flushAccountQuotaStateForTests() {
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    await flushToDisk();
+}

package/dist/proxy/accountSelection.d.ts

@@ -0,0 +1,8 @@
+import type { AccountAllowlist } from "../types/index.js";
+export declare const LEGACY_ANTHROPIC_ACCOUNT_KEY = "anthropic:legacy-default";
+export declare const ENV_ANTHROPIC_ACCOUNT_KEY = "anthropic:env";
+export declare function normalizeAnthropicAccountKey(value: string): string;
+export declare function anthropicAccountKeysEqual(left: string, right: string): boolean;
+export declare function createAccountAllowlist(values?: readonly string[]): AccountAllowlist | undefined;
+export declare function isAccountAllowed(accountKey: string, allowlist?: AccountAllowlist): boolean;
+export declare function shouldLoadFallbackCredential(storedAnthropicAccountCount: number, fallbackAccountKey: string, allowlist?: AccountAllowlist): boolean;

package/dist/proxy/accountSelection.js

@@ -0,0 +1,25 @@
+export const LEGACY_ANTHROPIC_ACCOUNT_KEY = "anthropic:legacy-default";
+export const ENV_ANTHROPIC_ACCOUNT_KEY = "anthropic:env";
+export function normalizeAnthropicAccountKey(value) {
+    const trimmed = value.trim().toLowerCase();
+    return trimmed.startsWith("anthropic:") ? trimmed : `anthropic:${trimmed}`;
+}
+export function anthropicAccountKeysEqual(left, right) {
+    return (normalizeAnthropicAccountKey(left) === normalizeAnthropicAccountKey(right));
+}
+export function createAccountAllowlist(values) {
+    if (values === undefined) {
+        return undefined;
+    }
+    return new Set(values
+        .map(normalizeAnthropicAccountKey)
+        .filter((value) => value !== "anthropic:"));
+}
+export function isAccountAllowed(accountKey, allowlist) {
+    return (allowlist === undefined ||
+        allowlist.has(normalizeAnthropicAccountKey(accountKey)));
+}
+export function shouldLoadFallbackCredential(storedAnthropicAccountCount, fallbackAccountKey, allowlist) {
+    return (storedAnthropicAccountCount === 0 &&
+        isAccountAllowed(fallbackAccountKey, allowlist));
+}

package/dist/proxy/proxyConfig.js

@@ -212,6 +212,22 @@ export function validateProxyConfig(config) {
         errors.push('"routing" must be an object');
         return errors;
     }
+    if (hasRouting) {
+        const routing = cfg.routing;
+        const rawAccountAllowlist = routing["account-allowlist"] ?? routing.accountAllowlist;
+        if (rawAccountAllowlist !== undefined) {
+            if (!Array.isArray(rawAccountAllowlist)) {
+                errors.push("routing.account-allowlist must be an array of non-empty strings");
+            }
+            else {
+                rawAccountAllowlist.forEach((entry, index) => {
+                    if (typeof entry !== "string" || entry.trim() === "") {
+                        errors.push(`routing.account-allowlist[${index}] must be a non-empty string`);
+                    }
+                });
+            }
+        }
+    }
     if (!hasAccounts && !hasRouting) {
         errors.push('Config must contain at least one of "accounts" or "routing"');
         return errors;
@@ -280,6 +296,7 @@ function warnPlaintextApiKeys(accounts) {
  * - `model-mappings` / `modelMappings` — array of {from, to, provider}
  * - `fallback-chain` / `fallbackChain` — array of {provider, model}
  * - `passthroughModels` / `passthrough-models` — array of model IDs
+ * - `account-allowlist` / `accountAllowlist` — allowed Anthropic account IDs
  *
  * Accepts both camelCase and kebab-case keys for YAML-friendliness.
  */
@@ -350,6 +367,13 @@ function parseRoutingConfig(raw) {
                 `string, got ${typeof rawPrimary}`);
         }
     }
+    const rawAccountAllowlist = (raw["account-allowlist"] ??
+        raw.accountAllowlist);
+    if (Array.isArray(rawAccountAllowlist)) {
+        result.accountAllowlist = [
+            ...new Set(rawAccountAllowlist.map((entry) => String(entry).trim())),
+        ];
+    }
     return result;
 }
 // ---------------------------------------------------------------------------

package/dist/proxy/proxyPaths.js

@@ -21,6 +21,7 @@ export function resolveProxyPaths(dev) {
             stateDir: base,
             logsDir: join(base, "logs"),
             quotaFile: join(base, "account-quotas.json"),
+            cooldownFile: join(base, "account-cooldowns.json"),
             isDev: true,
         };
     }
@@ -29,6 +30,7 @@ export function resolveProxyPaths(dev) {
         stateDir: base,
         logsDir: join(base, "logs"),
         quotaFile: join(base, "account-quotas.json"),
+        cooldownFile: join(base, "account-cooldowns.json"),
         isDev: false,
     };
 }

package/dist/proxy/requestLogger.js

@@ -594,6 +594,8 @@ export async function logStreamError(entry) {
     const logEntry = {
         ...entry,
         responseStatus: 200,
+        terminalStatus: 502,
+        terminalOutcome: "stream_error",
         errorType: "stream_error",
         note: "mid-stream failure after initial 200",
     };

package/dist/proxy/snapshotPersistence.js

@@ -5,7 +5,7 @@ const writeLocks = new Map();
 async function writeSnapshotFile(targetPath, payload, mode) {
     const dir = dirname(targetPath);
     const baseName = basename(targetPath);
-    await mkdir(dir, { recursive: true });
+    await mkdir(dir, { recursive: true, mode: 0o700 });
     const tempPath = join(dir, `.${baseName}.${process.pid}.${randomUUID()}.tmp`);
     try {
         await writeFile(tempPath, payload, { mode });

package/dist/proxy/sseInterceptor.js

@@ -185,6 +185,9 @@ function finalize(acc) {
         streamDurationMs: Date.now() - acc.startTime,
         totalBytesReceived: acc.totalBytesReceived,
         events: acc.events,
+        ...(acc.streamErrorMessage
+            ? { streamErrorMessage: acc.streamErrorMessage }
+            : {}),
         ...(acc.rawTextChunks ? { rawText: acc.rawTextChunks.join("") } : {}),
     };
 }
@@ -323,6 +326,19 @@ function processEvent(acc, event) {
         // Malformed JSON — skip silently, bytes already forwarded to client
         return;
     }
+    if (event.event === "error") {
+        const payload = parsed && typeof parsed === "object"
+            ? parsed
+            : {};
+        const nestedError = payload.error && typeof payload.error === "object"
+            ? payload.error
+            : undefined;
+        const message = nestedError?.message ?? payload.message;
+        acc.streamErrorMessage =
+            typeof message === "string" && message.trim()
+                ? message.trim()
+                : truncateString(event.data, MAX_EVENT_DATA_BYTES);
+    }
     switch (event.event) {
         case "message_start":
             processMessageStart(acc, parsed);

package/dist/proxy/streamOutcome.d.ts

@@ -0,0 +1,3 @@
+import type { StreamTerminalOutcome, StreamTerminalOutcomeTracker } from "../types/index.js";
+export declare function createStreamTerminalOutcomeTracker(): StreamTerminalOutcomeTracker;
+export declare function mergeStreamTerminalOutcome(outcome: StreamTerminalOutcome, sseErrorMessage?: string): StreamTerminalOutcome;

package/dist/proxy/streamOutcome.js

@@ -0,0 +1,26 @@
+export function createStreamTerminalOutcomeTracker() {
+    let settled = false;
+    let resolveOutcome;
+    const outcome = new Promise((resolve) => {
+        resolveOutcome = resolve;
+    });
+    const settle = (value) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        resolveOutcome(value);
+    };
+    return {
+        outcome,
+        complete: () => settle({ kind: "completed" }),
+        fail: (message) => settle({ kind: "upstream_error", message }),
+        cancel: () => settle({ kind: "client_cancelled" }),
+    };
+}
+export function mergeStreamTerminalOutcome(outcome, sseErrorMessage) {
+    if (outcome.kind === "completed" && sseErrorMessage) {
+        return { kind: "upstream_error", message: sseErrorMessage };
+    }
+    return outcome;
+}