@juspay/neurolink 10.6.4 → 10.7.0

package/dist/lib/providers/sagemaker/streaming.js

@@ -87,12 +87,12 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                     if (done) {
                         // Stream ended - send final chunk if needed
                         if (!finalUsage && accumulatedText) {
-                            finalUsage = estimateTokenUsage("", accumulatedText);
+                            finalUsage = estimateTokenUsage(options.prompt ?? "", accumulatedText);
                         }
                         const finalChunk = {
                             type: "finish",
                             finishReason: "stop",
-                            usage: finalUsage,
+                            usage: toLanguageModelV2Usage(finalUsage),
                         };
                         controller.enqueue(finalChunk);
                         options.onComplete?.(finalUsage || {
@@ -182,11 +182,11 @@ async function createProtocolSpecificStream(responseStream, parser, capability,
                         if (parser.isComplete(chunk)) {
                             finalUsage =
                                 parser.extractUsage(chunk) ||
-                                    estimateTokenUsage("", accumulatedText);
+                                    estimateTokenUsage(options.prompt ?? "", accumulatedText);
                             const finalChunk = {
                                 type: "finish",
                                 finishReason: chunk.finishReason || "stop",
-                                usage: finalUsage,
+                                usage: toLanguageModelV2Usage(finalUsage),
                             };
                             controller.enqueue(finalChunk);
                             options.onComplete?.(finalUsage);
@@ -271,7 +271,7 @@ async function createSyntheticStreamFromResponse(responseStream, options) {
                 const finalChunk = {
                     type: "finish",
                     finishReason: "stop",
-                    usage,
+                    usage: toLanguageModelV2Usage(usage),
                 };
                 controller.enqueue(finalChunk);
                 options.onComplete?.(usage);
@@ -305,7 +305,7 @@ export async function createSyntheticStream(text, usage, options = {}) {
             const finalChunk = {
                 type: "finish",
                 finishReason: "stop",
-                usage,
+                usage: toLanguageModelV2Usage(usage),
             };
             controller.enqueue(finalChunk);
             options.onComplete?.(usage);
@@ -313,6 +313,64 @@ export async function createSyntheticStream(text, usage, options = {}) {
         },
     });
 }
+/**
+ * Map the internal SageMakerUsage shape to AI SDK v2 usage keys. Stream
+ * finish parts previously carried promptTokens/completionTokens, but the
+ * SDK's v2→v3 bridge reads inputTokens/outputTokens/totalTokens — every
+ * streamed SageMaker turn resolved to undefined (zero) usage.
+ */
+function toLanguageModelV2Usage(usage) {
+    const inputTokens = usage?.promptTokens ?? 0;
+    const outputTokens = usage?.completionTokens ?? 0;
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: usage?.total || inputTokens + outputTokens,
+    };
+}
+/**
+ * Extract REAL token usage from a complete (non-streaming) SageMaker
+ * response body when the endpoint reports it. Covers the OpenAI-compatible
+ * shape (vLLM / TGI-OpenAI: usage.prompt_tokens/completion_tokens), the
+ * generic input_tokens/output_tokens shape, and the HuggingFace TGI shape
+ * (details.tokens.input/generated). Returns undefined when no real counts
+ * are present so callers can fall back to estimateTokenUsage.
+ */
+export function parseUsageFromResponseBody(body) {
+    // TGI-style endpoints wrap the response in an array
+    // ([{ generated_text, details: { tokens } }]) — normalize to the first
+    // item so those endpoints get real usage instead of the char estimate.
+    const responseBody = Array.isArray(body) ? body[0] : body;
+    if (!responseBody || typeof responseBody !== "object") {
+        return undefined;
+    }
+    const usageRecord = (responseBody.usage ?? responseBody.tokens);
+    if (usageRecord && typeof usageRecord === "object") {
+        const promptTokens = Number(usageRecord.prompt_tokens ?? usageRecord.input_tokens) || 0;
+        const completionTokens = Number(usageRecord.completion_tokens ?? usageRecord.output_tokens) || 0;
+        if (promptTokens > 0 || completionTokens > 0) {
+            return {
+                promptTokens,
+                completionTokens,
+                total: Number(usageRecord.total_tokens) || promptTokens + completionTokens,
+            };
+        }
+    }
+    const details = responseBody.details;
+    const tokens = details?.tokens;
+    if (tokens && typeof tokens === "object") {
+        const promptTokens = Number(tokens.input) || 0;
+        const completionTokens = Number(tokens.generated) || 0;
+        if (promptTokens > 0 || completionTokens > 0) {
+            return {
+                promptTokens,
+                completionTokens,
+                total: Number(tokens.total) || promptTokens + completionTokens,
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Estimate token usage from text content
  *

package/dist/lib/proxy/accountCooldown.js

@@ -2,15 +2,10 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { AsyncMutex } from "../utils/asyncMutex.js";
+import { ACCOUNT_COOLING_REASONS } from "./routingEvidence.js";
 import { writeJsonSnapshotAtomically } from "./snapshotPersistence.js";
 const COOLDOWN_FILE = "account-cooldowns.json";
-const VALID_REASONS = new Set([
-    "weekly",
-    "session",
-    "unified",
-    "transient",
-    "auth",
-]);
+const VALID_REASONS = new Set(ACCOUNT_COOLING_REASONS);
 let customCooldownFilePath = null;
 let cacheLoaded = false;
 let cacheLoadPromise = null;

package/dist/lib/proxy/proxyAnalysis.js

@@ -3,6 +3,7 @@ import { lstat, readdir, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { ACCOUNT_COOLING_REASONS, PROXY_ACCOUNT_TYPES, PROXY_ACCOUNT_ROUTING_MODES, PROXY_ACCOUNT_ROUTING_REASONS, PROXY_ACCOUNT_ROUTING_STRATEGIES, } from "./routingEvidence.js";
 const LIFECYCLE_FILE_PATTERN = /^proxy-lifecycle-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const ATTEMPT_FILE_PATTERN = /^proxy-attempts-\d{4}-\d{2}-\d{2}\.jsonl$/;
@@ -14,6 +15,11 @@ const LIFECYCLE_EVENTS = new Set([
     "response_first_chunk",
     "request_terminal",
 ]);
+const ROUTING_STRATEGIES = new Set(PROXY_ACCOUNT_ROUTING_STRATEGIES);
+const ROUTING_MODES = new Set(PROXY_ACCOUNT_ROUTING_MODES);
+const ROUTING_REASONS = new Set(PROXY_ACCOUNT_ROUTING_REASONS);
+const ROUTING_ACCOUNT_TYPES = new Set(PROXY_ACCOUNT_TYPES);
+const COOLING_REASONS = new Set(ACCOUNT_COOLING_REASONS);
 function isContainedPath(root, candidate) {
     const candidateRelative = relative(root, candidate);
     return (candidateRelative.length > 0 &&
@@ -45,6 +51,130 @@ function finiteNumber(value) {
 function stringValue(value) {
     return typeof value === "string" && value.length > 0 ? value : null;
 }
+function isNullableString(value) {
+    return value === null || (typeof value === "string" && value.length > 0);
+}
+function isNullableFiniteNumber(value) {
+    return value === null || finiteNumber(value) !== null;
+}
+function routingCandidateValue(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const candidate = value;
+    const requiredBooleanFields = [
+        "configuredPrimary",
+        "usable",
+        "saturated",
+        "quotaObserved",
+        "coolingActive",
+    ];
+    const requiredNullableNumberFields = [
+        "quotaLastUpdated",
+        "quotaAgeMs",
+        "coolingUntil",
+        "sessionUsed",
+        "sessionResetAt",
+        "sessionResetBucket",
+        "weeklyUsed",
+        "weeklyResetAt",
+    ];
+    const requiredNullableStringFields = [
+        "unifiedStatus",
+        "overageStatus",
+        "sessionStatus",
+        "weeklyStatus",
+    ];
+    if (!stringValue(candidate.account) ||
+        typeof candidate.accountType !== "string" ||
+        !ROUTING_ACCOUNT_TYPES.has(candidate.accountType) ||
+        !Number.isInteger(candidate.sourceIndex) ||
+        candidate.sourceIndex < 0 ||
+        !Number.isInteger(candidate.rank) ||
+        candidate.rank < 0 ||
+        requiredBooleanFields.some((field) => typeof candidate[field] !== "boolean") ||
+        requiredNullableNumberFields.some((field) => !isNullableFiniteNumber(candidate[field])) ||
+        requiredNullableStringFields.some((field) => !isNullableString(candidate[field])) ||
+        !(candidate.coolingReason === null ||
+            (typeof candidate.coolingReason === "string" &&
+                COOLING_REASONS.has(candidate.coolingReason)))) {
+        return null;
+    }
+    return {
+        account: candidate.account,
+        accountType: candidate.accountType,
+        sourceIndex: candidate.sourceIndex,
+        rank: candidate.rank,
+        configuredPrimary: candidate.configuredPrimary,
+        usable: candidate.usable,
+        saturated: candidate.saturated,
+        quotaObserved: candidate.quotaObserved,
+        quotaLastUpdated: candidate.quotaLastUpdated,
+        quotaAgeMs: candidate.quotaAgeMs,
+        coolingActive: candidate.coolingActive,
+        coolingReason: candidate.coolingReason,
+        coolingUntil: candidate.coolingUntil,
+        unifiedStatus: candidate.unifiedStatus,
+        overageStatus: candidate.overageStatus,
+        sessionStatus: candidate.sessionStatus,
+        sessionUsed: candidate.sessionUsed,
+        sessionResetAt: candidate.sessionResetAt,
+        sessionResetBucket: candidate.sessionResetBucket,
+        weeklyStatus: candidate.weeklyStatus,
+        weeklyUsed: candidate.weeklyUsed,
+        weeklyResetAt: candidate.weeklyResetAt,
+    };
+}
+function routingDecisionValue(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const decision = value;
+    const candidates = Array.isArray(decision.candidates)
+        ? decision.candidates.map(routingCandidateValue)
+        : [];
+    if (decision.schemaVersion !== 1 ||
+        !stringValue(decision.evaluatedAt) ||
+        !Number.isFinite(Date.parse(String(decision.evaluatedAt))) ||
+        typeof decision.strategy !== "string" ||
+        !ROUTING_STRATEGIES.has(decision.strategy) ||
+        typeof decision.mode !== "string" ||
+        !ROUTING_MODES.has(decision.mode) ||
+        typeof decision.selectionReason !== "string" ||
+        !ROUTING_REASONS.has(decision.selectionReason) ||
+        typeof decision.quotaRoutingEnabled !== "boolean" ||
+        typeof decision.quotaInputsUsed !== "boolean" ||
+        finiteNumber(decision.sessionSoftLimit) === null ||
+        decision.sessionSoftLimit <= 0 ||
+        decision.sessionSoftLimit > 1 ||
+        !Number.isInteger(decision.sessionResetToleranceMs) ||
+        decision.sessionResetToleranceMs <= 0 ||
+        !isNullableString(decision.configuredPrimaryAccount) ||
+        typeof decision.configuredPrimaryMatched !== "boolean" ||
+        !Number.isInteger(decision.rotationOffset) ||
+        decision.rotationOffset < 0 ||
+        !stringValue(decision.initialAccount) ||
+        candidates.length === 0 ||
+        candidates.some((candidate) => candidate === null)) {
+        return null;
+    }
+    return {
+        schemaVersion: 1,
+        evaluatedAt: decision.evaluatedAt,
+        strategy: decision.strategy,
+        mode: decision.mode,
+        selectionReason: decision.selectionReason,
+        quotaRoutingEnabled: decision.quotaRoutingEnabled,
+        quotaInputsUsed: decision.quotaInputsUsed,
+        sessionSoftLimit: decision.sessionSoftLimit,
+        sessionResetToleranceMs: decision.sessionResetToleranceMs,
+        configuredPrimaryAccount: decision.configuredPrimaryAccount,
+        configuredPrimaryMatched: decision.configuredPrimaryMatched,
+        rotationOffset: decision.rotationOffset,
+        initialAccount: decision.initialAccount,
+        candidates: candidates,
+    };
+}
 function percentile(sorted, fraction) {
     if (sorted.length === 0) {
         return null;
@@ -204,6 +334,47 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
         singleAttemptDelta,
     };
 }
+function summarizeRouting(finalRequests) {
+    const modes = {};
+    const selectionReasons = {};
+    const initialAccounts = {};
+    const records = [];
+    let finalAccountChanges = 0;
+    let finalOutsideCandidateSet = 0;
+    for (const [requestId, request] of finalRequests) {
+        const decision = request.routingDecision;
+        if (!decision) {
+            continue;
+        }
+        increment(modes, decision.mode);
+        increment(selectionReasons, decision.selectionReason);
+        increment(initialAccounts, decision.initialAccount);
+        const finalCandidate = decision.candidates.some((candidate) => candidate.account === request.account &&
+            candidate.accountType === request.accountType);
+        if (!finalCandidate) {
+            finalOutsideCandidateSet += 1;
+        }
+        else if (decision.initialAccount !== request.account) {
+            finalAccountChanges += 1;
+        }
+        records.push({
+            requestId,
+            timestamp: request.timestamp,
+            responseStatus: request.status,
+            finalAccount: request.account,
+            finalAccountType: request.accountType,
+            decision,
+        });
+    }
+    return {
+        modes,
+        selectionReasons,
+        initialAccounts,
+        finalAccountChanges,
+        finalOutsideCandidateSet,
+        records,
+    };
+}
 async function discoverLogFiles(logsDir) {
     const entries = await readdir(logsDir, { withFileTypes: true }).catch((error) => {
         throw new Error(`Unable to read proxy logs at ${logsDir}: ${error.message}`);
@@ -400,6 +571,9 @@ export async function analyzeProxyLogs(options) {
     }
     const finalRequests = new Map();
     const terminalStreamErrors = new Set();
+    let validRoutingDecisions = 0;
+    let invalidRoutingDecisions = 0;
+    let absentRoutingDecisions = 0;
     for (const filePath of requestFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("requests", record);
@@ -418,7 +592,21 @@ export async function analyzeProxyLogs(options) {
             if (status === null || !stringValue(record.method)) {
                 return;
             }
+            const hasRoutingDecision = Object.prototype.hasOwnProperty.call(record, "routingDecision");
+            const routingDecision = hasRoutingDecision
+                ? routingDecisionValue(record.routingDecision)
+                : null;
+            if (routingDecision) {
+                validRoutingDecisions += 1;
+            }
+            else if (hasRoutingDecision) {
+                invalidRoutingDecisions += 1;
+            }
+            else {
+                absentRoutingDecisions += 1;
+            }
             finalRequests.set(requestId, {
+                timestamp: new Date(timestamp).toISOString(),
                 status,
                 durationMs: finiteNumber(record.responseTimeMs),
                 account: stringValue(record.account) ?? "unknown",
@@ -428,6 +616,7 @@ export async function analyzeProxyLogs(options) {
                 cacheCreationTokens: finiteNumber(record.cacheCreationTokens),
                 errorType: stringValue(record.errorType),
                 errorCode: stringValue(record.errorCode),
+                routingDecision,
             });
         }, () => {
             malformedLines += 1;
@@ -498,6 +687,7 @@ export async function analyzeProxyLogs(options) {
     }
     const artifactsReferenced = artifactsPresent + artifactsMissing;
     const finalSummary = summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByRequest, accounts);
+    const routingSummary = summarizeRouting(finalRequests);
     return {
         generatedAt: new Date(nowMs).toISOString(),
         since: new Date(sinceMs).toISOString(),
@@ -514,6 +704,7 @@ export async function analyzeProxyLogs(options) {
             attempts: totalAttempts > 0,
             attemptLatency: attemptLatency.length > 0,
             cacheUsage: finalSummary.cache.requestsWithUsage > 0,
+            routingDecisions: routingSummary.records.length > 0,
         },
         dataQuality: {
             linesRead,
@@ -538,6 +729,11 @@ export async function analyzeProxyLogs(options) {
                 writeFailures,
                 truncatedCaptures,
             },
+            routingDecisions: {
+                valid: validRoutingDecisions,
+                invalid: invalidRoutingDecisions,
+                absent: absentRoutingDecisions,
+            },
         },
         lifecycle: {
             accepted: accepted.size,
@@ -572,6 +768,7 @@ export async function analyzeProxyLogs(options) {
             singleAttemptDelta: summarizeLatency(finalSummary.singleAttemptDelta),
         },
         cache: finalSummary.cache,
+        routing: routingSummary,
         accounts: [...accounts.values()].sort((left, right) => right.attempts - left.attempts),
     };
 }

package/dist/lib/proxy/requestLogger.js

@@ -236,6 +236,17 @@ function emitOtlpLogRecord(entry) {
                 // Account info
                 "account.name": entry.account,
                 "account.type": entry.accountType,
+                // Compact routing summary. Full candidate evidence stays in JSONL.
+                ...(entry.routingDecision && {
+                    "routing.mode": entry.routingDecision.mode,
+                    "routing.strategy": entry.routingDecision.strategy,
+                    "routing.selection_reason": entry.routingDecision.selectionReason,
+                    "routing.initial_account": entry.routingDecision.initialAccount,
+                    "routing.candidate_count": entry.routingDecision.candidates.length,
+                    "routing.final_account_changed": entry.routingDecision.initialAccount !== entry.account &&
+                        entry.routingDecision.candidates.some((candidate) => candidate.account === entry.account &&
+                            candidate.accountType === entry.accountType),
+                }),
                 // Token usage (when available)
                 ...(entry.inputTokens !== undefined && {
                     "ai.input_tokens": entry.inputTokens,

package/dist/lib/proxy/routingEvidence.d.ts

@@ -0,0 +1,6 @@
+/** Schema-v1 routing evidence values shared by emitters and offline readers. */
+export declare const PROXY_ACCOUNT_ROUTING_STRATEGIES: readonly ["round-robin", "fill-first"];
+export declare const PROXY_ACCOUNT_ROUTING_MODES: readonly ["quota", "primary", "round_robin", "single_account"];
+export declare const PROXY_ACCOUNT_ROUTING_REASONS: readonly ["single_account", "round_robin", "configured_primary", "insertion_order", "availability", "cooldown_recovery", "quota_probe", "session_headroom", "session_reset", "weekly_reset", "weekly_utilization"];
+export declare const PROXY_ACCOUNT_TYPES: readonly ["oauth", "api_key"];
+export declare const ACCOUNT_COOLING_REASONS: readonly ["weekly", "session", "unified", "transient", "auth"];

package/dist/lib/proxy/routingEvidence.js

@@ -0,0 +1,33 @@
+/** Schema-v1 routing evidence values shared by emitters and offline readers. */
+export const PROXY_ACCOUNT_ROUTING_STRATEGIES = [
+    "round-robin",
+    "fill-first",
+];
+export const PROXY_ACCOUNT_ROUTING_MODES = [
+    "quota",
+    "primary",
+    "round_robin",
+    "single_account",
+];
+export const PROXY_ACCOUNT_ROUTING_REASONS = [
+    "single_account",
+    "round_robin",
+    "configured_primary",
+    "insertion_order",
+    "availability",
+    "cooldown_recovery",
+    "quota_probe",
+    "session_headroom",
+    "session_reset",
+    "weekly_reset",
+    "weekly_utilization",
+];
+export const PROXY_ACCOUNT_TYPES = ["oauth", "api_key"];
+export const ACCOUNT_COOLING_REASONS = [
+    "weekly",
+    "session",
+    "unified",
+    "transient",
+    "auth",
+];
+//# sourceMappingURL=routingEvidence.js.map

package/dist/lib/server/routes/claudeProxyRoutes.d.ts

@@ -12,7 +12,7 @@
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
-import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
 /** Resolve the configured primary's stable key to its current index in the
  *  request's enabledAccounts list. Returns 0 (insertion-order fallback) when
  *  no key is configured or the key cannot be matched (account disabled/
@@ -279,6 +279,7 @@ export declare const __testHooks: {
     getStreamFailureDetails: typeof getStreamFailureDetails;
     trackUpstreamReadableStream: typeof trackUpstreamReadableStream;
     orderAccountsByQuota: typeof orderAccountsByQuota;
+    buildQuotaRoutingDecision: (accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number) => ProxyAccountRoutingDecision;
     resetEpochToMs: typeof resetEpochToMs;
     seedRuntimeQuotasFromDisk: typeof seedRuntimeQuotasFromDisk;
     reconcileEligibleAccountRuntimeState: typeof reconcileEligibleAccountRuntimeState;