@juspay/neurolink 12.9.2 → 12.9.3

package/dist/proxy/accountLedger.d.ts

@@ -29,10 +29,13 @@ import type { CliAccountUsageTotals } from "../types/index.js";
 /** UTC date stamp of the log file the totals cover. */
 export declare function currentUsageDate(now?: Date): string;
 /**
- * Token and cost totals for one UTC day, keyed by bare account label.
+ * Token and cost totals for one UTC day, keyed by provider-qualified account
+ * key ("anthropic:<label>" / "codex:<label>").
  *
- * Only Anthropic-pool rows are attributed, so a Codex account sharing a label
- * with an Anthropic one cannot contribute its tokens to the wrong row.
+ * Both engines' rows are attributed, each under its own key, so a Codex login
+ * sharing an email with an Anthropic one contributes to its own row and never
+ * to the other's. Keying by bare label used to force a choice between merging
+ * them and dropping Codex outright; it dropped Codex.
  */
 export declare function readAccountUsage(date?: string): Promise<Map<string, CliAccountUsageTotals>>;
 /** Drop all cached cursors. Exported for tests, which vary HOME per case. */

package/dist/proxy/accountLedger.js

@@ -33,9 +33,29 @@ const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 /**
  * Account types written by the Anthropic pool. The request log is shared with
  * the Codex engine, and an operator can use the same email for both, so rows
- * must be filtered by engine before being attributed to an Anthropic account.
+ * are attributed by provider-qualified key, never by bare label.
  */
 const ANTHROPIC_ACCOUNT_TYPES = new Set(["oauth", "api_key"]);
+const CODEX_ACCOUNT_TYPE = "codex-oauth";
+/**
+ * The key a log row is attributed under. Current builds write `accountKey`;
+ * rows from before that field existed carry only the label and the engine's
+ * account type, which is enough to rebuild it — the two engines never share a
+ * type string.
+ */
+function ledgerAccountKey(record, account) {
+    if (typeof record.accountKey === "string" && record.accountKey.length > 0) {
+        return record.accountKey;
+    }
+    const type = typeof record.accountType === "string" ? record.accountType : "";
+    if (ANTHROPIC_ACCOUNT_TYPES.has(type)) {
+        return `anthropic:${account.trim().toLowerCase()}`;
+    }
+    if (type === CODEX_ACCOUNT_TYPE) {
+        return `codex:${account}`;
+    }
+    return account;
+}
 const cursors = new Map();
 function getLogsDir() {
     return join(homedir(), ".neurolink", "logs");
@@ -134,9 +154,11 @@ async function advanceCursor(fileName, cursor) {
         // on the triple means two distinct calls that collide on id but differ in
         // account or model are still counted separately; a true re-log of the same
         // request keeps the same triple and merges.
-        const entryKey = `${requestId}\u0000${account}\u0000${typeof record.model === "string" ? record.model : ""}`;
+        const accountKey = ledgerAccountKey(record, account);
+        const entryKey = `${requestId}\u0000${accountKey}\u0000${typeof record.model === "string" ? record.model : ""}`;
         const next = {
             account,
+            accountKey,
             accountType: typeof record.accountType === "string" ? record.accountType : "",
             model: typeof record.model === "string" ? record.model : "",
             provider: typeof record.provider === "string" ? record.provider : undefined,
@@ -254,10 +276,13 @@ function emptyTotals() {
     };
 }
 /**
- * Token and cost totals for one UTC day, keyed by bare account label.
+ * Token and cost totals for one UTC day, keyed by provider-qualified account
+ * key ("anthropic:<label>" / "codex:<label>").
  *
- * Only Anthropic-pool rows are attributed, so a Codex account sharing a label
- * with an Anthropic one cannot contribute its tokens to the wrong row.
+ * Both engines' rows are attributed, each under its own key, so a Codex login
+ * sharing an email with an Anthropic one contributes to its own row and never
+ * to the other's. Keying by bare label used to force a choice between merging
+ * them and dropping Codex outright; it dropped Codex.
  */
 export async function readAccountUsage(date = currentUsageDate()) {
     const fileName = `proxy-${date}.jsonl`;
@@ -281,10 +306,12 @@ export async function readAccountUsage(date = currentUsageDate()) {
     const totals = new Map();
     const unpriced = new Map();
     for (const entry of cursor.entries.values()) {
-        if (!ANTHROPIC_ACCOUNT_TYPES.has(entry.accountType)) {
+        if (!ANTHROPIC_ACCOUNT_TYPES.has(entry.accountType) &&
+            entry.accountType !== CODEX_ACCOUNT_TYPE) {
+            // Translation and internal rows are proxy plumbing, not a login's spend.
             continue;
         }
-        const row = totals.get(entry.account) ?? emptyTotals();
+        const row = totals.get(entry.accountKey) ?? emptyTotals();
         row.requests += 1;
         row.inputTokens += entry.inputTokens;
         row.outputTokens += entry.outputTokens;
@@ -318,12 +345,12 @@ export async function readAccountUsage(date = currentUsageDate()) {
             }
             else {
                 row.unpricedRequests += 1;
-                const seen = unpriced.get(entry.account) ?? new Set();
+                const seen = unpriced.get(entry.accountKey) ?? new Set();
                 seen.add(entry.model);
-                unpriced.set(entry.account, seen);
+                unpriced.set(entry.accountKey, seen);
             }
         }
-        totals.set(entry.account, row);
+        totals.set(entry.accountKey, row);
     }
     for (const [account, row] of totals) {
         row.costUsd = Number(row.costUsd.toFixed(6));

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

@@ -12,6 +12,7 @@
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
+import type { ProxyAccountDirectoryOverride } from "../../types/index.js";
 import type { AccountAllowlist, AccountAdmissionLease, JsonObject, AccountCooldownPlan, AccountQuota, AccountQuotaWindow, AccountUsageFetchResult, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicEntitlementFailure, AnthropicInvalidRequestFailure, AnthropicLoopState, AnthropicScopedExhaustion, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyOveragePolicy, ProxyPassthroughAccount, QueuedAccountAdmission, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
 declare function tryAcquireAccountAdmission(accountKey: string, capacity: number | undefined): AccountAdmissionLease | undefined;
 declare function enqueueAccountAdmission(accountKey: string, capacity: number): QueuedAccountAdmission;
@@ -467,6 +468,7 @@ export declare const __testHooks: {
     refreshAccountLimits: typeof refreshAccountLimits;
     applyAccountUsageResult: typeof applyAccountUsageResult;
     clearLimitsRefreshStateForTests: () => void;
+    setAccountDirectoryForTests: (override: ProxyAccountDirectoryOverride | null) => void;
     isRetryableNetworkError: typeof isRetryableNetworkError;
     isPermanentRefreshFailure: typeof isPermanentRefreshFailure;
     getStreamFailureDetails: typeof getStreamFailureDetails;

package/dist/server/routes/claudeProxyRoutes.js

@@ -18,6 +18,8 @@ import { clearAccountCooldown, loadAccountCooldowns, saveAccountCooldown, } from
 import { anthropicAccountKeysEqual, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { getUnifiedRateLimitStatus, isQuotaOverageAvailable, loadAccountQuotas, mergeQuotaSnapshot, modelFamilyToken, parseQuotaHeaders, saveAccountQuota, } from "../../proxy/accountQuota.js";
 import { fetchAccountUsage, listAnthropicAccountsForUsage, usageToQuota, } from "../../proxy/accountUsage.js";
+import { tokenStore } from "../../auth/tokenStore.js";
+import { fetchCodexAccountUsage, listCodexAccountsForUsage, resolveProxyStatusAccountIdentity, } from "../../proxy/codexAccountUsage.js";
 import { AccountQuotaRefreshCoordinator } from "../../proxy/accountQuotaRefreshCoordinator.js";
 import { ProviderTransportCoordinator } from "../../proxy/providerTransportCoordinator.js";
 import { MAX_COOLDOWN_MS_BY_REASON } from "../../proxy/routingEvidence.js";
@@ -780,6 +782,45 @@ async function refreshAccountQuotaInBackground(account, trigger) {
     }
     await applyAccountUsageResult(account, refresh.result, refresh.startedAt);
 }
+/**
+ * The logins the account-exposing routes enumerate, per engine, plus every
+ * key the token store holds at all (disabled ones included). Overridable by
+ * the suite because the token store is a singleton bound to the real home at
+ * import — a case cannot point it elsewhere, and reading the operator's own
+ * logins inside a fixture test is exactly how a phantom would hide.
+ */
+let accountDirectoryOverride = null;
+async function listRoutableAccountsByEngine(allowlist) {
+    if (accountDirectoryOverride) {
+        return {
+            anthropic: accountDirectoryOverride.anthropic,
+            codex: accountDirectoryOverride.codex,
+        };
+    }
+    // The allowlist is an Anthropic routing concept, keyed by anthropic:
+    // prefixes; applying it to Codex keys would exclude every Codex login.
+    const [anthropic, codex] = await Promise.all([
+        listAnthropicAccountsForUsage(allowlist),
+        listCodexAccountsForUsage(),
+    ]);
+    return { anthropic, codex };
+}
+/**
+ * Every login the token store knows, routable or not. This is what separates
+ * a DISABLED login (still here, shown as unrouted) from a REMOVED one (gone,
+ * and not shown): usage counters and quota snapshots outlive a logout, and
+ * without this check a deleted login renders as an unrouted account forever.
+ */
+async function listKnownAccountKeys() {
+    if (accountDirectoryOverride) {
+        return accountDirectoryOverride.knownKeys;
+    }
+    const [anthropic, codex] = await Promise.all([
+        tokenStore.listByPrefix("anthropic:"),
+        tokenStore.listByPrefix("codex:"),
+    ]);
+    return new Set([...anthropic.map(normalizeAnthropicAccountKey), ...codex]);
+}
 /**
  * Fetch fresh limits from Anthropic's usage endpoint for every eligible OAuth
  * account and write them through the exact same chain the passive header
@@ -789,24 +830,38 @@ async function refreshAccountQuotaInBackground(account, trigger) {
  */
 async function refreshAccountLimits(options = {}) {
     const fetchedAt = Date.now();
-    const allAccounts = await listAnthropicAccountsForUsage(options.accountAllowlist);
+    const directory = await listRoutableAccountsByEngine(options.accountAllowlist);
+    const allAccounts = [
+        ...directory.anthropic.map((account) => ({
+            account,
+            provider: "anthropic",
+        })),
+        ...directory.codex.map((account) => ({
+            account,
+            provider: "codex",
+        })),
+    ];
     const accounts = options.accountFilter
-        ? allAccounts.filter((account) => account.label === options.accountFilter ||
+        ? allAccounts.filter(({ account }) => account.label === options.accountFilter ||
             account.key === options.accountFilter)
         : allAccounts;
     const persisted = await loadAccountQuotas().catch(() => ({}));
-    const buildResult = (account, status, quota, error) => {
+    const buildResult = (account, provider, status, quota, error) => {
         const state = accountRuntimeState.get(account.key);
+        // The quota store keys Anthropic snapshots by bare label for historical
+        // reasons (see CLAUDE.md) and Codex snapshots by full key. A Codex login
+        // must never fall back to the bare label: with one email on both engines
+        // that label holds the ANTHROPIC account's windows.
+        const persistedQuota = provider === "anthropic"
+            ? (persisted[account.key] ?? persisted[account.label] ?? null)
+            : (persisted[account.key] ?? null);
         const result = {
             account: account.label,
             key: account.key,
+            provider,
             type: account.type,
             status,
-            quota: quota ??
-                state?.quota ??
-                persisted[account.key] ??
-                persisted[account.label] ??
-                null,
+            quota: quota ?? state?.quota ?? persistedQuota,
         };
         if (error !== undefined) {
             result.error = error;
@@ -823,7 +878,7 @@ async function refreshAccountLimits(options = {}) {
         return {
             fetchedAt,
             snapshot: true,
-            results: accounts.map((account) => buildResult(account, "snapshot", null)),
+            results: accounts.map(({ account, provider }) => buildResult(account, provider, "snapshot", null)),
             refreshMetrics: accountQuotaRefreshCoordinator.getMetrics(),
         };
     }
@@ -835,23 +890,41 @@ async function refreshAccountLimits(options = {}) {
             if (index >= accounts.length) {
                 return;
             }
-            const account = accounts[index];
+            const { account, provider } = accounts[index];
             if (account.type !== "oauth") {
-                results[index] = buildResult(account, "skipped_api_key", null);
+                results[index] = buildResult(account, provider, "skipped_api_key", null);
                 continue;
             }
             const lastFetch = lastUsageFetchAt.get(account.key) ?? 0;
             if (Date.now() - lastFetch < MIN_USAGE_REFETCH_INTERVAL_MS) {
-                results[index] = buildResult(account, "throttled", null);
+                results[index] = buildResult(account, provider, "throttled", null);
                 continue;
             }
             lastUsageFetchAt.set(account.key, Date.now());
+            if (provider === "codex") {
+                // Codex has its own usage endpoint and no overage/cooldown
+                // reconciliation to run; the snapshot is written under the full key,
+                // which is the only key the Codex engine ever reads it back by.
+                try {
+                    const fetched = await fetchCodexAccountUsage(account);
+                    if (fetched.ok === false) {
+                        results[index] = buildResult(account, provider, "error", null, `codex usage fetch failed: ${fetched.reason}`);
+                        continue;
+                    }
+                    await saveAccountQuota(account.key, fetched.quota);
+                    results[index] = buildResult(account, provider, "refreshed", fetched.quota);
+                }
+                catch (err) {
+                    results[index] = buildResult(account, provider, "error", null, err instanceof Error ? err.message : String(err));
+                }
+                continue;
+            }
             // Isolate failures per account: an unexpected rejection must not abort
             // the Promise.all sweep and turn the whole /limits response into a 502.
             try {
                 const refresh = await accountQuotaRefreshCoordinator.run(account, `manual:${account.key}`, fetchValidatedAccountUsage, { force: true });
                 if (refresh.kind !== "completed") {
-                    results[index] = buildResult(account, "throttled", null);
+                    results[index] = buildResult(account, provider, "throttled", null);
                     continue;
                 }
                 const fetchResult = refresh.result;
@@ -859,18 +932,18 @@ async function refreshAccountLimits(options = {}) {
                 // file without strictNullChecks, where negated boolean-discriminant
                 // narrowing does not apply.
                 if (fetchResult.ok === false) {
-                    results[index] = buildResult(account, "error", null, fetchResult.error);
+                    results[index] = buildResult(account, provider, "error", null, fetchResult.error);
                     continue;
                 }
                 const quota = await applyAccountUsageResult(account, fetchResult, refresh.startedAt, persisted[account.key] ?? persisted[account.label] ?? null);
                 if (!quota) {
-                    results[index] = buildResult(account, "error", null, "usage payload had no recognizable limit windows");
+                    results[index] = buildResult(account, provider, "error", null, "usage payload had no recognizable limit windows");
                     continue;
                 }
-                results[index] = buildResult(account, "refreshed", quota);
+                results[index] = buildResult(account, provider, "refreshed", quota);
             }
             catch (err) {
-                results[index] = buildResult(account, "error", null, err instanceof Error ? err.message : String(err));
+                results[index] = buildResult(account, provider, "error", null, err instanceof Error ? err.message : String(err));
             }
         }
     };
@@ -6769,11 +6842,6 @@ function buildEarlyClaudeRequestError(args) {
  * millisecond fields tens of thousands of years into the future, so only the
  * seconds fields are converted, and 0 becomes null rather than epoch zero.
  */
-/**
- * Account types that represent a real credential rather than proxy plumbing.
- * Mirrors the Anthropic pool's own account types.
- */
-const REAL_ACCOUNT_TYPES = new Set(["oauth", "api_key"]);
 function toMillis(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0
         ? Math.round(value * 1000)
@@ -7498,9 +7566,31 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                         // Usage is the optional half; quota and status must still render.
                         usageError = error instanceof Error ? error.message : String(error);
                     }
-                    const statsByLabel = new Map();
-                    for (const entry of Object.values(statsAccounts)) {
-                        statsByLabel.set(entry.label, entry);
+                    // Joined by provider-qualified KEY, never by label. One email can
+                    // be logged in to both engines; joined by label, the Codex login was
+                    // swallowed by the Anthropic row (and its counters could land on
+                    // that row, last write winning). Legacy stats entries that predate
+                    // the key carry only a label and a type, which is enough to derive
+                    // it; a keyed entry for the same login wins over a legacy one.
+                    const statsByKey = new Map();
+                    for (const [mapKey, entry] of Object.entries(statsAccounts)) {
+                        const identity = resolveProxyStatusAccountIdentity(entry.label, entry.type, entry.key ?? mapKey);
+                        const identityKey = identity.key ?? mapKey;
+                        const existing = statsByKey.get(identityKey);
+                        if (!existing || (entry.key && !existing.key)) {
+                            statsByKey.set(identityKey, { ...entry, identityKey });
+                        }
+                    }
+                    // Which logins exist at all, disabled ones included. A stats entry
+                    // with no login behind it is a REMOVED account, not an unrouted one.
+                    // If the store cannot be read, err towards showing rows: hiding a
+                    // real login is the worse mistake, and the old behaviour.
+                    let knownKeys;
+                    try {
+                        knownKeys = await listKnownAccountKeys();
+                    }
+                    catch {
+                        knownKeys = null;
                     }
                     const rows = [];
                     const claimed = new Set();
@@ -7509,13 +7599,14 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                     // today, which is exactly when an operator most wants to see it.
                     for (const result of limits.results) {
                         const label = result.account;
-                        claimed.add(label);
-                        const stat = statsByLabel.get(label);
+                        claimed.add(result.key);
+                        const stat = statsByKey.get(result.key);
                         const quota = normalizeQuotaForAccounts(result.quota);
                         const cooling = isCooling(result.key ?? null);
                         rows.push({
                             label,
                             key: result.key ?? null,
+                            provider: result.provider,
                             kind: "account",
                             type: result.type ?? stat?.type ?? "oauth",
                             // result.status describes how the quota was obtained
@@ -7549,39 +7640,53 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                     weeklyHealth: quotaHealth(quota.weeklyStatus),
                                 }
                                 : null,
-                            usage: usageByAccount.get(label) ?? null,
+                            usage: usageByAccount.get(result.key) ?? null,
                         });
                     }
                     // Plumbing rows are still reported, but tagged, so a consumer can
                     // show or hide them rather than rendering them as credentials.
                     //
-                    // A real login can land here too: listAnthropicAccountsForUsage
-                    // skips accounts the token store has disabled or the allowlist
-                    // excludes, so an account with real usage history but no current
-                    // route is absent from limits.results. Tagging that as plumbing hid
-                    // the one account an operator is looking for when they ask why
-                    // traffic stopped — the docs tell consumers to filter internal rows
-                    // out. It stays kind "account", with a status saying why it has no
-                    // quota block.
-                    for (const entry of Object.values(statsAccounts)) {
-                        if (claimed.has(entry.label)) {
+                    // A real login can land here too: the listers skip accounts the
+                    // token store has disabled or the allowlist excludes, so a login
+                    // with real usage history but no current route is absent from
+                    // limits.results. Tagging that as plumbing hid the one account an
+                    // operator is looking for when they ask why traffic stopped. It
+                    // stays kind "account", with a status saying why it has no quota
+                    // block — but only while the login still EXISTS. A stats entry whose
+                    // login has been removed from the store is history, not a
+                    // credential, and rendering it as "unrouted" put a phantom account
+                    // on every dashboard for as long as the counters file lived.
+                    for (const entry of statsByKey.values()) {
+                        const identity = resolveProxyStatusAccountIdentity(entry.label, entry.type, entry.identityKey);
+                        if (identity.key !== null && claimed.has(identity.key)) {
+                            continue;
+                        }
+                        const isLogin = identity.provider !== "other";
+                        if (isLogin &&
+                            identity.key !== null &&
+                            knownKeys !== null &&
+                            !knownKeys.has(identity.key)) {
                             continue;
                         }
-                        const isRealAccount = REAL_ACCOUNT_TYPES.has(entry.type);
                         rows.push({
                             label: entry.label,
-                            key: null,
-                            kind: isRealAccount
+                            key: isLogin ? identity.key : null,
+                            ...(isLogin ? { provider: identity.provider } : {}),
+                            kind: isLogin
                                 ? "account"
                                 : entry.type === "translation"
                                     ? "translation"
                                     : "internal",
-                            type: entry.type,
-                            status: isRealAccount ? "unrouted" : null,
+                            // The row's type is the credential kind; the engine is
+                            // `provider`. Stats record Codex logins as "codex-oauth", which
+                            // consumers that only know the credential kinds read as
+                            // plumbing, so it is reported as the OAuth login it is.
+                            type: identity.provider === "codex" ? "oauth" : entry.type,
+                            status: isLogin ? "unrouted" : null,
                             cooling: false,
                             allowed: null,
                             expired: null,
-                            isPrimary: isPrimaryAccount(entry.label),
+                            isPrimary: isLogin ? isPrimaryAccount(identity.key) : false,
                             requests: entry.successCount + entry.errorCount,
                             errors: entry.errorCount,
                             rateLimits: entry.rateLimitCount,
@@ -7593,7 +7698,9 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                             // and cost in the ledger — hardcoding null here discarded
                             // exactly the usage an operator is looking for when they ask
                             // why traffic stopped.
-                            usage: usageByAccount.get(entry.label) ?? null,
+                            usage: identity.key !== null
+                                ? (usageByAccount.get(identity.key) ?? null)
+                                : null,
                         });
                     }
                     const response = {
@@ -8001,6 +8108,9 @@ export const __testHooks = {
         limitsRefreshInFlight = null;
         accountQuotaRefreshCoordinator.clear();
     },
+    setAccountDirectoryForTests: (override) => {
+        accountDirectoryOverride = override;
+    },
     isRetryableNetworkError,
     isPermanentRefreshFailure,
     getStreamFailureDetails,

package/dist/types/proxy.d.ts

@@ -1209,8 +1209,14 @@ export type ProxyQuotaRefreshRunResult = {
 export type ProxyLimitsAccountResult = {
     /** Account label (quota-store key). */
     account: string;
-    /** Token-store key ("anthropic:<label>"). */
+    /** Token-store key ("anthropic:<label>" or "codex:<label>"). */
     key: string;
+    /**
+     * Which pool engine owns this login. Two logins can share a label — an
+     * operator may use one email for both — so the key, not the label, is the
+     * identity, and this names the engine without parsing the key's prefix.
+     */
+    provider: ProxyAccountProvider;
     type: ProxyAccountType;
     status: "refreshed" | "throttled" | "skipped_api_key" | "snapshot" | "error";
     /** Fresh quota on "refreshed"; last known snapshot otherwise (may be null). */
@@ -1219,6 +1225,20 @@ export type ProxyLimitsAccountResult = {
     coolingUntil?: number;
     coolingReason?: AccountCoolingReason;
 };
+/** The pool engine a login belongs to, as named on limits and accounts rows. */
+export type ProxyAccountProvider = "anthropic" | "codex";
+/**
+ * Test-only replacement for the token store behind the account-exposing
+ * routes. The token store is a module singleton bound to the real home at
+ * import, so a suite cannot redirect it; this lets a case state which logins
+ * exist (`knownKeys`, including disabled ones) and which are routable per
+ * engine, exactly as the real listers would answer.
+ */
+export type ProxyAccountDirectoryOverride = {
+    knownKeys: Set<string>;
+    anthropic: ProxyPassthroughAccount[];
+    codex: ProxyPassthroughAccount[];
+};
 /** Response body of the proxy's GET /limits endpoint. */
 export type ProxyLimitsRefreshResponse = {
     fetchedAt: number;

package/dist/types/proxyClient.d.ts

@@ -141,10 +141,21 @@ export type CliClientUsageTotals = {
 };
 /** One row of GET /accounts. */
 export type CliAccountsRow = {
-    /** Bare label, e.g. "someone@example.com". The join key across all sources. */
+    /**
+     * Bare label, e.g. "someone@example.com". Display only: two rows can share
+     * it when one email is logged in to both engines. `key` is the identity.
+     */
     label: string;
-    /** Full pool key, e.g. "anthropic:someone@example.com". */
+    /**
+     * Full pool key, e.g. "anthropic:someone@example.com" or
+     * "codex:someone@example.com". Null only for plumbing rows.
+     */
     key: string | null;
+    /**
+     * Which pool engine owns this login. Absent on plumbing rows. Consumers
+     * that key a list by row must key by `key`, not `label` — see above.
+     */
+    provider?: "anthropic" | "codex";
     /**
      * What this row actually is. Only "account" rows are real logins; the proxy
      * also tracks internal and translation pseudo-accounts, which have no quota
@@ -183,6 +194,13 @@ export type CliAccountsResponse = {
 /** One request as recorded in the proxy request log, reduced to what costing needs. */
 export type ProxyLedgerEntry = {
     account: string;
+    /**
+     * Provider-qualified identity, "anthropic:<label>" or "codex:<label>".
+     * Read from the log row when present; derived from `accountType` for rows
+     * written before the pool logged it. This, not `account`, is the join key:
+     * one email can be logged in to both engines.
+     */
+    accountKey: string;
     /** Derived calling CLI; see CliAccountUsageTotals.byClient. */
     clientApp: string;
     accountType: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.9.2",
+  "version": "12.9.3",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {