@juspay/neurolink 9.87.2 → 9.87.4

package/dist/server/routes/openaiProxyRoutes.js

@@ -146,12 +146,53 @@ async function handleOpenAIToAnthropicBridge(args) {
             });
             return buildOpenAIErrorResponse(502, "Anthropic loopback returned empty stream body");
         }
-        // Streaming success: log now since the response body is consumed by the
-        // client. Token counts are not visible at this layer (the inner /v1/messages
-        // handler accounts them), so we omit them here.
-        await writeLifecycle(200);
-        const transformed = upstream.body.pipeThrough(createClaudeToOpenAIStreamTransform(body.model));
-        return new Response(transformed, {
+        let terminalStreamError;
+        const transformed = upstream.body.pipeThrough(createClaudeToOpenAIStreamTransform(body.model, {
+            onError: (message) => {
+                terminalStreamError = sanitizeForLog(message);
+            },
+        }));
+        const reader = transformed.getReader();
+        let lifecycleWritten = false;
+        const finishLifecycle = async (status, errorType, errorMessage) => {
+            if (lifecycleWritten) {
+                return;
+            }
+            lifecycleWritten = true;
+            await writeLifecycle(status, { errorType, errorMessage });
+        };
+        const trackedStream = new ReadableStream({
+            async pull(controller) {
+                try {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        if (terminalStreamError) {
+                            await finishLifecycle(502, "loopback_stream_error", terminalStreamError);
+                        }
+                        else {
+                            await finishLifecycle(200);
+                        }
+                        controller.close();
+                        return;
+                    }
+                    controller.enqueue(value);
+                }
+                catch (error) {
+                    const message = sanitizeForLog(error instanceof Error ? error.message : String(error));
+                    await finishLifecycle(502, "loopback_stream_error", message);
+                    controller.error(error);
+                }
+            },
+            async cancel(reason) {
+                try {
+                    await reader.cancel(reason);
+                }
+                finally {
+                    await finishLifecycle(499, "client_cancelled", "Client cancelled the OpenAI-compatible stream");
+                }
+            },
+        });
+        return new Response(trackedStream, {
             status: 200,
             headers: {
                 "content-type": "text/event-stream",

package/dist/types/cli.d.ts

@@ -800,6 +800,8 @@ export type ProxyGuardArgs = {
     failureThreshold?: number;
     pollIntervalMs?: number;
     quiet?: boolean;
+    /** Run update checks only; never mutate client settings. */
+    updaterOnly?: boolean;
 };
 /** Arguments accepted by `neurolink proxy telemetry <subcommand>` */
 export type ProxyTelemetryArgs = {
@@ -829,6 +831,8 @@ export type ProxyState = {
     accountAllowlist?: string[];
     /** Optional fail-open guard PID that reverts Claude settings if proxy dies */
     guardPid?: number;
+    /** Dedicated updater PID for launchd-managed proxy installations. */
+    updaterPid?: number;
     /** How the proxy was launched — "launchd" if installed as service, "manual" otherwise */
     managedBy?: "launchd" | "manual";
     /** Whether the proxy is running in transparent passthrough mode */

package/dist/types/proxy.d.ts

@@ -518,6 +518,7 @@ export type AnthropicLoopState = {
     } | null;
     authFailureMessage: string | null;
     authCooldownMessage: string | null;
+    fallbackFailureMessage?: string;
     attemptNumber: number;
 };
 export type AnthropicUpstreamBody = {
@@ -586,6 +587,10 @@ export type AccountCooldownPlan = {
      *  burst), a small number of jittered same-account retries is allowed first. */
     rotateImmediately: boolean;
 };
+export type TransientRateLimitRetryBudget = {
+    coolingUntil: number;
+    retriesClaimed: number;
+};
 export type AnthropicUpstreamFetchResult = {
     continueLoop: boolean;
     retrySameAccount?: boolean;
@@ -595,6 +600,15 @@ export type AnthropicUpstreamFetchResult = {
     cooldownPlan?: AccountCooldownPlan;
     /** Quota snapshot parsed from the response headers (429 or success), if present. */
     quota?: AccountQuota;
+    /** A terminal upstream rejection already captured and classified by the
+     *  fetch layer. The route must finalize it directly instead of feeding it
+     *  through the generic non-OK handler a second time. */
+    terminalError?: {
+        status: number;
+        body: string;
+        headers: Record<string, string>;
+        errorType: "construction_rejection";
+    };
     response?: Response;
     lastError: unknown;
     sawRateLimit: boolean;
@@ -897,6 +911,26 @@ export type QuietStatus = {
     lastActivityAt: Date | null;
     silenceDurationMs: number;
 };
+/** In-process proxy request activity used to protect streaming restarts. */
+export type ProxyActivitySnapshot = {
+    activeRequests: number;
+    lastActivityAt: Date | null;
+};
+/** Activity payload exposed by the running proxy status endpoint. */
+export type ProxyRuntimeActivity = {
+    activeRequests: number;
+    lastActivityAt: string | null;
+};
+/** Request metadata retained by the HTTP adapter for terminal error logging. */
+export type RuntimeRequestMetadata = {
+    requestId: string;
+    method: string;
+    path: string;
+    startedAt: number;
+    model: string;
+    stream: boolean;
+    toolCount: number;
+};
 /** Accumulated upstream body capture from a raw stream. */
 export type RawStreamCapture = {
     totalBytes: number;
@@ -1060,6 +1094,34 @@ export type UpdateState = {
     lastUpdateAt: string | null;
     lastUpdateVersion: string | null;
 };
+/** Supported global package managers for proxy self-updates. */
+export type GlobalInstallerKind = "npm" | "pnpm";
+/** Result of probing one global package-manager executable. */
+export type GlobalInstallerProbe = {
+    kind: GlobalInstallerKind;
+    bin: string;
+    version?: string;
+    globalRoot?: string;
+    globalBinDir?: string;
+    working: boolean;
+    installable: boolean;
+    matchesCurrentInstall: boolean;
+    reason?: string;
+};
+/** Selected package manager plus all candidates considered. */
+export type GlobalInstallerResolution = {
+    installer?: GlobalInstallerProbe;
+    tried: GlobalInstallerProbe[];
+};
+/** Injectable command runner used by global-installer tests. */
+export type GlobalInstallerExecFile = typeof import("node:child_process").execFileSync;
+/** Overrides used while resolving the global package manager. */
+export type ResolveGlobalInstallerOptions = {
+    entryScript?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    execFileSync?: GlobalInstallerExecFile;
+};
 /** Shape of the dynamically-imported js-yaml module. `dump` is optional —
  *  read-only consumers (proxy config loader) only need `load`; writers
  *  (CLI primary-account commands) check `dump` before calling. */

package/package.json

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