@juspay/neurolink 12.7.3 → 12.7.5

package/dist/cli/commands/proxy.js

@@ -24,7 +24,7 @@ import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serv
 import { configureProxyKeepAliveDispatcher } from "../../proxy/proxyDispatcher.js";
 import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 import { startProxyLogCleanupScheduler } from "../../proxy/logCleanupScheduler.js";
-import { anthropicAccountKeysEqual, createAccountAllowlist, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
+import { anthropicAccountKeysEqual, createAccountAllowlist, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage.js";
 import { beginProxyRequest, getProxyActivitySnapshot, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
@@ -66,11 +66,9 @@ const gatedShareRequests = new WeakSet();
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
 /** How long shutdown waits on the share listener before moving on. */
 const SHARE_LISTENER_CLOSE_TIMEOUT_MS = 10_000;
-const LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS = 5_000;
 const PROXY_STATUS_TOKEN_READ_TIMEOUT_MS = 2_000;
 const PROXY_STATUS_RECONCILE_TIMEOUT_MS = 750;
 const PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS = 750;
-let legacyStatusAccountCache;
 // Allowed drift between a pid's OS-reported start time and the persisted
 // ProxySupervisorState.startTime before processLooksLikeProxySupervisor
 // treats it as a confident mismatch (recycled pid). Generous on purpose:
@@ -386,34 +384,6 @@ async function resolveStatusPrimaryAccount(proxyConfig) {
         source: "fallback",
     };
 }
-async function resolveLegacyStatusAccountLabel(storedAnthropicAccountCount) {
-    if (storedAnthropicAccountCount !== 0) {
-        return null;
-    }
-    const credentialsPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
-    const now = Date.now();
-    if (legacyStatusAccountCache?.credentialsPath === credentialsPath &&
-        legacyStatusAccountCache.expiresAt > now) {
-        return legacyStatusAccountCache.label;
-    }
-    let label = null;
-    try {
-        const { readFile } = await import("node:fs/promises");
-        const parsed = JSON.parse(await readFile(credentialsPath, "utf8"));
-        if (parsed.oauth?.accessToken) {
-            label = parsed.email?.trim() || "legacy-default";
-        }
-    }
-    catch {
-        label = null;
-    }
-    legacyStatusAccountCache = {
-        credentialsPath,
-        expiresAt: now + LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS,
-        label,
-    };
-    return label;
-}
 function deriveAccountAllowance(accountKey, now, allowlist, expirations, cooldowns) {
     const allowed = isAccountAllowed(accountKey, allowlist);
     const expiresAt = expirations.get(accountKey);
@@ -1067,6 +1037,7 @@ function redactStatusAccounts(rows, allowed) {
     return rows.map((row, index) => ({
         ...row,
         label: `account-${index + 1}`,
+        ...(row.key !== undefined ? { key: null } : {}),
         ...(row.email !== undefined ? { email: null } : {}),
     }));
 }
@@ -1686,21 +1657,28 @@ export async function createProxyStartApp(params) {
             logger.debug(`[proxy] /status using empty cooldown snapshot: ${error instanceof Error ? error.message : String(error)}`);
             return {};
         });
-        const storedAccountKeys = new Set();
+        const storedAnthropicAccountKeys = new Set();
+        const storedCodexAccountKeys = new Set();
         const storedAccountExpirations = new Map();
-        const disabledAccountKeys = new Set();
         const disabledProviderAccountKeys = new Set();
         let accountInventoryLoaded = false;
         try {
             const { tokenStore } = await import("../../auth/tokenStore.js");
-            const storedKeys = await withTimeout(tokenStore.listByPrefix("anthropic:"), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account enumeration timed out");
-            for (const key of storedKeys) {
-                storedAccountKeys.add(normalizeAnthropicAccountKey(key));
+            const [anthropicKeys, codexKeys] = await withTimeout(Promise.all([
+                tokenStore.listByPrefix("anthropic:"),
+                tokenStore.listByPrefix("codex:"),
+            ]), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account enumeration timed out");
+            for (const key of anthropicKeys) {
+                storedAnthropicAccountKeys.add(normalizeAnthropicAccountKey(key));
+            }
+            for (const key of codexKeys) {
+                storedCodexAccountKeys.add(key);
             }
             // Once account names are known, preserve them even when optional token
             // metadata is slow. That keeps the status table useful and avoids
             // incorrectly presenting known accounts as removed.
             accountInventoryLoaded = true;
+            const storedKeys = [...anthropicKeys, ...codexKeys];
             const inventory = await withTimeout((async () => {
                 const tokenExpirations = await Promise.all(storedKeys.map(async (key) => {
                     try {
@@ -1717,20 +1695,21 @@ export async function createProxyStartApp(params) {
             })(), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account metadata timed out");
             for (const expiration of inventory.tokenExpirations) {
                 if (expiration) {
-                    storedAccountExpirations.set(normalizeAnthropicAccountKey(expiration[0]), expiration[1]);
+                    const key = expiration[0].startsWith("anthropic:")
+                        ? normalizeAnthropicAccountKey(expiration[0])
+                        : expiration[0];
+                    storedAccountExpirations.set(key, expiration[1]);
                 }
             }
             for (const key of inventory.disabledKeys) {
-                disabledAccountKeys.add(normalizeAnthropicAccountKey(key));
-                disabledProviderAccountKeys.add(key);
+                disabledProviderAccountKeys.add(key.startsWith("anthropic:")
+                    ? normalizeAnthropicAccountKey(key)
+                    : key);
             }
         }
         catch (err) {
             logger.debug(`[proxy] /status: failed to resolve account cooldown labels: ${err instanceof Error ? err.message : String(err)}`);
         }
-        const legacyAccountLabel = accountInventoryLoaded
-            ? await withTimeout(resolveLegacyStatusAccountLabel(storedAccountKeys.size), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status legacy account inspection timed out").catch(() => null)
-            : null;
         const now = Date.now();
         const health = buildProxyHealthResponse(readiness, {
             strategy: activeStrategy,
@@ -1744,52 +1723,54 @@ export async function createProxyStartApp(params) {
             source: "fallback",
         }));
         const activeUpdaterPid = supervisorState?.updaterPid ?? runtimeState?.updaterPid;
-        const accountRows = Object.values(stats.accounts).map((account) => {
-            const identity = resolveProxyStatusAccountIdentity(account.label, account.type);
+        const accountRows = Object.entries(stats.accounts).map(([persistedMapKey, account]) => {
+            // Legacy snapshots used their bare map key as an inferred identity. Do
+            // not map those old rows to a provider based on an email: the same email
+            // can be present in both pools. New records carry account.key.
+            const persistedKey = account.key ?? null;
+            const identity = persistedKey
+                ? resolveProxyStatusAccountIdentity(account.label, account.type, persistedKey)
+                : { provider: "other", key: null };
+            const isLegacyUnattributed = persistedKey === null &&
+                (account.type === "oauth" ||
+                    account.type === "api_key" ||
+                    account.type === "codex-oauth");
             const isAnthropicAccount = identity.provider === "anthropic";
             const isCodexAccount = identity.provider === "codex";
-            const normalizedKey = identity.provider === "anthropic" ? identity.key : null;
-            const isLegacyAccount = isAnthropicAccount && account.label === legacyAccountLabel;
-            const accountKey = isAnthropicAccount
-                ? storedAccountKeys.has(normalizedKey ?? "")
-                    ? normalizedKey
-                    : isLegacyAccount
-                        ? LEGACY_ANTHROPIC_ACCOUNT_KEY
-                        : account.label === "env"
-                            ? ENV_ANTHROPIC_ACCOUNT_KEY
-                            : normalizedKey
-                : identity.key;
-            const isStored = isAnthropicAccount &&
-                accountKey !== null &&
-                (storedAccountKeys.has(accountKey) || isLegacyAccount);
-            const { allowed, expired, cooling } = isAnthropicAccount && accountKey !== null
+            const accountKey = identity.key ?? (persistedKey || persistedMapKey);
+            const isStored = (isAnthropicAccount && storedAnthropicAccountKeys.has(accountKey)) ||
+                (isCodexAccount && storedCodexAccountKeys.has(accountKey));
+            const providerState = isAnthropicAccount
                 ? deriveAccountAllowance(accountKey, now, activeAccountAllowlist, storedAccountExpirations, cooldowns)
-                : {
-                    allowed: true,
-                    expired: false,
-                    cooling: accountKey !== null &&
-                        (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
-                };
-            const isDisabled = (isAnthropicAccount &&
-                accountKey !== null &&
-                disabledAccountKeys.has(accountKey)) ||
-                (isCodexAccount &&
-                    accountKey !== null &&
-                    disabledProviderAccountKeys.has(accountKey));
+                : isCodexAccount
+                    ? {
+                        allowed: true,
+                        expired: (storedAccountExpirations.get(accountKey) ?? 0) > 0 &&
+                            (storedAccountExpirations.get(accountKey) ?? 0) <= now,
+                        cooling: (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
+                    }
+                    : { allowed: true, expired: false, cooling: false };
+            const isDisabled = !isLegacyUnattributed && disabledProviderAccountKeys.has(accountKey);
             const accountStatus = account.type === "internal"
                 ? "internal"
-                : isDisabled
-                    ? "disabled"
-                    : isAnthropicAccount && expired
-                        ? "expired"
-                        : isAnthropicAccount && !allowed
-                            ? "excluded"
-                            : accountInventoryLoaded && isAnthropicAccount && !isStored
-                                ? "removed"
-                                : cooling
-                                    ? "cooling"
-                                    : "active";
+                : isLegacyUnattributed
+                    ? "unattributed"
+                    : isDisabled
+                        ? "disabled"
+                        : providerState.expired
+                            ? "expired"
+                            : isAnthropicAccount && !providerState.allowed
+                                ? "excluded"
+                                : accountInventoryLoaded &&
+                                    (isAnthropicAccount || isCodexAccount) &&
+                                    !isStored
+                                    ? "removed"
+                                    : providerState.cooling
+                                        ? "cooling"
+                                        : "active";
             return {
+                key: isLegacyUnattributed ? null : accountKey,
+                provider: isLegacyUnattributed ? "unknown" : identity.provider,
                 label: account.label,
                 type: account.type,
                 attempts: account.attemptCount,
@@ -1800,21 +1781,26 @@ export async function createProxyStartApp(params) {
                 rateLimits: account.rateLimitCount,
                 transientRateLimits: account.transientRateLimitCount,
                 quotaRateLimits: account.quotaRateLimitCount,
-                cooling,
+                cooling: providerState.cooling,
                 status: accountStatus,
-                allowed: account.type === "internal" ? undefined : allowed,
-                expired: isAnthropicAccount ? expired : undefined,
+                allowed: account.type === "internal" ? undefined : providerState.allowed,
+                expired: isAnthropicAccount || isCodexAccount
+                    ? providerState.expired
+                    : undefined,
             };
         });
-        const representedAccountKeys = new Set(accountRows
-            .filter((account) => account.type === "oauth" || account.type === "api_key")
-            .map((account) => normalizeAnthropicAccountKey(account.label)));
-        for (const accountKey of storedAccountKeys) {
+        const representedAccountKeys = new Set(accountRows.flatMap((account) => account.key &&
+            (account.provider === "anthropic" || account.provider === "codex")
+            ? [account.key]
+            : []));
+        for (const accountKey of storedAnthropicAccountKeys) {
             if (representedAccountKeys.has(accountKey)) {
                 continue;
             }
             const { allowed, expired, cooling } = deriveAccountAllowance(accountKey, now, activeAccountAllowlist, storedAccountExpirations, cooldowns);
             accountRows.push({
+                key: accountKey,
+                provider: "anthropic",
                 label: accountKey.slice("anthropic:".length),
                 type: "oauth",
                 attempts: 0,
@@ -1826,7 +1812,7 @@ export async function createProxyStartApp(params) {
                 transientRateLimits: 0,
                 quotaRateLimits: 0,
                 cooling,
-                status: disabledAccountKeys.has(accountKey)
+                status: disabledProviderAccountKeys.has(accountKey)
                     ? "disabled"
                     : expired
                         ? "expired"
@@ -1839,6 +1825,38 @@ export async function createProxyStartApp(params) {
                 expired,
             });
         }
+        for (const accountKey of storedCodexAccountKeys) {
+            if (representedAccountKeys.has(accountKey)) {
+                continue;
+            }
+            const expiresAt = storedAccountExpirations.get(accountKey);
+            const expired = expiresAt !== undefined && expiresAt > 0 && expiresAt <= now;
+            const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
+            accountRows.push({
+                key: accountKey,
+                provider: "codex",
+                label: accountKey.slice("codex:".length),
+                type: "codex-oauth",
+                attempts: 0,
+                requests: 0,
+                success: 0,
+                errors: 0,
+                attemptErrors: 0,
+                rateLimits: 0,
+                transientRateLimits: 0,
+                quotaRateLimits: 0,
+                cooling,
+                status: disabledProviderAccountKeys.has(accountKey)
+                    ? "disabled"
+                    : expired
+                        ? "expired"
+                        : cooling
+                            ? "cooling"
+                            : "active",
+                allowed: true,
+                expired,
+            });
+        }
         const attributed = accountRows.reduce((total, account) => ({
             attempts: total.attempts + (account.attempts ?? 0),
             requests: total.requests + (account.requests ?? 0),
@@ -3031,7 +3049,8 @@ function printStatusStats(stats) {
         if (lastError) {
             const cause = lastError.errorType ?? lastError.category;
             const code = lastError.errorCode ? `/${lastError.errorCode}` : "";
-            const account = lastError.account ? ` account=${lastError.account}` : "";
+            const accountIdentity = lastError.accountKey ?? lastError.account;
+            const account = accountIdentity ? ` account=${accountIdentity}` : "";
             console.info(`    Last error:  ${new Date(lastError.at).toISOString()} ${cause}${code} status=${lastError.status}${account}`);
             if (lastError.message) {
                 console.info(`    Last cause:  ${sanitizeProxyStatusTerminalErrorMessage(lastError.message)}`);

package/dist/cli/factories/authCommandFactory.js

@@ -6,10 +6,8 @@
  * - login, logout, status, refresh: Anthropic OAuth (API key + OAuth)
  * - providers, validate, health: Multi-provider auth management
  */
-/**
- * Supported providers for authentication
- */
-const SUPPORTED_PROVIDERS = ["anthropic", "codex"];
+/** Providers with first-class credential flows in `neurolink auth`. */
+const AUTH_LOGIN_PROVIDERS = ["anthropic", "codex"];
 /**
  * Auth Command Factory
  *
@@ -167,7 +165,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to authenticate with",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
             demandOption: true,
         })
             .option("method", {
@@ -204,7 +202,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to log out from",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
             demandOption: true,
         })
             .example("$0 auth logout anthropic", "Clear all Anthropic credentials");
@@ -217,7 +215,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to check (optional, shows all if not specified)",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
         })
             .example("$0 auth status", "Show status for all configured providers")
             .example("$0 auth status anthropic", "Show Anthropic authentication status")
@@ -231,7 +229,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to refresh tokens for",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
             demandOption: true,
         })
             .example("$0 auth refresh anthropic", "Refresh Anthropic OAuth tokens");
@@ -244,7 +242,7 @@ export class AuthCommandFactory {
             .option("refresh", {
             type: "boolean",
             default: false,
-            description: "Fetch fresh limits from Anthropic for all OAuth accounts before listing (via the running proxy when available)",
+            description: "Refresh available provider limits for authenticated accounts; show unsupported providers explicitly",
         })
             .example("$0 auth list", "List all authenticated accounts")
             .example("$0 auth list --format json", "List accounts in JSON format")
@@ -257,8 +255,7 @@ export class AuthCommandFactory {
         return yargs
             .positional("provider", {
             type: "string",
-            description: "AI provider to remove account from",
-            choices: SUPPORTED_PROVIDERS,
+            description: "Provider namespace to remove an account from",
             demandOption: true,
         })
             .option("label", {

package/dist/memory/memoryRetrievalTools.d.ts

@@ -1,13 +1,16 @@
+import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.js";
 import type { ArtifactStore, Tool } from "../types/index.js";
 /**
  * Factory function that creates memory retrieval tools bound to a memory manager.
  *
- * @param memoryManager  Redis conversation memory manager instance.
+ * @param memoryManager  Conversation memory manager instance. Session history
+ *                       retrieval requires the Redis-backed manager; with the
+ *                       in-memory manager the tool returns a descriptive error.
  * @param artifactStore  Optional artifact store for externalized MCP outputs.
  *                       When provided, retrieve_context gains an `artifactId`
  *                       parameter that fetches the full payload written by
  *                       McpOutputNormalizer under strategy="externalize".
  * @returns Record of tool name to Vercel AI SDK tool definition
  */
-export declare function createMemoryRetrievalTools(memoryManager: RedisConversationMemoryManager | undefined, artifactStore?: ArtifactStore): Record<string, Tool>;
+export declare function createMemoryRetrievalTools(memoryManager: ConversationMemoryManager | RedisConversationMemoryManager | undefined, artifactStore?: ArtifactStore): Record<string, Tool>;

package/dist/memory/memoryRetrievalTools.js

@@ -15,7 +15,9 @@ const MAX_SEARCH_MATCHES = 50;
 /**
  * Factory function that creates memory retrieval tools bound to a memory manager.
  *
- * @param memoryManager  Redis conversation memory manager instance.
+ * @param memoryManager  Conversation memory manager instance. Session history
+ *                       retrieval requires the Redis-backed manager; with the
+ *                       in-memory manager the tool returns a descriptive error.
  * @param artifactStore  Optional artifact store for externalized MCP outputs.
  *                       When provided, retrieve_context gains an `artifactId`
  *                       parameter that fetches the full payload written by
@@ -146,10 +148,16 @@ async function executeRetrieveContext(args, memoryManager, artifactStore, otelSp
             error: "sessionId is required when artifactId is not provided",
         };
     }
-    if (!memoryManager) {
+    // getSessionRaw exists only on the Redis-backed manager. A truthy manager
+    // can still be the in-memory one (tool registered for an artifact store, or
+    // Redis init fell back to in-memory), so guard on capability — not just
+    // presence — instead of throwing "getSessionRaw is not a function".
+    if (!memoryManager || !("getSessionRaw" in memoryManager)) {
         otelSpan.setStatus({
             code: SpanStatusCode.ERROR,
-            message: "Memory manager not configured",
+            message: memoryManager
+                ? "Conversation memory backend is not Redis"
+                : "Memory manager not configured",
         });
         return {
             error: "Session history retrieval requires Redis conversation memory — " +

package/dist/neurolink.js

@@ -1401,10 +1401,11 @@ export class NeuroLink {
             inputSchema: retrieveContextDef.inputSchema,
             execute: async (params) => {
                 // Lazy: conversationMemory is initialized on the first generate() call.
-                // When only an artifact store is present (no Redis), memoryManager is
-                // undefined — createMemoryRetrievalTools handles that via an explicit guard.
-                const memoryManager = this.conversationMemory;
-                const tools = createMemoryRetrievalTools(memoryManager, this.mcpArtifactStore);
+                // It may be undefined (artifact-store-only), the Redis manager, or the
+                // in-memory manager (no Redis config, or Redis init fell back) —
+                // createMemoryRetrievalTools guards session retrieval on getSessionRaw
+                // capability and returns a descriptive error otherwise.
+                const tools = createMemoryRetrievalTools(this.conversationMemory ?? undefined, this.mcpArtifactStore);
                 // Return the result directly so the LLM receives clean output instead
                 // of a nested { success, data, metadata } wrapper.
                 // Bounded by TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS so a stalled Redis or

package/dist/proxy/codexAccountUsage.d.ts

@@ -12,7 +12,7 @@ export declare const CODEX_ACCOUNT_PREFIX = "codex:";
 /** Keep an account label in the Codex namespace used by its token store. */
 export declare function normalizeCodexAccountKey(value: string): string;
 /** Resolve the provider-qualified key used to render a proxy status row. */
-export declare function resolveProxyStatusAccountIdentity(label: string, type: string): CodexProxyStatusAccountIdentity;
+export declare function resolveProxyStatusAccountIdentity(label: string, type: string, persistedKey?: string): CodexProxyStatusAccountIdentity;
 /** Enumerate Codex OAuth accounts from the token store for usage refresh. */
 export declare function listCodexAccountsForUsage(): Promise<ProxyPassthroughAccount[]>;
 /** Normalise a Codex rate-limit block into the shared AccountQuota shape. */

package/dist/proxy/codexAccountUsage.js

@@ -19,7 +19,19 @@ export function normalizeCodexAccountKey(value) {
         : `${CODEX_ACCOUNT_PREFIX}${trimmed}`;
 }
 /** Resolve the provider-qualified key used to render a proxy status row. */
-export function resolveProxyStatusAccountIdentity(label, type) {
+export function resolveProxyStatusAccountIdentity(label, type, persistedKey) {
+    // Current counter snapshots persist the provider-qualified key. Prefer it
+    // over the display type so a future type rename cannot move an account into
+    // the wrong cooldown/disabled namespace.
+    if (persistedKey?.toLowerCase().startsWith("anthropic:")) {
+        return {
+            provider: "anthropic",
+            key: normalizeAnthropicAccountKey(persistedKey),
+        };
+    }
+    if (persistedKey?.startsWith(CODEX_ACCOUNT_PREFIX)) {
+        return { provider: "codex", key: persistedKey };
+    }
     if (type === "oauth" || type === "api_key") {
         return { provider: "anthropic", key: normalizeAnthropicAccountKey(label) };
     }

package/dist/proxy/proxyActivity.js

@@ -63,6 +63,13 @@ export function trackProxyResponse(response, finishRequest, observer) {
     let observedBodyBytes = 0;
     let responseChunks = 0;
     let settled = false;
+    let sourceClosed = false;
+    // A framework can cancel its adapter after the upstream stream has already
+    // closed. Snapshot reader.closed before cancel() so that normal cleanup is
+    // not recorded as a client-aborted request.
+    void reader.closed.then(() => {
+        sourceClosed = true;
+    }, () => undefined);
     const settle = (outcome) => {
         if (settled) {
             return;
@@ -100,7 +107,11 @@ export function trackProxyResponse(response, finishRequest, observer) {
             }
         },
         async cancel(reason) {
-            settle("client_cancelled");
+            // Read the state before cancelling: reader.cancel() itself rejects the
+            // closed promise for a genuinely active source, which is too late to
+            // distinguish it from a source that had already ended normally.
+            await Promise.resolve();
+            settle(sourceClosed ? "completed" : "client_cancelled");
             await withTimeout(reader.cancel(reason), PROXY_RESPONSE_CANCEL_TIMEOUT_MS, "Timed out cancelling the upstream proxy response");
         },
     });

package/dist/proxy/usageStats.d.ts

@@ -40,7 +40,7 @@ export declare class ProxyUsageStatsStore {
     recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
     recordFinalError(status: number, accountLabel?: string, accountType?: string, details?: ProxyTerminalErrorDetails): void;
     getStats(): ProxyStats;
-    getAccountStats(label: string): AccountStats | undefined;
+    getAccountStats(label: string, type?: string): AccountStats | undefined;
     getTerminalErrors(): ProxyTerminalErrorJournal;
     getUsageSnapshot(): ProxyUsageStatsSnapshot;
     getPersistenceStatus(): ProxyStatsPersistenceStatus;
@@ -81,7 +81,7 @@ export declare function getStats(): ProxyStats;
 export declare function getUsageSnapshot(): ProxyUsageStatsSnapshot;
 export declare function getReconciledStats(): Promise<ProxyStats>;
 export declare function getReconciledUsageSnapshot(): Promise<ProxyUsageStatsSnapshot>;
-export declare function getAccountStats(label: string): AccountStats | undefined;
+export declare function getAccountStats(label: string, type?: string): AccountStats | undefined;
 export declare function getTerminalErrors(): ProxyTerminalErrorJournal;
 export declare function getUsageStatsPersistenceStatus(): ProxyStatsPersistenceStatus;
 export declare function flushUsageStats(): Promise<void>;