@juspay/neurolink 12.12.3 → 12.12.5

package/dist/server/routes/codexProxyRoutes.js

@@ -134,18 +134,18 @@ function buildCodexErrorResponse(status, message) {
  * tokens and hydrating cooldown + quota state from disk.
  */
 async function loadCodexProxyAccounts() {
-    const keys = await tokenStore.listByPrefix(CODEX_ACCOUNT_PREFIX);
-    const [cooldowns, quotas] = await Promise.all([
+    const [inventory, cooldowns, quotas] = await Promise.all([
+        tokenStore.getProviderSnapshot(),
         loadAccountCooldowns(),
         loadAccountQuotas(),
     ]);
     const now = Date.now();
     const accounts = [];
-    for (const key of keys) {
-        if (await tokenStore.isDisabled(key)) {
+    for (const [key, entry] of Object.entries(inventory)) {
+        if (!key.startsWith(CODEX_ACCOUNT_PREFIX) || entry.disabled) {
             continue;
         }
-        const tokens = await tokenStore.loadTokens(key);
+        const tokens = entry.tokens;
         if (!tokens || tokens.tokenType !== "Bearer") {
             // Only OAuth (Bearer) accounts can serve the ChatGPT backend.
             continue;
@@ -346,6 +346,17 @@ export async function handleCodexResponsesRequest(ctx) {
         }).catch(() => undefined);
     };
     const accounts = await loadCodexProxyAccounts();
+    const cancelRequest = async (account) => {
+        await recordFinalOutcome(account, 499, {
+            errorType: "client_cancelled",
+            errorMessage: "Client cancelled Codex request",
+            terminalOutcome: "client_cancelled",
+        });
+        return buildCodexErrorResponse(499, "Client cancelled Codex request");
+    };
+    if (ctx.abortSignal?.aborted) {
+        return cancelRequest();
+    }
     if (accounts.length === 0) {
         await recordFinalOutcome(undefined, 401, {
             errorType: "no_accounts",
@@ -392,6 +403,9 @@ export async function handleCodexResponsesRequest(ctx) {
         let authRetried = false;
         // Same-account loop only re-runs once, for a post-401 token refresh.
         for (;;) {
+            if (ctx.abortSignal?.aborted) {
+                return cancelRequest(lastAttemptedAccount);
+            }
             attempt += 1;
             const attemptStartedAt = Date.now();
             lastAttemptedAccount = account;
@@ -402,10 +416,23 @@ export async function handleCodexResponsesRequest(ctx) {
                     method: "POST",
                     headers: buildCodexUpstreamHeaders(ctx.headers, account),
                     body: bodyStr,
-                    signal: AbortSignal.timeout(CODEX_UPSTREAM_TIMEOUT_MS),
+                    signal: ctx.abortSignal
+                        ? AbortSignal.any([
+                            ctx.abortSignal,
+                            AbortSignal.timeout(CODEX_UPSTREAM_TIMEOUT_MS),
+                        ])
+                        : AbortSignal.timeout(CODEX_UPSTREAM_TIMEOUT_MS),
                 });
             }
             catch (error) {
+                if (ctx.abortSignal?.aborted) {
+                    writeAttempt(account, attempt, attemptStartedAt, 499, {
+                        errorType: "client_cancelled",
+                        errorMessage: "Client cancelled Codex request",
+                        retryable: false,
+                    });
+                    return cancelRequest(account);
+                }
                 // A transport failure message is derived from local state — resolved
                 // hostnames, socket paths, Node internals — and says nothing the caller
                 // can act on. Keep the detail in the log and return a fixed string, so

package/dist/types/cli.d.ts

@@ -860,6 +860,7 @@ export type ProxyRollingState = {
         generation: number;
     }>;
     queuedSockets: number;
+    pendingTransfers?: number;
     rejectedSockets: number;
     failedTransfers: number;
     lastFailure: {
@@ -871,7 +872,7 @@ export type ProxyRollingState = {
         workerPid?: number;
         workerExitCode?: number | null;
         workerExitSignal?: string | null;
-        supervisorAction?: "none" | "sigkill_after_transfer_failure";
+        supervisorAction?: "none" | "sigkill_after_transfer_failure" | "cancel_uncommitted_socket";
     } | null;
 };
 export type ProxySupervisorState = {

package/dist/types/codex.d.ts

@@ -138,12 +138,17 @@ export type CodexResponsesInputItem = {
     call_id: string;
     output: string;
 };
+/** Codex reasoning settings; supported levels depend on the selected model. */
+export type CodexReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 /** Request shape used to bridge Anthropic Messages traffic to Codex Responses. */
 export type CodexResponsesRequest = {
     model: string;
     input: CodexResponsesInputItem[];
     stream: true;
     store: false;
+    reasoning?: {
+        effort: CodexReasoningEffort;
+    };
     instructions?: string;
     tools?: Array<{
         type: "function";
@@ -163,3 +168,8 @@ export type CodexFallbackResult = {
     usage?: NonNullable<InternalResult["usage"]>;
     finishReason: "end_turn" | "tool_use";
 };
+/** Incremental Claude frames and explicit upstream cancellation. */
+export type CodexFallbackStream = {
+    frames: AsyncGenerator<string, CodexFallbackResult>;
+    cancel: (reason?: unknown) => Promise<void>;
+};

package/dist/types/proxy.d.ts

@@ -192,6 +192,9 @@ export type SSEMessageDelta = {
     };
     usage: {
         output_tokens: number;
+        input_tokens?: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
     };
 };
 export type SSEMessageStop = {
@@ -1392,6 +1395,7 @@ export type ClaudeProxyModelTier = "opus" | "sonnet" | "haiku" | "other";
 export type ProxyTranslationAttempt = {
     provider?: string;
     model?: string;
+    reasoningEffort?: FallbackEntry["reasoningEffort"];
     label: string;
 };
 /** Ordered plan of provider attempts for a proxy request. */
@@ -2360,7 +2364,7 @@ export type RollingWorkerFailureDetails = {
     workerPid?: number;
     workerExitCode?: number | null;
     workerExitSignal?: string | null;
-    supervisorAction?: "none" | "sigkill_after_transfer_failure";
+    supervisorAction?: "none" | "sigkill_after_transfer_failure" | "cancel_uncommitted_socket";
 };
 export type RollingWorkerSupervisorEvent = {
     at: string;
@@ -2388,6 +2392,8 @@ export type RollingWorkerSupervisorSnapshot = {
         generation: number;
     }>;
     queuedSockets: number;
+    /** Offered sockets awaiting acknowledgement or commit, across all workers. */
+    pendingTransfers?: number;
     rejectedSockets: number;
     failedTransfers: number;
     /** Bounded generation-scoped evidence for attributing lifetime counters. */
@@ -2404,13 +2410,15 @@ export type RollingWorkerSupervisorOptions = {
     spawnWorker: (generation: number, expectedVersion: string) => RollingWorkerHandle;
     readyTimeoutMs?: number;
     socketQueueLimit?: number;
+    /** Bound IPC socket offers independently of active HTTP requests. */
+    maxPendingTransfers?: number;
     socketQueueTimeoutMs?: number;
     shutdownTimeoutMs?: number;
     onStateChange?: (snapshot: RollingWorkerSupervisorSnapshot) => void;
     onReplacementRequested?: (request: {
         generation: number;
         pid: number;
-        reason: "environment";
+        reason: "environment" | "socket_offer_timeout";
     }) => void;
     log?: (message: string) => void;
 };
@@ -2421,6 +2429,7 @@ export type RollingProxyServerOptions = {
     spawnWorker: (generation: number, expectedVersion: string) => RollingWorkerHandle;
     readyTimeoutMs?: number;
     socketQueueLimit?: number;
+    maxPendingTransfers?: number;
     socketQueueTimeoutMs?: number;
     shutdownTimeoutMs?: number;
     recoveryDelayMs?: number;

package/dist/types/subscription.d.ts

@@ -5,6 +5,7 @@
  * and usage tracking for Anthropic API access.
  */
 import type { StoredOAuthTokens } from "./auth.js";
+import type { CodexReasoningEffort } from "./codex.js";
 export type { StoredOAuthTokens, TokenRefresher, TokenStorageData, StoredProviderTokens, } from "./auth.js";
 /**
  * Claude subscription tier levels
@@ -979,6 +980,8 @@ export type ModelMapping = {
 export type FallbackEntry = {
     provider: string;
     model: string;
+    /** Explicit Codex fallback effort. Omit to use the upstream default. */
+    reasoningEffort?: CodexReasoningEffort;
 };
 /** Full proxy routing config */
 export type ProxyRoutingConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.12.3",
+  "version": "12.12.5",
   "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": {