@juspay/neurolink 11.16.3 → 11.17.1

package/dist/core/loopEngine.js

@@ -28,6 +28,8 @@ function sumUsage(a, b) {
         cacheReadTokens: (a.cacheReadTokens ?? 0) + (b.cacheReadTokens ?? 0) || undefined,
         cacheWriteTokens: (a.cacheWriteTokens ?? 0) + (b.cacheWriteTokens ?? 0) || undefined,
         reasoningTokens: (a.reasoningTokens ?? 0) + (b.reasoningTokens ?? 0) || undefined,
+        cacheWrite5mTokens: (a.cacheWrite5mTokens ?? 0) + (b.cacheWrite5mTokens ?? 0) || undefined,
+        cacheWrite1hTokens: (a.cacheWrite1hTokens ?? 0) + (b.cacheWrite1hTokens ?? 0) || undefined,
     };
 }
 /**

package/dist/providers/anthropic/client.js

@@ -1567,7 +1567,7 @@ export class AnthropicProvider extends BaseProvider {
                         content: [{ type: "text", text: ANTHROPIC_ELISION_NOTE }],
                     });
                 }
-                return rebuilt;
+                return { conversation: rebuilt };
             };
             const buildParams = (conversation) => {
                 // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
@@ -1599,7 +1599,10 @@ export class AnthropicProvider extends BaseProvider {
                     model: modelId,
                     messages: cachedConversation,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
-                    stream: true,
+                    // No `stream: true` here: executeStep sets it when it calls
+                    // messages.create, so declaring it made the caller assert a literal
+                    // the adapter immediately overwrites — and forced this whole params
+                    // object into the streaming variant for a field it does not own.
                     ...(payload.system ? { system: payload.system } : {}),
                     ...(streamSamplingParams.temperature !== undefined
                         ? { temperature: streamSamplingParams.temperature }

package/dist/providers/anthropic/loopAdapter.d.ts

@@ -23,4 +23,4 @@
  */
 import type Anthropic from "@anthropic-ai/sdk";
 import type { AgenticLoopAdapter, AnthropicLoopAdapterConfig } from "../../types/index.js";
-export declare function createAnthropicLoopAdapter(config: AnthropicLoopAdapterConfig): AgenticLoopAdapter<Anthropic.Messages.MessageParam[], Anthropic.Messages.ContentBlockParam[]>;
+export declare function createAnthropicLoopAdapter<TMessage = Anthropic.Messages.MessageParam>(config: AnthropicLoopAdapterConfig<TMessage>): AgenticLoopAdapter<TMessage[], Anthropic.Messages.ContentBlockParam[]>;

package/dist/providers/anthropic/loopAdapter.js

@@ -52,10 +52,12 @@ export function createAnthropicLoopAdapter(config) {
          */
         ...(config.planReclaim
             ? {
-                planReclaim: (conversation, step) => {
-                    const reclaimed = config.planReclaim?.(conversation, step);
-                    return reclaimed ? { conversation: reclaimed } : undefined;
-                },
+                // Passed straight through, INCLUDING `{ stop: true }`. Wrapping the
+                // return as `{ conversation }` swallowed the stop signal, so a guard
+                // that could not reclaim enough room had no way to end the turn and
+                // the loop kept sending oversized requests until the provider
+                // rejected one.
+                planReclaim: (conversation, step) => config.planReclaim?.(conversation, step),
             }
             : {}),
         resolveToolOnMiss: (name) => {
@@ -97,6 +99,12 @@ export function createAnthropicLoopAdapter(config) {
             let outputTokens = 0;
             let cacheReadTokens = 0;
             let cacheWriteTokens = 0;
+            // Reported alongside the total, not derivable from it: the two TTL
+            // tiers are priced differently, so a caller that reports them (the
+            // Claude-on-Vertex turn span does) cannot reconstruct the split from
+            // cacheWriteTokens alone.
+            let cacheWrite5mTokens = 0;
+            let cacheWrite1hTokens = 0;
             let stepOutputTokens = 0;
             for await (const rawEvent of events) {
                 if (signal.aborted) {
@@ -118,6 +126,19 @@ export function createAnthropicLoopAdapter(config) {
                     // accounting.
                     cacheReadTokens += usage?.cache_read_input_tokens ?? 0;
                     cacheWriteTokens += usage?.cache_creation_input_tokens ?? 0;
+                    // BEST EFFORT, and the limit is worth stating. The nested TTL
+                    // breakdown exists only on `Usage` (this event); `MessageDeltaUsage`
+                    // carries the cache TOTALS but not the split, so message_start is
+                    // the only place in the raw event stream it can come from. The
+                    // pre-migration loop read it off `stream.finalMessage()` — the SDK's
+                    // ACCUMULATED message — so if the API leaves `cache_creation` null
+                    // here and fills it only on the assembled message, these two stay
+                    // zero and the totals above remain correct regardless.
+                    // Reported as undefined rather than a false zero when absent.
+                    cacheWrite5mTokens +=
+                        usage?.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+                    cacheWrite1hTokens +=
+                        usage?.cache_creation?.ephemeral_1h_input_tokens ?? 0;
                     // The guard calibrates from the FULL prompt size, not input_tokens
                     // alone: on a cache hit the uncached remainder is tiny and using it
                     // would let the guard drift far under the real cost.
@@ -297,6 +318,11 @@ export function createAnthropicLoopAdapter(config) {
                     outputTokens,
                     cacheReadTokens,
                     cacheWriteTokens,
+                    // Omitted entirely when the stream never reported a split, so a
+                    // consumer can tell "no TTL breakdown available" from "zero tokens
+                    // in that tier".
+                    ...(cacheWrite5mTokens ? { cacheWrite5mTokens } : {}),
+                    ...(cacheWrite1hTokens ? { cacheWrite1hTokens } : {}),
                 },
                 rawStopReason,
                 raw: blocks,
@@ -305,7 +331,13 @@ export function createAnthropicLoopAdapter(config) {
         buildToolResultMessages(conversation, stepResult, toolResults) {
             const assistantMessage = {
                 role: "assistant",
-                content: stepResult.raw,
+                // server_tool_use blocks are stripped before the turn is replayed:
+                // the API emits them on the way out but REJECTS them on the way back
+                // in, so echoing one fails the next request outright rather than
+                // degrading. Both Claude-on-Vertex loops filtered these by hand; doing
+                // it here means a caller cannot forget to. A provider that never emits
+                // them sees no change.
+                content: stepResult.raw.filter((block) => block.type !== "server_tool_use"),
             };
             const resultMessage = {
                 role: "user",
@@ -318,7 +350,17 @@ export function createAnthropicLoopAdapter(config) {
                     ...(result.error ? { is_error: true } : {}),
                 })),
             };
-            return [...conversation, assistantMessage, resultMessage];
+            // The two messages are built in the SDK's own shape and handed back as
+            // TMessage. Every Anthropic-compatible message type accepts a plain
+            // assistant turn and a tool_result user turn — that is the wire format,
+            // not a dialect — and a caller's narrower type differs only in fields
+            // neither of these sets. One assertion, at the single point where the
+            // adapter authors content rather than passing it through.
+            return [
+                ...conversation,
+                assistantMessage,
+                resultMessage,
+            ];
         },
         mapFinishReason: mapAnthropicFinishReason,
     };

package/dist/providers/googleNativeGemini3/utils.js

@@ -473,7 +473,11 @@ export function buildNativeToolDeclarations(tools, reservedNames) {
  */
 export function guardToolExecutor(name, execute, guards) {
     return async (args, opts) => {
-        const call = () => Promise.resolve(execute(args, opts));
+        const invoke = () => Promise.resolve(execute(args, opts));
+        // The span wraps the CALL, not the guard: a timeout or an abort is a fact
+        // about this tool invocation and belongs inside its observation.
+        const wrapInSpan = guards.withToolSpan;
+        const call = wrapInSpan ? () => wrapInSpan(name, invoke) : invoke;
         guards.onProgress?.();
         try {
             const raced = guards.abortSignal