@juspay/neurolink 12.59.0 → 13.0.1

package/dist/server/routes/agentRoutes.js

@@ -74,7 +74,7 @@ export function createAgentRoutes(basePath = "/api") {
                     }
                     const request = validation.data;
                     return withSpan({
-                        name: "neurolink.http.execute",
+                        name: "http.execute",
                         tracer: tracers.http,
                         attributes: {
                             "http.route": "/api/agent/execute",
@@ -165,7 +165,7 @@ export function createAgentRoutes(basePath = "/api") {
                     // Wrap stream with a span that stays open for the full consumption
                     // lifetime, not just the generator creation.
                     async function* redactedStream() {
-                        const streamSpan = tracers.http.startSpan("neurolink.http.stream", {
+                        const streamSpan = tracers.http.startSpan("http.stream", {
                             attributes: {
                                 "http.route": "/api/agent/stream",
                                 "ai.provider": request.provider || "default",
@@ -221,7 +221,7 @@ export function createAgentRoutes(basePath = "/api") {
                     try {
                         const providerName = request.provider || "openai";
                         return await withSpan({
-                            name: "neurolink.http.embed",
+                            name: "http.embed",
                             tracer: tracers.http,
                             attributes: {
                                 "http.route": "/api/agent/embed",
@@ -260,7 +260,7 @@ export function createAgentRoutes(basePath = "/api") {
                     try {
                         const providerName = request.provider || "openai";
                         return await withSpan({
-                            name: "neurolink.http.embedMany",
+                            name: "http.embedMany",
                             tracer: tracers.http,
                             attributes: {
                                 "http.route": "/api/agent/embed-many",

package/dist/server/routes/claudeProxyRoutes.js

@@ -2306,7 +2306,10 @@ function extractResponseInfo(responseJson) {
  * streaming path records the same gen_ai.response.* attributes as non-streaming.
  */
 function responseInfoFromStream(data) {
-    const info = {};
+    const info = {
+        output: data.contentBlocks,
+        firstOutputAt: data.firstUsefulOutputAt,
+    };
     if (data.model) {
         info.responseModel = data.model;
     }
@@ -2736,6 +2739,64 @@ function trackUpstreamReadableStream(source) {
     });
     return { stream, outcome: tracker.outcome };
 }
+function settleStreamSpend(account, model, usage) {
+    settleBorrowedRequest(account.key, model, usage);
+    recordLeasedAccountSpend(account.label, model, usage);
+}
+function logStreamFinal(logFinalRequest, failure, accountLabel, accountType, usage) {
+    logFinalRequest(failure?.status ?? 200, accountLabel, accountType, failure?.errorType, failure?.message, usage);
+}
+function streamUsageFields(usage) {
+    return {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheCreationTokens: usage.cacheCreationInputTokens,
+        ...oneHourCacheWriteFields(usage.cacheCreation1hInputTokens),
+        cacheReadTokens: usage.cacheReadInputTokens,
+    };
+}
+function setRateLimitUsage(tracer, response, usage) {
+    const rateLimit5h = parseFloat(response.headers.get("anthropic-ratelimit-unified-5h-utilization") ?? "");
+    const rateLimit7d = parseFloat(response.headers.get("anthropic-ratelimit-unified-7d-utilization") ?? "");
+    if (isNaN(rateLimit5h) && isNaN(rateLimit7d)) {
+        return;
+    }
+    const usageUpdate = streamUsageFields(usage);
+    if (!isNaN(rateLimit5h)) {
+        usageUpdate.rateLimitAfter5h = rateLimit5h;
+    }
+    if (!isNaN(rateLimit7d)) {
+        usageUpdate.rateLimitAfter7d = rateLimit7d;
+    }
+    tracer.setUsage(usageUpdate);
+}
+function logStreamBodies(args) {
+    const { logProxyBody, headers, data, clientBody, requestStartTime } = args;
+    const common = {
+        headers,
+        contentType: headers["content-type"] ?? "text/event-stream",
+        account: args.account,
+        accountType: args.accountType,
+        attempt: args.attempt,
+        responseStatus: args.responseStatus,
+    };
+    logProxyBody({
+        ...common,
+        phase: "upstream_response",
+        body: data.rawText ?? "",
+        sourceTruncated: data.rawTextTruncated,
+        bodySize: data.totalBytesReceived,
+        durationMs: Date.now() - requestStartTime,
+    });
+    logProxyBody({
+        ...common,
+        phase: "client_response",
+        body: clientBody.text,
+        sourceTruncated: clientBody.truncated,
+        bodySize: clientBody.totalBytes,
+        durationMs: Date.now() - requestStartTime,
+    });
+}
 async function handleClaudePassthroughStreamResponse(args) {
     const { ctx, bodyStr, response, tracer, requestStartTime, upstreamSpan, upstreamResponseHeaders, logProxyBody, logFinalRequest, } = args;
     const responseHeaders = { ...upstreamResponseHeaders };
@@ -2779,73 +2840,28 @@ async function handleClaudePassthroughStreamResponse(args) {
                 const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
                 observeClaudeStreamOutput(ctx.metadata, data);
                 const failure = getStreamFailureDetails(terminalOutcome);
-                capturedTracer.setUsage({
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                });
+                capturedTracer.setUsage(streamUsageFields(data.usage));
                 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 = {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                };
-                if (!isNaN(rateLimit5h)) {
-                    usageUpdate.rateLimitAfter5h = rateLimit5h;
-                }
-                if (!isNaN(rateLimit7d)) {
-                    usageUpdate.rateLimitAfter7d = rateLimit7d;
-                }
-                if (!isNaN(rateLimit5h) || !isNaN(rateLimit7d)) {
-                    capturedTracer.setUsage(usageUpdate);
-                }
+                setRateLimitUsage(capturedTracer, capturedResponse, data.usage);
                 capturedTracer.logUpstreamResponseBody(data.rawText ?? "");
-                capturedTracer.recordMetrics();
                 capturedTracer.recordBodySizes(capturedRequestBytes, data.totalBytesReceived);
                 capturedUpstreamSpan?.end();
                 if (failure) {
                     capturedTracer.setError(failure.errorType, failure.message);
                 }
                 capturedTracer.end(failure?.status ?? response.status, Date.now() - requestStartTime);
-                finalizeStream(failure?.status ?? response.status, failure?.errorType, failure?.message, {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                });
-                logProxyBody({
-                    phase: "upstream_response",
-                    headers: responseHeaders,
-                    body: data.rawText ?? "",
-                    sourceTruncated: data.rawTextTruncated,
-                    bodySize: data.totalBytesReceived,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
-                    account: "passthrough",
-                    accountType: "passthrough",
-                    attempt: 1,
-                    responseStatus: 200,
-                    durationMs: Date.now() - requestStartTime,
-                });
-                logProxyBody({
-                    phase: "client_response",
+                finalizeStream(failure?.status ?? response.status, failure?.errorType, failure?.message, streamUsageFields(data.usage));
+                logStreamBodies({
+                    logProxyBody,
                     headers: responseHeaders,
-                    body: clientBody.text,
-                    sourceTruncated: clientBody.truncated,
-                    bodySize: clientBody.totalBytes,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
+                    data,
+                    clientBody,
                     account: "passthrough",
                     accountType: "passthrough",
                     attempt: 1,
                     responseStatus: 200,
-                    durationMs: Date.now() - requestStartTime,
+                    requestStartTime,
                 });
             })
                 .catch((error) => {
@@ -2886,38 +2902,17 @@ async function handleClaudePassthroughStreamResponse(args) {
                 const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
                 observeClaudeStreamOutput(ctx.metadata, data);
                 const failure = getStreamFailureDetails(terminalOutcome);
-                finalizeStream(failure?.status ?? response.status, failure?.errorType, failure?.message, {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                });
-                logProxyBody({
-                    phase: "upstream_response",
-                    headers: responseHeaders,
-                    body: data.rawText ?? "",
-                    sourceTruncated: data.rawTextTruncated,
-                    bodySize: data.totalBytesReceived,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
-                    account: "passthrough",
-                    accountType: "passthrough",
-                    attempt: 1,
-                    responseStatus: response.status,
-                    durationMs: Date.now() - requestStartTime,
-                });
-                logProxyBody({
-                    phase: "client_response",
+                finalizeStream(failure?.status ?? response.status, failure?.errorType, failure?.message, streamUsageFields(data.usage));
+                logStreamBodies({
+                    logProxyBody,
                     headers: responseHeaders,
-                    body: clientBody.text,
-                    sourceTruncated: clientBody.truncated,
-                    bodySize: clientBody.totalBytes,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
+                    data,
+                    clientBody,
                     account: "passthrough",
                     accountType: "passthrough",
                     attempt: 1,
                     responseStatus: response.status,
-                    durationMs: Date.now() - requestStartTime,
+                    requestStartTime,
                 });
             })
                 .catch((error) => {
@@ -3012,7 +3007,6 @@ async function handleClaudePassthroughJsonResponse(args) {
             }
         }
         tracer.setResponseInfo(extractResponseInfo(responseJson));
-        tracer.recordMetrics();
         const responseJsonStr = JSON.stringify(responseJson);
         tracer.recordBodySizes(bodyStr.length, responseJsonStr.length);
         upstreamSpan?.end();
@@ -5251,99 +5245,38 @@ function attachAnthropicSuccessStreamTelemetry(args) {
             const capturedResponse = response;
             const capturedRequestBytes = finalBodyStr.length;
             const capturedAccountLabel = account.label;
-            const capturedAccountKey = account.key;
             telemetryDone = Promise.all([telemetry, clientCapture, streamOutcome])
                 .then(([data, clientBody, rawOutcome]) => {
                 const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
                 observeClaudeStreamOutput(ctx.metadata, data);
                 recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account, logAttempt);
-                capturedTracer.setUsage({
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                });
+                const usage = streamUsageFields(data.usage);
+                capturedTracer.setUsage(usage);
                 // Bill the borrowing grant from the same totals. A stream's usage is
                 // only final at message_delta, which is exactly here.
-                settleBorrowedRequest(capturedAccountKey, data.model, {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                });
-                recordLeasedAccountSpend(capturedAccountLabel, data.model, {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                });
+                settleStreamSpend(account, data.model, usage);
                 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 = {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                };
-                if (!isNaN(rateLimit5h)) {
-                    usageUpdate.rateLimitAfter5h = rateLimit5h;
-                }
-                if (!isNaN(rateLimit7d)) {
-                    usageUpdate.rateLimitAfter7d = rateLimit7d;
-                }
-                if (!isNaN(rateLimit5h) || !isNaN(rateLimit7d)) {
-                    capturedTracer.setUsage(usageUpdate);
-                }
+                setRateLimitUsage(capturedTracer, capturedResponse, data.usage);
                 capturedTracer.logUpstreamResponseBody(data.rawText ?? "");
-                capturedTracer.recordMetrics();
                 capturedTracer.recordBodySizes(capturedRequestBytes, data.totalBytesReceived);
                 capturedUpstreamSpan?.end();
                 const failure = getStreamFailureDetails(terminalOutcome);
-                const usage = {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                };
                 if (failure) {
                     capturedTracer.setError(failure.errorType, failure.message);
-                    capturedTracer.end(failure.status, Date.now() - requestStartTime);
-                    logFinalRequest(failure.status, capturedAccountLabel, account.type, failure.errorType, failure.message, usage);
-                }
-                else {
-                    capturedTracer.end(200, Date.now() - requestStartTime);
-                    logFinalRequest(200, capturedAccountLabel, account.type, undefined, undefined, usage);
                 }
-                logProxyBody({
-                    phase: "upstream_response",
-                    headers: responseHeaders,
-                    body: data.rawText ?? "",
-                    sourceTruncated: data.rawTextTruncated,
-                    bodySize: data.totalBytesReceived,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
-                    account: capturedAccountLabel,
-                    accountType: account.type,
-                    attempt: attemptNumber,
-                    responseStatus: 200,
-                    durationMs: Date.now() - requestStartTime,
-                });
-                logProxyBody({
-                    phase: "client_response",
+                capturedTracer.end(failure?.status ?? 200, Date.now() - requestStartTime);
+                logStreamFinal(logFinalRequest, failure, capturedAccountLabel, account.type, usage);
+                logStreamBodies({
+                    logProxyBody,
                     headers: responseHeaders,
-                    body: clientBody.text,
-                    sourceTruncated: clientBody.truncated,
-                    bodySize: clientBody.totalBytes,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
+                    data,
+                    clientBody,
                     account: capturedAccountLabel,
                     accountType: account.type,
                     attempt: attemptNumber,
                     responseStatus: 200,
-                    durationMs: Date.now() - requestStartTime,
+                    requestStartTime,
                 });
             })
                 .catch((error) => {
@@ -5382,7 +5315,6 @@ function attachAnthropicSuccessStreamTelemetry(args) {
             });
             streamSource = streamSource.pipeThrough(noTracerInterceptor);
             const capturedAccountLabel = account.label;
-            const capturedAccountKey = account.key;
             telemetryDone = Promise.all([
                 noTracerTelemetry,
                 clientCapture,
@@ -5393,48 +5325,21 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                 observeClaudeStreamOutput(ctx.metadata, data);
                 recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account, logAttempt);
                 const failure = getStreamFailureDetails(terminalOutcome);
-                const usage = {
-                    inputTokens: data.usage.inputTokens,
-                    outputTokens: data.usage.outputTokens,
-                    cacheCreationTokens: data.usage.cacheCreationInputTokens,
-                    ...oneHourCacheWriteFields(data.usage.cacheCreation1hInputTokens),
-                    cacheReadTokens: data.usage.cacheReadInputTokens,
-                };
+                const usage = streamUsageFields(data.usage);
                 // Settled on the untraced path too: whether telemetry is exported has
                 // nothing to do with whether a borrower should be charged.
-                settleBorrowedRequest(capturedAccountKey, data.model, usage);
-                recordLeasedAccountSpend(capturedAccountLabel, data.model, usage);
-                if (failure) {
-                    logFinalRequest(failure.status, capturedAccountLabel, account.type, failure.errorType, failure.message, usage);
-                }
-                else {
-                    logFinalRequest(200, capturedAccountLabel, account.type, undefined, undefined, usage);
-                }
-                logProxyBody({
-                    phase: "upstream_response",
-                    headers: responseHeaders,
-                    body: data.rawText ?? "",
-                    sourceTruncated: data.rawTextTruncated,
-                    bodySize: data.totalBytesReceived,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
-                    account: capturedAccountLabel,
-                    accountType: account.type,
-                    attempt: attemptNumber,
-                    responseStatus: 200,
-                    durationMs: Date.now() - requestStartTime,
-                });
-                logProxyBody({
-                    phase: "client_response",
+                settleStreamSpend(account, data.model, usage);
+                logStreamFinal(logFinalRequest, failure, capturedAccountLabel, account.type, usage);
+                logStreamBodies({
+                    logProxyBody,
                     headers: responseHeaders,
-                    body: clientBody.text,
-                    sourceTruncated: clientBody.truncated,
-                    bodySize: clientBody.totalBytes,
-                    contentType: responseHeaders["content-type"] ?? "text/event-stream",
+                    data,
+                    clientBody,
                     account: capturedAccountLabel,
                     accountType: account.type,
                     attempt: attemptNumber,
                     responseStatus: 200,
-                    durationMs: Date.now() - requestStartTime,
+                    requestStartTime,
                 });
             })
                 .catch((error) => {
@@ -5569,7 +5474,6 @@ async function handleAnthropicJsonSuccessResponse(args) {
             }
         }
         tracer.setResponseInfo(extractResponseInfo(responseJson));
-        tracer.recordMetrics();
         const responseJsonStr = JSON.stringify(responseJson);
         tracer.recordBodySizes(finalBodyStr.length, responseJsonStr.length);
         upstreamSpan?.end();
@@ -5672,7 +5576,6 @@ async function handleAnthropicSuccessfulNonStreamRetryResponse(args) {
             });
         }
         tracer.setResponseInfo(extractResponseInfo(retryJson));
-        tracer.recordMetrics();
         const retryJsonStr = JSON.stringify(retryJson);
         tracer.recordBodySizes(finalBodyStr.length, retryJsonStr.length);
         upstreamSpan?.end();
@@ -8518,7 +8421,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                         ? runtimeConfigProvider().modelRouter
                         : modelRouter;
                     return withSpan({
-                        name: "neurolink.http.claudeProxy.listModels",
+                        name: "http.claudeProxy.listModels",
                         tracer: tracers.http,
                         attributes: { "http.route": `${basePath}/v1/models` },
                     }, async () => buildAnthropicModelsListResponse(requestModelRouter));
@@ -8533,7 +8436,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                 method: "POST",
                 path: `${basePath}/v1/messages/count_tokens`,
                 handler: async (ctx) => withSpan({
-                    name: "neurolink.http.claudeProxy.countTokens",
+                    name: "http.claudeProxy.countTokens",
                     tracer: tracers.http,
                     attributes: {
                         "http.route": `${basePath}/v1/messages/count_tokens`,
@@ -8552,7 +8455,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                         .join(" ");
                     const inputTokens = Math.ceil(text.length / 4);
                     span.setAttribute("ai.model", body.model);
-                    span.setAttribute("gen_ai.usage.input_tokens", inputTokens);
+                    span.setAttribute("ai.tokens.input", inputTokens);
                     return { input_tokens: inputTokens };
                 }),
                 description: "Count tokens for a messages request",
@@ -8587,7 +8490,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                     const snapshotOnly = ctx.query?.snapshot === "true" || ctx.query?.snapshot === "1";
                     const accountFilter = ctx.query?.account;
                     return withSpan({
-                        name: "neurolink.http.claudeProxy.limits",
+                        name: "http.claudeProxy.limits",
                         tracer: tracers.http,
                         attributes: { "http.route": `${basePath}/limits` },
                     }, async () => {