@juspay/neurolink 10.8.22 → 10.9.1

package/dist/proxy/proxyLifecycle.js

@@ -9,6 +9,8 @@ const SCHEMA_VERSION = 1;
 const DEFAULT_QUEUE_CAPACITY = 10_000;
 const DEFAULT_BATCH_SIZE = 256;
 const DEFAULT_FLUSH_INTERVAL_MS = 25;
+const DEFAULT_MAX_WRITE_RETRIES = 3;
+const MAX_WRITE_RETRY_DELAY_MS = 1_000;
 const LIFECYCLE_APPEND_TIMEOUT_MS = 2_000;
 const MAX_SHORT_FIELD_LENGTH = 256;
 const SESSION_KEY_FILE = ".proxy-lifecycle-session-key";
@@ -17,6 +19,7 @@ let lifecycleLogDir;
 let queueCapacity = DEFAULT_QUEUE_CAPACITY;
 let batchSize = DEFAULT_BATCH_SIZE;
 let flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS;
+let maxWriteRetries = DEFAULT_MAX_WRITE_RETRIES;
 let processInstanceId = randomUUID();
 let sessionHashKey = randomBytes(32);
 let nextSequence = 1;
@@ -28,10 +31,13 @@ let queueDrops = 0;
 let invalidDrops = 0;
 let writeDrops = 0;
 let writeFailures = 0;
+let writeRetries = 0;
 let inFlight = 0;
 let queue = [];
 let flushTimer;
 let flushInFlight;
+let nextFlushDelayMs;
+let appendLifecycleFile = appendFile;
 function positiveInteger(value, fallback) {
     return Number.isInteger(value) && (value ?? 0) > 0
         ? value
@@ -123,14 +129,14 @@ function clearScheduledFlush() {
         flushTimer = undefined;
     }
 }
-function scheduleFlush() {
+function scheduleFlush(delayMs = flushIntervalMs) {
     if (flushTimer || flushInFlight || queue.length === 0) {
         return;
     }
     flushTimer = setTimeout(() => {
         flushTimer = undefined;
         void startFlush();
-    }, flushIntervalMs);
+    }, delayMs);
     flushTimer.unref?.();
 }
 async function flushBatch() {
@@ -143,27 +149,53 @@ async function flushBatch() {
         const byPath = new Map();
         for (const item of batch) {
             const path = join(item.logDir, `proxy-lifecycle-${item.date}.jsonl`);
-            const lines = byPath.get(path) ?? [];
-            lines.push(`${JSON.stringify(item.record)}\n`);
-            byPath.set(path, lines);
+            const items = byPath.get(path) ?? [];
+            items.push(item);
+            byPath.set(path, items);
         }
-        for (const [path, lines] of byPath) {
+        const retries = [];
+        let retryDelayMs = 0;
+        for (const [path, items] of byPath) {
+            const lines = items.map((item) => `${JSON.stringify(item.record)}\n`);
             try {
                 // This best-effort telemetry sink intentionally avoids fsync so request
                 // throughput is not coupled to storage latency. Loss is surfaced by
                 // writeDrops/writeFailures rather than delaying proxy responses.
-                await withTimeout(appendFile(path, lines.join(""), { mode: 0o600 }), LIFECYCLE_APPEND_TIMEOUT_MS, "Timed out writing proxy lifecycle metadata");
+                await withTimeout(appendLifecycleFile(path, lines.join(""), { mode: 0o600 }), LIFECYCLE_APPEND_TIMEOUT_MS, "Timed out writing proxy lifecycle metadata");
                 written += lines.length;
             }
             catch (error) {
-                dropped += lines.length;
-                writeDrops += lines.length;
                 writeFailures += 1;
+                const retryable = items.filter((item) => item.writeRetries < maxWriteRetries);
+                const exhausted = items.length - retryable.length;
+                if (retryable.length > 0) {
+                    const nextRetries = retryable.map((item) => ({
+                        ...item,
+                        writeRetries: item.writeRetries + 1,
+                    }));
+                    retries.push(...nextRetries);
+                    writeRetries += nextRetries.length;
+                    retryDelayMs = Math.max(retryDelayMs, Math.min(MAX_WRITE_RETRY_DELAY_MS, flushIntervalMs *
+                        2 ** Math.max(...nextRetries.map((item) => item.writeRetries))));
+                }
+                if (exhausted > 0) {
+                    dropped += exhausted;
+                    writeDrops += exhausted;
+                }
                 logger.warn("[proxy] lifecycle metadata write failed", {
+                    path,
+                    retrying: retryable.length,
+                    dropped: exhausted,
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
         }
+        if (retries.length > 0) {
+            // Keep retried records ahead of newly admitted records. This preserves
+            // per-file sequence order while continuing to keep request paths async.
+            queue.unshift(...retries);
+            nextFlushDelayMs = Math.max(nextFlushDelayMs ?? 0, retryDelayMs || flushIntervalMs);
+        }
     }
     finally {
         inFlight = Math.max(0, inFlight - batch.length);
@@ -179,21 +211,27 @@ function startFlush() {
         if (flushInFlight === currentFlush) {
             flushInFlight = undefined;
         }
-        scheduleFlush();
+        const delayMs = nextFlushDelayMs;
+        nextFlushDelayMs = undefined;
+        scheduleFlush(delayMs);
     }, () => {
         if (flushInFlight === currentFlush) {
             flushInFlight = undefined;
         }
-        scheduleFlush();
+        const delayMs = nextFlushDelayMs;
+        nextFlushDelayMs = undefined;
+        scheduleFlush(delayMs);
     });
     return currentFlush;
 }
 export function configureProxyLifecycleLogger(options) {
     clearScheduledFlush();
+    nextFlushDelayMs = undefined;
     loggerEnabled = false;
     lifecycleLogDir = undefined;
     queueCapacity = positiveInteger(options.queueCapacity, DEFAULT_QUEUE_CAPACITY);
     batchSize = positiveInteger(options.batchSize, DEFAULT_BATCH_SIZE);
+    maxWriteRetries = positiveInteger(options.maxWriteRetries, DEFAULT_MAX_WRITE_RETRIES);
     flushIntervalMs = positiveInteger(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
     if (options.enabled && options.logDir) {
         try {
@@ -268,6 +306,7 @@ export function logProxyLifecycleEvent(input) {
             logDir: lifecycleLogDir,
             date: String(record.timestamp).slice(0, 10),
             record,
+            writeRetries: 0,
         });
         enqueued += 1;
         scheduleFlush();
@@ -303,6 +342,7 @@ export function getProxyLifecycleLoggerSnapshot() {
         invalidDrops,
         writeDrops,
         writeFailures,
+        writeRetries,
         pending: queue.length,
         inFlight,
         flushing: flushInFlight !== undefined,
@@ -315,6 +355,7 @@ export function resetProxyLifecycleLoggerForTests() {
     queueCapacity = DEFAULT_QUEUE_CAPACITY;
     batchSize = DEFAULT_BATCH_SIZE;
     flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS;
+    maxWriteRetries = DEFAULT_MAX_WRITE_RETRIES;
     processInstanceId = randomUUID();
     sessionHashKey = randomBytes(32);
     nextSequence = 1;
@@ -326,7 +367,16 @@ export function resetProxyLifecycleLoggerForTests() {
     invalidDrops = 0;
     writeDrops = 0;
     writeFailures = 0;
+    writeRetries = 0;
     inFlight = 0;
     queue = [];
     flushInFlight = undefined;
+    nextFlushDelayMs = undefined;
+    appendLifecycleFile = appendFile;
 }
+/** Isolated failure injection for lifecycle durability tests. */
+export const __proxyLifecycleTestHooks = {
+    setAppendFileForTests(append) {
+        appendLifecycleFile = append;
+    },
+};

package/dist/proxy/usageStats.d.ts

@@ -77,6 +77,8 @@ export declare function recordFinalSuccess(accountLabel?: string, accountType?:
 export declare function recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
 export declare function recordFinalError(status: number, accountLabel?: string, accountType?: string, details?: ProxyTerminalErrorDetails): void;
 export declare function getStats(): ProxyStats;
+/** Return the process-local coherent snapshot without filesystem reconciliation. */
+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;

package/dist/proxy/usageStats.js

@@ -1121,6 +1121,10 @@ export function recordFinalError(status, accountLabel, accountType, details) {
 export function getStats() {
     return defaultStore.getStats();
 }
+/** Return the process-local coherent snapshot without filesystem reconciliation. */
+export function getUsageSnapshot() {
+    return defaultStore.getUsageSnapshot();
+}
 export async function getReconciledStats() {
     return defaultStore.reconcile();
 }

package/dist/types/proxy.d.ts

@@ -1246,6 +1246,8 @@ export type ProxyLifecycleLoggerSnapshot = {
     invalidDrops: number;
     writeDrops: number;
     writeFailures: number;
+    /** Events requeued after a transient lifecycle metadata write failure. */
+    writeRetries: number;
     pending: number;
     inFlight: number;
     flushing: boolean;
@@ -1257,12 +1259,15 @@ export type ProxyLifecycleLoggerOptions = {
     queueCapacity?: number;
     batchSize?: number;
     flushIntervalMs?: number;
+    /** Bounded retries for a metadata batch that cannot be appended immediately. */
+    maxWriteRetries?: number;
 };
 /** Serialized lifecycle line awaiting a bounded batch write. */
 export type QueuedProxyLifecycleEvent = {
     logDir: string;
     date: string;
     record: Record<string, unknown>;
+    writeRetries: number;
 };
 /** Percentile summary used by offline proxy log analysis. */
 export type ProxyLatencySummary = {
@@ -2167,6 +2172,8 @@ export type StatusStats = {
     terminalErrorDetailsComparable?: boolean;
     terminalErrorDetailsMissing?: number;
     terminalErrorDetailsExcess?: number;
+    /** Whether this status response reconciled shared state or used local memory. */
+    snapshotSource?: "reconciled" | "memory";
     accounts?: {
         label: string;
         type: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.8.22",
+  "version": "10.9.1",
   "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": {
@@ -145,6 +145,7 @@
     "test:model-capabilities": "npx tsx test/continuous-test-suite-model-capabilities.ts",
     "test:agent-runtime:vitest": "pnpm exec vitest run test/agentRuntime.test.ts",
     "test:retry-after:vitest": "pnpm exec vitest run test/retryAfter.test.ts",
+    "test:websearch-grounding": "npx tsx test/continuous-test-suite-websearch-grounding.ts",
     "test:ci": "pnpm run test && pnpm run test:client && pnpm run test:hitl",
     "// CI tier — fast, no live AI calls, safe for every commit": "",
     "test:tool-routing": "npx tsx test/continuous-test-suite-tool-routing.ts",
@@ -152,7 +153,7 @@
     "test:system-messages": "npx tsx test/continuous-test-suite-system-messages.ts",
     "test:test-stubs": "npx tsx test/continuous-test-suite-test-stubs.ts",
     "test:tool-routing-semantic": "npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",