@juspay/neurolink 9.79.1 → 9.79.3

package/dist/lib/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/lib/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/dist/processors/document/ExcelProcessor.js

@@ -44,7 +44,15 @@ async function loadExcelJS() {
         return _exceljs;
     }
     try {
-        _exceljs = await import(/* @vite-ignore */ "exceljs");
+        const mod = await import(/* @vite-ignore */ "exceljs");
+        // exceljs is a CommonJS module. Under Node ESM (and some bundlers) the
+        // `Workbook` constructor is exposed at runtime on the namespace's `default`
+        // export rather than on the namespace itself — so a bare
+        // `new ExcelJS.Workbook()` throws "ExcelJS.Workbook is not a constructor"
+        // (TS still types it as present via esModuleInterop, masking the bug).
+        // Normalise here so the constructor is reachable regardless of interop style.
+        const ns = mod;
+        _exceljs = (ns.Workbook ? ns : (ns.default ?? ns));
         return _exceljs;
     }
     catch (err) {

package/dist/providers/anthropic.js

@@ -22,6 +22,8 @@ import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { resolveClaudeMaxTokens } from "../utils/tokenLimits.js";
+import { toAnthropicImageBlock, fileToAnthropicBlock, } from "./anthropicImageBlocks.js";
+import { modelDeprecatesTemperature } from "../core/modules/structuredOutputPolicy.js";
 import { createChunkQueue, createDeferredAnalytics, stringifyToolInput, } from "./openaiChatCompletionsClient.js";
 /**
  * Beta headers for Claude Code integration.
@@ -209,45 +211,6 @@ const parseRateLimitHeaders = (headers) => {
 // ───────────────────────────────────────────────────────────────────────────
 // Native Messages-API conversion helpers (NeuroLink/V3 shapes → Anthropic)
 // ───────────────────────────────────────────────────────────────────────────
-/**
- * Convert an image part (data URL, bare base64, https URL, or byte array)
- * into an Anthropic image block. Returns undefined for unusable inputs.
- */
-const toAnthropicImageBlock = (data) => {
-    if (data instanceof Uint8Array) {
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: "image/png",
-                data: Buffer.from(data).toString("base64"),
-            },
-        };
-    }
-    if (typeof data !== "string" && !(data instanceof URL)) {
-        return undefined;
-    }
-    const str = data instanceof URL ? data.toString() : data;
-    const dataUrlMatch = str.match(/^data:(image\/[a-z+.-]+);base64,(.+)$/i);
-    if (dataUrlMatch) {
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: dataUrlMatch[1],
-                data: dataUrlMatch[2],
-            },
-        };
-    }
-    if (/^https?:\/\//i.test(str)) {
-        return { type: "image", source: { type: "url", url: str } };
-    }
-    // Bare base64 payload — assume PNG (matches the OpenAI-compat client).
-    return {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: str },
-    };
-};
 /**
  * Read an Anthropic cache breakpoint from a message/part/tool carrier.
  * MessageBuilder marks system messages (and GenerationHandler marks the last
@@ -347,6 +310,35 @@ const messagesToAnthropic = (msgs) => {
                             blocks.push(cc ? { ...img, cache_control: cc } : img);
                         }
                     }
+                    else if (p?.type === "file") {
+                        // AI-SDK v6 encodes images AND PDFs as `type:"file"` parts in the
+                        // LanguageModel prompt that `doGenerate` receives. Without this
+                        // branch the image is dropped on the tool-using generate path and
+                        // the model never sees it ("no image detected").
+                        //
+                        // Runtime guard: p comes from message parsing and may not match the
+                        // expected shape. Verify p is an object and that mediaType, if
+                        // present, is a string (not an object/array from a malformed part).
+                        // Skip gracefully rather than passing a bad shape to fileToAnthropicBlock.
+                        const isValidFilePart = typeof p === "object" &&
+                            p !== null &&
+                            ("mediaType" in p
+                                ? typeof p.mediaType === "string"
+                                : true);
+                        const block = isValidFilePart
+                            ? fileToAnthropicBlock(p)
+                            : undefined;
+                        if (block) {
+                            const cc = cacheControlOf(p);
+                            if (cc) {
+                                // block is a fresh object from fileToAnthropicBlock; mutate in
+                                // place to keep the discriminated-union type (a spread widens it
+                                // past ContentBlockParam).
+                                block.cache_control = cc;
+                            }
+                            blocks.push(block);
+                        }
+                    }
                 }
                 if (blocks.length > 0) {
                     applyMessageCacheControl(blocks, msg);
@@ -1136,7 +1128,9 @@ export class AnthropicProvider extends BaseProvider {
                     messages,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
-                    ...(options.temperature !== undefined && options.temperature !== null
+                    ...(options.temperature !== undefined &&
+                        options.temperature !== null &&
+                        !modelDeprecatesTemperature(modelId)
                         ? { temperature: options.temperature }
                         : {}),
                     ...(options.topP !== undefined && options.topP !== null
@@ -1386,7 +1380,9 @@ export class AnthropicProvider extends BaseProvider {
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
                     stream: true,
                     ...(payload.system ? { system: payload.system } : {}),
-                    ...(options.temperature !== undefined && options.temperature !== null
+                    ...(options.temperature !== undefined &&
+                        options.temperature !== null &&
+                        !modelDeprecatesTemperature(modelId)
                         ? { temperature: options.temperature }
                         : {}),
                     ...(anthropicTools && anthropicTools.length > 0

package/dist/providers/anthropicImageBlocks.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure converters from multimodal content parts into native Anthropic
+ * Messages-API content blocks (image / document).
+ *
+ * Two input shapes reach the native Anthropic surface:
+ *
+ *  1. NeuroLink/V3 multimodal parts — `{ type: "image", image }` produced by
+ *     the multimodal message builder (base64, data URL, https URL, or bytes).
+ *
+ *  2. AI-SDK LanguageModel prompt parts — `{ type: "file", mediaType, data }`.
+ *     This is how `ai@6` encodes BOTH images and PDFs in the prompt that the
+ *     provider's `doGenerate(options.prompt)` receives. Before this module the
+ *     converter only handled `type:"image"`, so on the tool-using generate
+ *     path (which always normalises images to `type:"file"`) the image part
+ *     was silently dropped — the model never saw the image ("no image
+ *     detected"). Gemini/Vertex are immune because they read `input.images`
+ *     directly in their own builders instead of going through this conversion.
+ *
+ * Media type is taken from the AI-SDK-provided `mediaType` when present, then
+ * sniffed from magic bytes, and only then defaulted — a hardcoded `image/png`
+ * default silently corrupts JPEG/GIF/WebP uploads (the Anthropic API rejects a
+ * mislabeled base64 image with HTTP 400 and the image vanishes).
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+/**
+ * Detect a supported image media type from a buffer's magic bytes. Returns
+ * undefined when the bytes are not one of the four Anthropic-supported formats.
+ */
+export declare function sniffImageMediaType(bytes: Uint8Array): Anthropic.Messages.Base64ImageSource["media_type"] | undefined;
+/**
+ * Convert an image part (data URL, bare base64, https URL, byte array, or
+ * ArrayBuffer) into an Anthropic image block. Honors `mediaTypeHint` (the
+ * AI-SDK `mediaType`), falls back to magic-byte sniffing, then to image/png.
+ * Returns undefined for unusable inputs.
+ */
+export declare function toAnthropicImageBlock(data: unknown, mediaTypeHint?: string): Anthropic.Messages.ImageBlockParam | undefined;
+/**
+ * Convert an AI-SDK `{ type: "file", mediaType, data }` content part into the
+ * matching Anthropic content block: image/* → image block (media type honored,
+ * not hardcoded), application/pdf → document block. Returns undefined for
+ * unsupported media types (so the caller simply omits them rather than 400ing).
+ * When `mediaType` is absent, image bytes are still salvaged via sniffing.
+ */
+export declare function fileToAnthropicBlock(part: {
+    mediaType?: string;
+    data?: unknown;
+}): Anthropic.Messages.ContentBlockParam | undefined;