@juspay/neurolink 11.15.2 → 11.15.4

package/dist/core/loopEngine.js

@@ -107,8 +107,11 @@ export function runAgenticLoop(adapter, initialConversation, options) {
                         catch (err) {
                             throw hasEmitted ? new PostEmissionStepError(err) : err;
                         }
-                    }, undefined, // no OTel span threaded through the engine today; adapters instrument their own steps if they need span-level detail
-                    `${adapter.providerLabel}.step`);
+                    }, 
+                    // The caller's span, when it passes one. withProviderRetry writes
+                    // gen_ai.provider.total_attempts here, so a loop that threaded a
+                    // span before it moved onto this engine keeps emitting it.
+                    options.span, `${adapter.providerLabel}.step`);
                 }
                 catch (err) {
                     throw err instanceof PostEmissionStepError ? err.cause : err;

package/dist/providers/anthropic/client.js

@@ -1697,9 +1697,17 @@ export class AnthropicProvider extends BaseProvider {
                     },
                 };
             }
+            // The active span goes with it. Before this loop moved onto the shared
+            // engine it called
+            //   withProviderRetry(fn, trace.getActiveSpan() ?? undefined, label)
+            // and that span is where gen_ai.provider.total_attempts is recorded.
+            // The engine passed `undefined` in its place, so the attribute silently
+            // stopped being emitted for every native Anthropic turn.
+            const activeSpan = trace.getActiveSpan();
             const { stream, resultPromise } = runAgenticLoop(adapter, payload.messages.slice(), {
                 tools: engineTools,
                 ...(abortSignal ? { abortSignal } : {}),
+                ...(activeSpan ? { span: activeSpan } : {}),
             });
             // Structured turns buffer their text rather than streaming it: a caller
             // that passed a schema needs parseable JSON, and deltas emitted before

package/dist/server/routes/claudeProxyRoutes.js

@@ -6056,6 +6056,15 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                 handler: async (ctx) => {
                     const routing = runtimeConfigProvider?.();
                     const effectiveAllowlist = routing?.accountAllowlist ?? accountAllowlist;
+                    // Hot-reloaded routing wins over the value baked in at construction,
+                    // the same precedence the request path uses.
+                    const effectivePrimaryKey = routing?.primaryAccountKey ?? primaryAccountKey;
+                    // Rows carry a bare label in one loop and a full pool key in the
+                    // other; anthropicAccountKeysEqual normalises both, so neither can
+                    // miss the match on prefix alone.
+                    const isPrimaryAccount = (keyOrLabel) => !!effectivePrimaryKey &&
+                        !!keyOrLabel &&
+                        anthropicAccountKeysEqual(keyOrLabel, effectivePrimaryKey);
                     // Cached by default. This endpoint is built to be polled, and a live
                     // refresh spends the user's own OAuth credentials against Anthropic's
                     // usage API — one dashboard on a short interval would hammer it.
@@ -6160,7 +6169,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                             cooling,
                             allowed: null,
                             expired: null,
-                            isPrimary: false,
+                            isPrimary: isPrimaryAccount(result.key ?? label),
                             requests: stat ? stat.successCount + stat.errorCount : null,
                             errors: stat?.errorCount ?? null,
                             rateLimits: stat?.rateLimitCount ?? null,
@@ -6204,7 +6213,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                             cooling: false,
                             allowed: null,
                             expired: null,
-                            isPrimary: false,
+                            isPrimary: isPrimaryAccount(entry.label),
                             requests: entry.successCount + entry.errorCount,
                             errors: entry.errorCount,
                             rateLimits: entry.rateLimitCount,

package/dist/types/loopEngine.d.ts

@@ -1,4 +1,5 @@
 import type Anthropic from "@anthropic-ai/sdk";
+import type { Span } from "@opentelemetry/api";
 import type { Tool } from "./tools.js";
 import type { CollectedChunkResult, NativeFunctionCall, NativeToolDeclarationsResult } from "./providers.js";
 /**
@@ -292,6 +293,19 @@ export type AgenticLoopOptions = {
         execute?: (args: Record<string, unknown>, opts: unknown) => Promise<unknown>;
     }>;
     abortSignal?: AbortSignal;
+    /**
+     * Span the per-step provider retry annotates, via
+     * `withProviderRetry(..., span, ...)` — it records
+     * `gen_ai.provider.total_attempts` on every completed step, retried or not.
+     *
+     * Caller-supplied rather than read from the ambient context inside the
+     * engine. Reading it here would hand the attribute to every provider on the
+     * engine, including ones whose hand-rolled loops never emitted it, and a
+     * refactor that silently ADDS observable behaviour is the same defect as one
+     * that silently drops it. Today only the direct Anthropic loops set this,
+     * because only they threaded a span before moving onto the engine.
+     */
+    span?: Span;
 };
 export type AgenticLoopResult<TConversation> = {
     text: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.15.2",
+  "version": "11.15.4",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {