@juspay/neurolink 9.79.1 → 9.79.3

package/dist/server/routes/claudeProxyRoutes.js

@@ -20,6 +20,7 @@ import { tracers } from "../../telemetry/tracers.js";
 import { withSpan } from "../../telemetry/withSpan.js";
 import { ProxyTracer, recordFallbackAttempt } from "../../proxy/proxyTracer.js";
 import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
+import { relocateClientSystemIntoMessages } from "../../proxy/systemRelocation.js";
 import { logBodyCapture, logRequest, logRequestAttempt, logStreamError, } from "../../proxy/requestLogger.js";
 import { createSSEInterceptor } from "../../proxy/sseInterceptor.js";
 import { needsRefresh, persistTokens, refreshToken, } from "../../proxy/tokenRefresh.js";
@@ -332,6 +333,63 @@ async function maybeRefreshClaudeSnapshot(accountLabel, accountKey, headers, bod
     }
     return next;
 }
+/**
+ * Parse response-side details (model, finish reason, invoked tools) from a
+ * non-streaming Anthropic reply so they can be recorded on the trace span.
+ */
+function extractResponseInfo(responseJson) {
+    const info = {};
+    if (!responseJson || typeof responseJson !== "object") {
+        return info;
+    }
+    const r = responseJson;
+    if (typeof r.model === "string") {
+        info.responseModel = r.model;
+    }
+    if (typeof r.stop_reason === "string") {
+        info.finishReason = r.stop_reason;
+    }
+    if (typeof r.stop_sequence === "string") {
+        info.stopSequence = r.stop_sequence;
+    }
+    if (Array.isArray(r.content)) {
+        const toolCalls = r.content
+            .filter((b) => !!b &&
+            typeof b === "object" &&
+            b.type === "tool_use")
+            .map((b) => String(b.name ?? ""))
+            .filter((n) => n.length > 0);
+        if (toolCalls.length > 0) {
+            info.toolCalls = toolCalls;
+        }
+    }
+    return info;
+}
+/**
+ * Build response-info from streaming telemetry (responding model, finish
+ * reason, and the tools the model invoked via tool_use content blocks) so the
+ * streaming path records the same gen_ai.response.* attributes as non-streaming.
+ */
+function responseInfoFromStream(data) {
+    const info = {};
+    if (data.model) {
+        info.responseModel = data.model;
+    }
+    if (data.stopReason) {
+        info.finishReason = data.stopReason;
+    }
+    if (data.stopSequence) {
+        info.stopSequence = data.stopSequence;
+    }
+    const toolCalls = (data.contentBlocks ?? [])
+        .filter((b) => b.type === "tool_use")
+        .map((b) => String(b.toolName ?? ""))
+        .filter((n) => n.length > 0);
+    if (toolCalls.length > 0) {
+        info.toolCalls = toolCalls;
+    }
+    return info;
+}
 /**
  * Polyfill the request body for OAuth accounts.
  * Claude Code injects a billing header, agent block, and metadata.user_id
@@ -350,25 +408,21 @@ function polyfillOAuthBody(bodyStr, accountToken, snapshot, preferredSessionId)
             text: snapshot?.body?.agentBlock ||
                 "You are a Claude agent, built on Anthropic's Claude Agent SDK.",
         };
-        // Normalise system to array and APPEND billing + agent blocks.
-        // IMPORTANT: We append (not prepend) to preserve the client's cache
-        // prefix chain. Anthropic's prompt caching uses prefix matching — if we
-        // insert anything before the client's system blocks, we invalidate all
-        // cached content (tools, system prompt, message history).
+        // Normalise system to an array, then route by client type.
         //
-        // Claude Code sends a billing block with a `cch=<hash>` value that changes
-        // on every request. We fix this by:
-        //   1. Removing the client's billing block from its current position
-        //   2. Stabilizing it while keeping the official Claude Code shape
-        //   3. Appending it at the END so the cacheable system blocks stay
-        //      at the front of the prefix chain
+        // The subscription/OAuth path only accepts a `system` it recognises as the
+        // genuine Claude Code prompt. A real CC client sends its own billing + agent
+        // identity blocks alongside the canonical prompt — we keep those in place and
+        // just stabilise the volatile billing `cch`. A custom client (Curator) sends
+        // its own arbitrary system prompt with NO agent block; left in `system` it is
+        // rejected as `rate_limit_error: "Error"`, so we relocate it into the message
+        // stream and send only the recognised billing + agent blocks as `system`.
         if (parsed.system) {
             if (typeof parsed.system === "string") {
                 parsed.system = [{ type: "text", text: parsed.system }];
             }
             if (Array.isArray(parsed.system)) {
-                // Find and remove existing billing/agent blocks from wherever
-                // the client placed them (typically at system[0])
+                // Find existing billing/agent blocks wherever the client placed them.
                 const billingIdx = parsed.system.findIndex((b) => typeof b.text === "string" &&
                     b.text.includes("x-anthropic-billing-header"));
                 const agentIdx = parsed.system.findIndex((b) => typeof b.text === "string" && b.text.includes("Claude Agent SDK"));
@@ -376,17 +430,29 @@ function polyfillOAuthBody(bodyStr, accountToken, snapshot, preferredSessionId)
                     type: "text",
                     text: buildStableClaudeCodeBillingHeader(parsed.system[billingIdx]?.text ?? snapshot?.body?.billingHeader),
                 };
-                // Remove in reverse index order so indices stay valid
+                // A genuine Claude Code client supplies its own agent-identity block;
+                // a custom client (Curator) does not.
+                const isClaudeCodeClient = agentIdx >= 0;
+                // Strip billing/agent from their positions (reverse order so indices
+                // stay valid). What remains is the client's "extra" system content.
                 const indicesToRemove = [billingIdx, agentIdx]
                     .filter((i) => i >= 0)
                     .sort((a, b) => b - a);
                 for (const idx of indicesToRemove) {
                     parsed.system.splice(idx, 1);
                 }
-                // Always append a deterministic billing block at the end.
-                // If the client sent one, we stripped its dynamic cch= and use
-                // our stable version instead. If not, we add ours.
-                parsed.system = [...parsed.system, billingBlock, agentBlock];
+                if (!isClaudeCodeClient && parsed.system.length > 0) {
+                    // Non-CC client: relocate its system into the message stream so the
+                    // subscription/OAuth path accepts the request, then send only the
+                    // recognised billing + agent blocks as `system`.
+                    relocateClientSystemIntoMessages(parsed, parsed.system);
+                    parsed.system = [billingBlock, agentBlock];
+                }
+                else {
+                    // Genuine Claude Code (or no extra blocks): keep the recognised system
+                    // and append the deterministic billing + agent blocks at the end.
+                    parsed.system = [...parsed.system, billingBlock, agentBlock];
+                }
             }
         }
         else {
@@ -680,6 +746,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 capturedTracer.logStreamEvents(data.events);
+                capturedTracer.setResponseInfo(responseInfoFromStream(data));
                 const rateLimit5h = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-5h-utilization") ?? "");
                 const rateLimit7d = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-7d-utilization") ?? "");
                 const usageUpdate = {
@@ -871,6 +938,7 @@ async function handleClaudePassthroughJsonResponse(args) {
                 tracer.setUsage(usageWithRates);
             }
         }
+        tracer.setResponseInfo(extractResponseInfo(responseJson));
         tracer.recordMetrics();
         const responseJsonStr = JSON.stringify(responseJson);
         tracer.recordBodySizes(bodyStr.length, responseJsonStr.length);
@@ -1556,6 +1624,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 capturedTracer.logStreamEvents(data.events);
+                capturedTracer.setResponseInfo(responseInfoFromStream(data));
                 const rateLimit5h = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-5h-utilization") ?? "");
                 const rateLimit7d = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-7d-utilization") ?? "");
                 const usageUpdate = {
@@ -1773,6 +1842,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
                 tracer.setUsage(usageWithRates);
             }
         }
+        tracer.setResponseInfo(extractResponseInfo(responseJson));
         tracer.recordMetrics();
         const responseJsonStr = JSON.stringify(responseJson);
         tracer.recordBodySizes(finalBodyStr.length, responseJsonStr.length);
@@ -1875,6 +1945,7 @@ async function handleAnthropicSuccessfulRetryResponse(args) {
                         cacheReadTokens: data.usage.cacheReadInputTokens,
                     });
                     capturedTracer.logStreamEvents(data.events);
+                    capturedTracer.setResponseInfo(responseInfoFromStream(data));
                     capturedTracer.logUpstreamResponseHeaders(Object.fromEntries([...capturedRetryResp.headers.entries()]));
                     capturedTracer.recordMetrics();
                     capturedTracer.recordBodySizes(capturedRetryRequestBytes, data.totalBytesReceived);
@@ -1961,6 +2032,7 @@ async function handleAnthropicSuccessfulRetryResponse(args) {
                 cacheReadTokens: retryUsage.cache_read_input_tokens ?? 0,
             });
         }
+        tracer.setResponseInfo(extractResponseInfo(retryJson));
         tracer.recordMetrics();
         const retryJsonStr = JSON.stringify(retryJson);
         tracer.recordBodySizes(finalBodyStr.length, retryJsonStr.length);
@@ -2083,7 +2155,14 @@ async function handleAnthropicAuthRetry(args) {
             currentLastError = retryBody;
             logger.debug(`[proxy] retry ${authRetry + 1} failed: ${retryStatus} ${retryBody.substring(0, 120)}`);
             recordAttemptError(account.label, account.type, retryStatus);
-            if (retryStatus === 429) {
+            // A real rate-limit 429 rotates accounts. But an anti-abuse / construction
+            // 429 (no rate-limit headers, body "Error") is NOT a real rate limit:
+            // advancing the primary or rotating cannot help and only burns quota. Skip
+            // the rotate path for it so it falls through to the terminal error return
+            // below, surfacing the truthful upstream error — mirroring the initial
+            // fetch path's fast-fail (isAntiAbuseConstruction429).
+            if (retryStatus === 429 &&
+                !isAntiAbuseConstruction429(retryRespHeaders, retryBody)) {
                 currentSawRateLimit = true;
                 advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
                 break;
@@ -2373,6 +2452,13 @@ function createClaudeRequestRuntimeContext(args) {
             model: body.model,
             stream: body.stream ?? false,
             toolCount: Array.isArray(body.tools) ? body.tools.length : 0,
+            toolNames: Array.isArray(body.tools)
+                ? body.tools
+                    .map((t) => t && typeof t === "object" && "name" in t
+                    ? String(t.name ?? "")
+                    : "")
+                    .filter((n) => n.length > 0)
+                : undefined,
             sessionId: ctx.headers["x-neurolink-session-id"] ??
                 ctx.headers["x-claude-code-session-id"] ??
                 undefined,
@@ -2649,6 +2735,24 @@ async function prepareAnthropicAccountAttempt(args) {
         upstreamSpan,
     };
 }
+/**
+ * Detect Anthropic's anti-abuse / request-construction 429.
+ *
+ * The subscription/OAuth path rejects requests it does not recognise as genuine
+ * Claude Code traffic with a 429 `rate_limit_error` whose message is literally
+ * "Error" and which carries NONE of the real rate-limit headers (no retry-after,
+ * no anthropic-ratelimit-*). This is NOT a capacity limit — retrying or rotating
+ * accounts cannot fix it and only burns quota, so the caller must fail fast and
+ * surface the truthful upstream error instead of "all accounts rate-limited".
+ */
+function isAntiAbuseConstruction429(headers, body) {
+    const hasRetryAfter = !!headers["retry-after"];
+    const hasRateLimitHeaders = Object.keys(headers).some((k) => k.toLowerCase().startsWith("anthropic-ratelimit-"));
+    if (hasRetryAfter || hasRateLimitHeaders) {
+        return false;
+    }
+    return (body.includes("rate_limit_error") && /"message"\s*:\s*"Error"/.test(body));
+}
 async function fetchAnthropicAccountResponse(args) {
     const { url, headers, finalBodyStr, account, accountState: _accountState2, enabledAccounts: _enabledAccounts, orderedAccounts: _orderedAccounts, tracer, logAttempt, logProxyBody, fetchStartMs, attemptNumber, currentLastError, currentSawRateLimit, currentSawNetworkError, upstreamSpan, } = args;
     let lastError = currentLastError;
@@ -2719,6 +2823,30 @@ async function fetchAnthropicAccountResponse(args) {
             responseStatus: 429,
             durationMs: Date.now() - fetchStartMs,
         });
+        // Anti-abuse / request-construction 429 (no rate-limit headers, body
+        // "Error"): rotating accounts cannot help and only burns quota. Fail fast
+        // and surface the truthful upstream error instead of the misleading
+        // "all accounts rate-limited" after 44 wasted attempts.
+        if (isAntiAbuseConstruction429(errRespHeaders, String(lastError))) {
+            logger.always(`[proxy] ← 429 account=${account.label} anti-abuse/construction rejection (no ratelimit headers, body="Error") — NOT a real rate limit; returning upstream error without rotating`);
+            logAttempt(429, "construction_rejection", String(lastError));
+            tracer?.setError("construction_rejection", String(lastError).slice(0, 500));
+            currentUpstreamSpan?.end();
+            const passthrough = new Response(String(lastError), {
+                status: 429,
+                headers: {
+                    "content-type": errRespHeaders["content-type"] ?? "application/json",
+                },
+            });
+            return {
+                continueLoop: false,
+                response: passthrough,
+                lastError,
+                sawRateLimit,
+                sawNetworkError,
+                upstreamSpan: undefined,
+            };
+        }
         logger.always(`[proxy] ← 429 account=${account.label} retry-after=${retryAfterMs}ms (upstream) ratelimit-status=${errRespHeaders["anthropic-ratelimit-unified-status"] ?? "unknown"}`);
         logAttempt(429, "rate_limit_error", String(lastError));
         tracer?.setError("rate_limit_error", String(lastError).slice(0, 500));

package/dist/types/proxy.d.ts

@@ -771,10 +771,20 @@ export type ProxyRequestContext = {
     model: string;
     stream: boolean;
     toolCount: number;
+    /** Names of the tools advertised in the request (what the caller exposed). */
+    toolNames?: string[];
     sessionId?: string;
     userAgent?: string;
     clientApp?: string;
 };
+/** Response-side details parsed from the upstream reply (model, finish, tools). */
+export type ResponseInfoContext = {
+    responseModel?: string;
+    finishReason?: string;
+    stopSequence?: string;
+    /** Names of the tools the model actually invoked (tool_use blocks). */
+    toolCalls?: string[];
+};
 /** Context recorded when an account is selected for a proxy request. */
 export type AccountSelectionContext = {
     strategy: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.79.1",
+  "version": "9.79.3",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, voice (TTS/STT/realtime), and professional CLI. 58+ external MCP servers discoverable, multimodal file processing, RAG pipelines. Build, test, and deploy AI applications with 21+ providers: OpenAI, Anthropic, Google AI Studio, Google Vertex, AWS Bedrock, Azure OpenAI, Mistral, LiteLLM, SageMaker, Hugging Face, Ollama, OpenAI-compatible, OpenRouter, DeepSeek, NVIDIA NIM, LM Studio, llama.cpp, plus voice (OpenAI TTS, ElevenLabs, Deepgram, Azure Speech).",
   "author": {
@@ -118,6 +118,9 @@
     "test:auth": "npx tsx test/continuous-test-suite-auth.ts",
     "test:autoresearch": "npx tsx test/continuous-test-suite-autoresearch.ts",
     "test:autoresearch:redis": "npx tsx test/continuous-test-suite-autoresearch-redis.ts",
+    "test:anthropic-tools-policy": "npx tsx test/continuous-test-suite-anthropic-tools-policy.ts",
+    "test:anthropic-multimodal": "npx tsx test/continuous-test-suite-anthropic-multimodal.ts",
+    "test:excel-interop": "npx tsx test/continuous-test-suite-excel-interop.ts",
     "test:envguard": "npx tsx test/helpers/envGuard.test.ts",
     "test:tool-routing-cli:vitest": "pnpm exec vitest run test/toolRoutingCli.test.ts",
     "test:tool-routing-cli": "pnpm run test:tool-routing-cli:vitest && npx tsx test/continuous-test-suite-tool-routing-cli.ts",
@@ -131,7 +134,7 @@
     "test:tool-routing": "pnpm run test:unit:vitest && npx tsx test/continuous-test-suite-tool-routing.ts",
     "test:tool-routing-semantic:vitest": "pnpm exec vitest run test/toolRoutingSemantic.test.ts",
     "test:tool-routing-semantic": "pnpm run test:tool-routing-semantic:vitest && npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && 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:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:tool-routing-semantic:vitest",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && 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:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:tool-routing-semantic:vitest && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop",
     "// 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": "",
@@ -598,6 +601,9 @@
       "rollup@>=4.0.0 <4.59.0": ">=4.59.0",
       "shell-quote@<1.8.4": ">=1.8.4",
       "undici@>=8.0.0": ">=7.24.0 <8.0.0"
+    },
+    "patchedDependencies": {
+      "mammoth@1.12.0": "patches/mammoth@1.12.0.patch"
     }
   },
   "os": [