@juspay/neurolink 9.37.0 → 9.39.0

package/dist/lib/server/routes/claudeProxyRoutes.js

@@ -9,6 +9,9 @@
  * provider/model pairs (e.g. "claude-sonnet-4-20250514" -> vertex/gemini-2.5-pro).
  * Without a router, models are passed through to the Anthropic provider.
  */
+import { readFile, access } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
 import { parseClaudeRequest, serializeClaudeResponse, ClaudeStreamSerializer, buildClaudeError, generateToolUseId, } from "../../proxy/claudeFormat.js";
 import { logger } from "../../utils/logger.js";
 import { recordRequest, recordSuccess, recordError, recordCooldown, } from "../../proxy/usageStats.js";
@@ -81,6 +84,127 @@ function advancePrimaryIfCurrent(accountKey, enabledCount, primaryAccountKey) {
     primaryAccountIndex = (primaryAccountIndex + 1) % enabledCount;
 }
 // ---------------------------------------------------------------------------
+// OAuth polyfill helpers (extracted to reduce block nesting)
+// ---------------------------------------------------------------------------
+const snapshotCache = new Map();
+const SNAPSHOT_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Load a header snapshot captured from a real Claude Code session and apply
+ * any headers the client didn't send.  This makes non-Claude-Code requests
+ * (e.g. from Curator, custom apps) appear identical to Claude Code.
+ */
+async function applyHeaderSnapshot(headers, accountLabel) {
+    try {
+        // Sanitize accountLabel to prevent directory traversal
+        const safeLabel = accountLabel.replace(/[^a-zA-Z0-9._@-]/g, "_");
+        // Check cache first
+        const cached = snapshotCache.get(safeLabel);
+        if (cached && Date.now() - cached.loadedAt < SNAPSHOT_CACHE_TTL_MS) {
+            for (const [sk, sv] of Object.entries(cached.headers)) {
+                const lower = sk.toLowerCase();
+                if (typeof sv === "string" &&
+                    !headers[lower] &&
+                    !BLOCKED_UPSTREAM_HEADERS.has(lower) &&
+                    lower !== "authorization" &&
+                    lower !== "x-api-key") {
+                    headers[lower] = sv;
+                }
+            }
+            return;
+        }
+        const snapshotPath = join(homedir(), ".neurolink", "header-snapshots", `anthropic_${safeLabel}.json`);
+        try {
+            await access(snapshotPath);
+        }
+        catch {
+            return;
+        }
+        const snapshot = JSON.parse(await readFile(snapshotPath, "utf8"));
+        if (!snapshot.headers) {
+            return;
+        }
+        // Store in cache
+        snapshotCache.set(safeLabel, {
+            headers: snapshot.headers,
+            loadedAt: Date.now(),
+        });
+        for (const [sk, sv] of Object.entries(snapshot.headers)) {
+            const lower = sk.toLowerCase();
+            if (typeof sv === "string" &&
+                !headers[lower] &&
+                !BLOCKED_UPSTREAM_HEADERS.has(lower) &&
+                lower !== "authorization" &&
+                lower !== "x-api-key") {
+                headers[lower] = sv;
+            }
+        }
+    }
+    catch {
+        // Snapshot missing or corrupt — continue without it
+    }
+}
+/**
+ * Polyfill the request body for OAuth accounts.
+ * Claude Code injects a billing header, agent block, and metadata.user_id
+ * into the body.  Non-CC clients (Curator, custom apps) don't send these —
+ * Anthropic rejects without them.
+ */
+function polyfillOAuthBody(bodyStr, accountToken) {
+    try {
+        const parsed = JSON.parse(bodyStr);
+        // Billing header block (required by Anthropic for OAuth)
+        const randomHex = Math.random().toString(16).substring(2, 5);
+        const billingBlock = {
+            type: "text",
+            text: `x-anthropic-billing-header: cc_version=2.1.86.${randomHex}; cc_entrypoint=cli; cch=proxy;`,
+        };
+        const agentBlock = {
+            type: "text",
+            text: "You are a Claude agent, built on Anthropic's Claude Agent SDK.",
+        };
+        // Normalise system to array and prepend billing + agent
+        if (parsed.system) {
+            if (typeof parsed.system === "string") {
+                parsed.system = [{ type: "text", text: parsed.system }];
+            }
+            if (Array.isArray(parsed.system)) {
+                const hasBilling = parsed.system.some((b) => typeof b.text === "string" &&
+                    b.text.includes("x-anthropic-billing-header"));
+                const hasAgent = parsed.system.some((b) => typeof b.text === "string" && b.text.includes("Claude Agent SDK"));
+                const toInsert = [];
+                if (!hasBilling) {
+                    toInsert.push(billingBlock);
+                }
+                if (!hasAgent) {
+                    toInsert.push(agentBlock);
+                }
+                if (toInsert.length > 0) {
+                    parsed.system = [...toInsert, ...parsed.system];
+                }
+            }
+        }
+        else {
+            parsed.system = [billingBlock, agentBlock];
+        }
+        // Inject metadata.user_id (required for OAuth)
+        if (!parsed.metadata?.user_id) {
+            const tokenPrefix = accountToken.substring(0, Math.min(20, accountToken.length));
+            const hash = Array.from(new TextEncoder().encode(tokenPrefix))
+                .reduce((a, b) => ((a << 5) - a + b) | 0, 0)
+                .toString(16)
+                .replace("-", "");
+            parsed.metadata = {
+                ...parsed.metadata,
+                user_id: `proxy-${hash}`,
+            };
+        }
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return bodyStr; // JSON parse failed — use original body
+    }
+}
+// ---------------------------------------------------------------------------
 // Legacy credential refresh helper (extracted to reduce block nesting)
 // ---------------------------------------------------------------------------
 async function tryLoadLegacyAccount(creds, legacyCredPath) {
@@ -158,17 +282,29 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                 handler: async (ctx) => {
                     const body = ctx.body;
                     // 1. Validate
-                    if (!body?.model || !body?.messages) {
+                    if (typeof body?.model !== "string" ||
+                        !Array.isArray(body?.messages)) {
                         return buildClaudeError(400, "Missing required fields: model, messages");
                     }
                     // 2. Resolve model via router (or pass through to anthropic)
+                    // Guard: without a model router, only Claude models are allowed.
+                    const modelLower = body.model.toLowerCase();
+                    if (!modelRouter && !modelLower.startsWith("claude-")) {
+                        return buildClaudeError(404, `Model '${body.model}' is not an Anthropic model. ` +
+                            `The proxy only supports Claude models. ` +
+                            `Use a model router to route non-Claude models to other providers.`);
+                    }
                     const route = modelRouter?.resolve(body.model) ?? {
                         provider: "anthropic",
                         model: body.model,
                     };
                     try {
                         // 3. Route based on target provider
-                        const isClaudeTarget = route.provider === "anthropic" || route.provider === null;
+                        if (route.provider === null) {
+                            return buildClaudeError(404, `Model '${body.model}' is not a Claude model. ` +
+                                `Use a model router to route it to another provider.`);
+                        }
+                        const isClaudeTarget = route.provider === "anthropic";
                         if (isClaudeTarget) {
                             // ─── PASSTHROUGH MODE (Claude → Claude) ───────────────
                             const fs = await import("fs");
@@ -435,27 +571,54 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                 headers["content-type"] = "application/json";
                                 if (isOAuth) {
                                     headers["authorization"] = `Bearer ${account.token}`;
+                                    delete headers["x-api-key"];
                                 }
                                 else {
                                     headers["x-api-key"] = account.token;
                                     delete headers["authorization"];
                                 }
-                                // Defaults: only set when client didn't send them
+                                // Apply header snapshot defaults for OAuth accounts
+                                if (isOAuth) {
+                                    await applyHeaderSnapshot(headers, account.label);
+                                }
+                                // Hard defaults for anything still missing
                                 if (!headers["user-agent"]) {
-                                    headers["user-agent"] = "claude-cli/2.1.80 (external, cli)";
+                                    headers["user-agent"] = "claude-cli/2.1.86 (external, cli)";
                                 }
                                 if (!headers["anthropic-version"]) {
                                     headers["anthropic-version"] = "2023-06-01";
                                 }
-                                // Ensure oauth beta is always present in the beta list
-                                const existingBetas = headers["anthropic-beta"] ?? "";
-                                if (!existingBetas) {
-                                    headers["anthropic-beta"] = "oauth-2025-04-20";
+                                if (!headers["anthropic-dangerous-direct-browser-access"]) {
+                                    headers["anthropic-dangerous-direct-browser-access"] = "true";
+                                }
+                                // Manage anthropic-beta header based on auth type.
+                                // OAuth requires specific betas; API-key must NOT carry them.
+                                if (isOAuth) {
+                                    const existing = new Set((headers["anthropic-beta"] ?? "")
+                                        .split(",")
+                                        .map((s) => s.trim())
+                                        .filter(Boolean));
+                                    existing.add("oauth-2025-04-20");
+                                    existing.add("claude-code-20250219");
+                                    headers["anthropic-beta"] = [...existing].join(",");
                                 }
-                                else if (!existingBetas.includes("oauth")) {
-                                    headers["anthropic-beta"] =
-                                        `${existingBetas},oauth-2025-04-20`;
+                                else {
+                                    // Strip OAuth-specific betas that may have leaked from client
+                                    const cleaned = (headers["anthropic-beta"] ?? "")
+                                        .split(",")
+                                        .map((s) => s.trim())
+                                        .filter((s) => s && s !== "oauth-2025-04-20")
+                                        .join(",");
+                                    if (cleaned) {
+                                        headers["anthropic-beta"] = cleaned;
+                                    }
+                                    else {
+                                        delete headers["anthropic-beta"];
+                                    }
                                 }
+                                // Polyfill request body for OAuth accounts
+                                const buildUpstreamBody = () => isOAuth ? polyfillOAuthBody(bodyStr, account.token) : bodyStr;
+                                const finalBodyStr = buildUpstreamBody();
                                 logger.always(`[proxy] → account=${account.label} (${account.type})`);
                                 recordRequest(account.label, account.type);
                                 // Log full request for debugging (written to ~/.neurolink/logs/proxy-debug-*.jsonl)
@@ -465,7 +628,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                     response = await fetch(url, {
                                         method: "POST",
                                         headers,
-                                        body: bodyStr,
+                                        body: finalBodyStr,
                                         signal: AbortSignal.timeout(UPSTREAM_FETCH_TIMEOUT_MS),
                                     });
                                 }
@@ -497,6 +660,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                         }
                                         else {
                                             const date = new Date(retryAfter);
+                                            // eslint-disable-next-line max-depth
                                             if (!Number.isNaN(date.getTime())) {
                                                 cooldownMs = Math.max(date.getTime() - Date.now(), 1000);
                                             }
@@ -530,12 +694,14 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                             authRetryError = `refresh failed for account=${account.label} attempt ${authRetry + 1}/${MAX_AUTH_RETRIES}: ${refreshSucceeded.error?.slice(0, 200) ?? "unknown"}`;
                                             lastError = authRetryError;
                                             logger.always(`[proxy] ⚠ account=${account.label} refresh failed on attempt ${authRetry + 1}`);
+                                            // eslint-disable-next-line max-depth
                                             if (accountState.consecutiveRefreshFailures >=
                                                 MAX_CONSECUTIVE_REFRESH_FAILURES) {
                                                 await disableAccountUntilReauth(account, accountState);
                                                 authFailureMessage = formatReauthMessage(account.label);
                                                 break;
                                             }
+                                            // eslint-disable-next-line max-depth
                                             if (authRetry < MAX_AUTH_RETRIES - 1) {
                                                 await sleep(2000);
                                             }
@@ -549,9 +715,10 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                             const retryResp = await fetch(url, {
                                                 method: "POST",
                                                 headers,
-                                                body: bodyStr,
+                                                body: buildUpstreamBody(),
                                                 signal: AbortSignal.timeout(UPSTREAM_FETCH_TIMEOUT_MS),
                                             });
+                                            // eslint-disable-next-line max-depth
                                             if (retryResp.ok) {
                                                 authRetrySucceeded = true;
                                                 accountState.consecutiveRefreshFailures = 0;
@@ -647,6 +814,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                             lastError = retryBody;
                                             logger.debug(`[proxy] retry ${authRetry + 1} failed: ${retryStatus} ${retryBody.substring(0, 120)}`);
                                             recordError(account.label, account.type, retryStatus);
+                                            // eslint-disable-next-line max-depth
                                             if (retryStatus === 429) {
                                                 sawRateLimit = true;
                                                 const retryAfter = retryResp.headers.get("retry-after");
@@ -659,6 +827,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                                 recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
                                                 break;
                                             }
+                                            // eslint-disable-next-line max-depth
                                             if (retryStatus === 401 ||
                                                 retryStatus === 402 ||
                                                 retryStatus === 403) {
@@ -668,12 +837,14 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                                 }
                                                 continue;
                                             }
+                                            // eslint-disable-next-line max-depth
                                             if (isTransientHttpFailure(retryStatus, retryBody)) {
                                                 // Decision 8: No cooldown for transient errors — rotate immediately
                                                 sawTransientFailure = true;
                                                 break;
                                             }
                                             logAttempt(retryStatus, "api_error", summarizeErrorMessage(retryBody));
+                                            // eslint-disable-next-line max-depth
                                             try {
                                                 return JSON.parse(retryBody);
                                             }
@@ -695,7 +866,9 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                         }
                                     }
                                     if (!authRetrySucceeded) {
+                                        // eslint-disable-next-line max-depth
                                         if (!accountState.permanentlyDisabled) {
+                                            // eslint-disable-next-line max-depth
                                             if (!accountState.coolingUntil ||
                                                 accountState.coolingUntil <= Date.now()) {
                                                 accountState.coolingUntil =
@@ -953,6 +1126,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                             "anthropic-ratelimit-tokens-limit",
                                         ]) {
                                             const val = response.headers.get(h);
+                                            // eslint-disable-next-line max-depth
                                             if (val) {
                                                 responseHeaders[h] = val;
                                             }

package/dist/lib/telemetry/telemetryService.d.ts

@@ -8,7 +8,7 @@ export type HealthMetrics = {
 };
 export declare class TelemetryService {
     private static instance;
-    private sdk?;
+    private tracerProvider?;
     private enabled;
     private initialized;
     private meter?;

package/dist/lib/telemetry/telemetryService.js

@@ -1,12 +1,12 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { metrics, trace, } from "@opentelemetry/api";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { context, metrics, trace, } from "@opentelemetry/api";
+import { BasicTracerProvider, BatchSpanProcessor, } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { logger } from "../utils/logger.js";
 export class TelemetryService {
     static instance;
-    sdk;
+    tracerProvider;
     enabled = false;
     initialized = false;
     meter;
@@ -52,11 +52,16 @@ export class TelemetryService {
                 [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
                 [ATTR_SERVICE_VERSION]: process.env.OTEL_SERVICE_VERSION || "3.0.1",
             });
-            this.sdk = new NodeSDK({
+            const exporter = new OTLPTraceExporter({
+                url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT
+                    ? `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT}/v1/traces`
+                    : undefined,
+            });
+            this.tracerProvider = new BasicTracerProvider({
                 resource,
-                // Note: Metric reader configured separately
-                instrumentations: [getNodeAutoInstrumentations()],
+                spanProcessors: [new BatchSpanProcessor(exporter)],
             });
+            trace.setGlobalTracerProvider(this.tracerProvider);
             this.meter = metrics.getMeter("neurolink-ai");
             this.tracer = trace.getTracer("neurolink-ai");
             this.initializeMetrics();
@@ -101,12 +106,21 @@ export class TelemetryService {
             return;
         }
         try {
-            await this.sdk?.start();
+            // Register AsyncLocalStorage context manager for proper parent-child
+            // span relationships across async boundaries (required for startActiveSpan)
+            try {
+                const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks");
+                context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
+            }
+            catch {
+                // context-async-hooks not installed — context propagation
+                // will use the default (noop) manager
+            }
             this.initialized = true;
-            logger.debug("[Telemetry] SDK started successfully");
+            logger.debug("[Telemetry] Tracer provider started successfully");
         }
         catch (error) {
-            logger.error("[Telemetry] Failed to start SDK:", error);
+            logger.error("[Telemetry] Failed to start:", error);
             this.enabled = false;
             this.initialized = false;
         }
@@ -294,11 +308,11 @@ export class TelemetryService {
     }
     // Cleanup
     async shutdown() {
-        if (this.enabled && this.sdk) {
+        if (this.enabled && this.tracerProvider) {
             try {
-                await this.sdk.shutdown();
+                await this.tracerProvider.shutdown();
                 this.initialized = false;
-                logger.debug("[Telemetry] SDK shutdown completed");
+                logger.debug("[Telemetry] Tracer provider shutdown completed");
             }
             catch (error) {
                 logger.error("[Telemetry] Error during shutdown:", error);

package/dist/models/anthropicModels.d.ts

@@ -20,8 +20,10 @@ export declare enum AnthropicModel {
     CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20241022",
     CLAUDE_3_5_SONNET_V2 = "claude-3-5-sonnet-v2-20241022",
     CLAUDE_SONNET_4 = "claude-sonnet-4-20250514",
+    CLAUDE_SONNET_4_6 = "claude-sonnet-4-6",
     CLAUDE_3_OPUS = "claude-3-opus-20240229",
-    CLAUDE_OPUS_4 = "claude-opus-4-20250514"
+    CLAUDE_OPUS_4 = "claude-opus-4-20250514",
+    CLAUDE_OPUS_4_6 = "claude-opus-4-6"
 }
 /**
  * Model access mapping by subscription tier

package/dist/models/anthropicModels.js

@@ -27,10 +27,14 @@ export var AnthropicModel;
     AnthropicModel["CLAUDE_3_5_SONNET_V2"] = "claude-3-5-sonnet-v2-20241022";
     // Claude Sonnet 4 (Latest Sonnet)
     AnthropicModel["CLAUDE_SONNET_4"] = "claude-sonnet-4-20250514";
+    // Claude Sonnet 4.6
+    AnthropicModel["CLAUDE_SONNET_4_6"] = "claude-sonnet-4-6";
     // Claude 3 Opus (Legacy flagship)
     AnthropicModel["CLAUDE_3_OPUS"] = "claude-3-opus-20240229";
     // Claude Opus 4 (Latest flagship)
     AnthropicModel["CLAUDE_OPUS_4"] = "claude-opus-4-20250514";
+    // Claude Opus 4.6
+    AnthropicModel["CLAUDE_OPUS_4_6"] = "claude-opus-4-6";
 })(AnthropicModel || (AnthropicModel = {}));
 // ============================================================================
 // MODEL TIER ACCESS DEFINITIONS
@@ -56,6 +60,7 @@ export const MODEL_TIER_ACCESS = {
         AnthropicModel.CLAUDE_3_5_SONNET,
         AnthropicModel.CLAUDE_3_5_SONNET_V2,
         AnthropicModel.CLAUDE_SONNET_4,
+        AnthropicModel.CLAUDE_SONNET_4_6,
     ],
     // Max tier: All models including Opus
     max: ["*"], // All models
@@ -167,6 +172,32 @@ export const MODEL_METADATA = {
         family: "opus",
         description: "Latest flagship model with advanced reasoning",
     },
+    // Claude Sonnet 4.6
+    [AnthropicModel.CLAUDE_SONNET_4_6]: {
+        displayName: "Claude Sonnet 4.6",
+        contextWindow: 1000000,
+        maxOutputTokens: 64000,
+        supportsVision: true,
+        supportsExtendedThinking: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+        deprecated: false,
+        family: "sonnet",
+        description: "Claude 4.6 Sonnet with 1M context window",
+    },
+    // Claude Opus 4.6
+    [AnthropicModel.CLAUDE_OPUS_4_6]: {
+        displayName: "Claude Opus 4.6",
+        contextWindow: 1000000,
+        maxOutputTokens: 64000,
+        supportsVision: true,
+        supportsExtendedThinking: true,
+        supportsToolUse: true,
+        supportsStreaming: true,
+        deprecated: false,
+        family: "opus",
+        description: "Claude 4.6 Opus flagship with 1M context window",
+    },
 };
 // ============================================================================
 // DEFAULT MODELS BY TIER
@@ -417,11 +448,16 @@ export function getLatestModelsByFamily() {
     const familyPriority = {
         haiku: [AnthropicModel.CLAUDE_3_5_HAIKU, AnthropicModel.CLAUDE_3_HAIKU],
         sonnet: [
+            AnthropicModel.CLAUDE_SONNET_4_6,
             AnthropicModel.CLAUDE_SONNET_4,
             AnthropicModel.CLAUDE_3_5_SONNET_V2,
             AnthropicModel.CLAUDE_3_5_SONNET,
         ],
-        opus: [AnthropicModel.CLAUDE_OPUS_4, AnthropicModel.CLAUDE_3_OPUS],
+        opus: [
+            AnthropicModel.CLAUDE_OPUS_4_6,
+            AnthropicModel.CLAUDE_OPUS_4,
+            AnthropicModel.CLAUDE_3_OPUS,
+        ],
     };
     for (const family of Object.keys(familyPriority)) {
         for (const model of familyPriority[family]) {

package/dist/processors/media/VideoProcessor.d.ts

@@ -10,8 +10,9 @@
  * The extracted content is formatted as text + images that can be sent to any
  * AI provider for analysis.
  *
- * Uses fluent-ffmpeg for video processing and sharp for frame resizing.
- * Requires ffmpeg/ffprobe to be available (via ffmpeg-static or system PATH).
+ * Uses mediabunny (pure TypeScript) for metadata extraction, with fluent-ffmpeg
+ * as a fallback for unsupported formats. Requires ffmpeg for keyframe/subtitle
+ * extraction (via ffmpeg-static or system PATH).
  *
  * Key features:
  * - Adaptive keyframe extraction intervals based on video duration
@@ -157,6 +158,11 @@ export declare class VideoProcessor extends BaseFileProcessor<ProcessedVideo> {
      * @returns Success result with probe data or error message
      */
     private probeVideo;
+    /**
+     * Probe a video file using mediabunny (pure TypeScript, no native binary).
+     * Falls back to ffprobe if mediabunny fails or doesn't support the format.
+     */
+    private probeVideoWithMediabunny;
     /**
      * Build a structured metadata object from ffprobe data.
      *