@juspay/neurolink 12.14.15 → 12.14.17

package/dist/core/baseProvider.js

@@ -31,7 +31,7 @@ import { attachStreamCancel, cancelStream, releaseIterator, } from "../utils/str
 import { TimeoutError as AsyncTimeoutError, withTimeoutFn, } from "../utils/async/withTimeout.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
-import { getKeyCount, getKeysAsString } from "../utils/transformationUtils.js";
+import { getKeyCount, getKeysAsString, transformToolExecutions, } from "../utils/transformationUtils.js";
 import { ToolExecutionRecorder } from "./toolExecutionRecorder.js";
 import { TTS_ERROR_CODES, TTSProcessor } from "../utils/ttsProcessor.js";
 import { executeVideoAnalysis, hasVideoFrames, } from "../utils/videoAnalysisProcessor.js";
@@ -48,6 +48,7 @@ import { Utilities } from "./modules/Utilities.js";
 import { generateOnceNative } from "../utils/nativeSingleShot.js";
 import { validateExecutionControl } from "../utils/parameterValidation.js";
 import { extractTokenUsage } from "../utils/tokenUtils.js";
+import { preserveLiveStreamAccessors } from "../utils/streamResultAccessors.js";
 /**
  * Read the consumer-facing lifecycle callbacks buried inside a request's
  * middleware blob. The parameter is `unknown` on purpose: request options
@@ -523,10 +524,14 @@ export class BaseProvider {
             cancelStream(activeStream);
             releaseIterator(activeIterator);
         });
-        return {
+        // A naked spread reads (and thereby snapshots) every enumerable getter
+        // on `result` — including a provider's lazily-populated `toolsUsed` /
+        // `toolExecutions` — before the consumer has pulled a single chunk.
+        // Re-applying the original accessor descriptors keeps those fields live.
+        return preserveLiveStreamAccessors(result, {
             ...result,
             stream: wrapped,
-        };
+        });
     }
     /**
      * The eager half of the retired-model stream fallback, for providers whose
@@ -688,7 +693,12 @@ export class BaseProvider {
             cancelStream(originalStream);
             releaseIterator(upstreamIterator);
         });
-        return { ...result, stream: wrappedStream };
+        // See the comment in withStreamModelFallback above: this spread must not
+        // be allowed to freeze a provider's lazy toolsUsed/toolExecutions getters.
+        return preserveLiveStreamAccessors(result, {
+            ...result,
+            stream: wrappedStream,
+        });
     }
     /**
      * Fire the consumer-supplied onError callback before throwing. Used in
@@ -891,7 +901,19 @@ export class BaseProvider {
                 }
                 : undefined;
             // Create a synthetic stream from the generate result that simulates progressive delivery
-            return {
+            //
+            // toolsUsed/toolExecutions: generate()'s result carries both once the
+            // tool round trip settles, but a plain field list (like every other
+            // field above) would silently drop them from the fake-streaming
+            // StreamResult. toolsUsed overlaps generate()'s and StreamResult's
+            // declared types exactly, so it is assigned directly; toolExecutions
+            // does not (GenerateResult carries ToolExecutionRecord[], StreamResult
+            // declares ToolExecutionSummary[] but every other live producer of this
+            // field actually returns transformToolExecutions()'s
+            // {name,input,output,duration} shape) — attached via defineProperty,
+            // the same bypass `createMCPStream()` uses, rather than a literal that
+            // would fail the structural check or need a banned double-cast.
+            return Object.defineProperty({
                 stream: this.createFakeStreamingOutput(result, options, onTTSComplete),
                 usage: result?.usage,
                 provider: result?.provider,
@@ -916,7 +938,13 @@ export class BaseProvider {
                 evaluation: result?.evaluation,
                 audio,
                 ttsMetadata,
-            };
+                toolsUsed: result?.toolsUsed,
+            }, "toolExecutions", {
+                value: transformToolExecutions(result?.toolExecutions),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
         }
         catch (error) {
             logger.error(`Fake streaming fallback failed for ${this.providerName}:`, error);

package/dist/models/manifests/vertex.js

@@ -11,8 +11,12 @@ export const vertexManifest = {
             aliases: [],
             contextWindow: 1048576,
             maxOutputTokens: 64000,
-            vision: false,
-            functionCalling: false,
+            // Measured against live Vertex, every served model in this project —
+            // gemini-2.5-flash / -pro / -flash-lite, claude-sonnet-4-6 and
+            // claude-sonnet-4-5@20250929 — accepted image and PDF input and
+            // returned tool calls. Declaring false here contradicted the wire.
+            vision: true,
+            functionCalling: true,
         },
     },
 };

package/dist/neurolink.js

@@ -82,6 +82,7 @@ import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "./utils/lifecy
 import { interleaveTTSStream } from "./utils/ttsStream.js";
 import { resolveLifecycleTimeoutMs } from "./utils/lifecycleTimeout.js";
 import { cloneOptionsForCallIsolation } from "./utils/cloneOptions.js";
+import { pickLiveStreamDescriptors, preserveLiveStreamAccessors, } from "./utils/streamResultAccessors.js";
 import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "./utils/json/coerce.js";
 // Factory processing imports
 import { createCleanStreamOptions, enhanceTextGenerationOptions, processFactoryOptions, processStreamingFactoryOptions, validateFactoryConfig, } from "./utils/factoryProcessing.js";
@@ -6873,10 +6874,17 @@ Current user's request: ${currentInput}`;
             // the inner loop. We only get here if the loop didn't return.
             throw new Error(`[NeuroLink.stream] iteration fallback exhausted ${maxAttempts} attempts`);
         })();
-        return {
+        // `result`'s toolsUsed/toolExecutions may be live getters (openai-compat
+        // providers back them with a getter over an array still being populated
+        // by a background loop) — a naked spread here would read them once, now,
+        // and freeze whatever they held at that instant. preserveLiveStreamAccessors
+        // re-applies the original getter descriptors onto the rebuilt object, the
+        // same fix already applied to withStreamModelFallback/
+        // wrapStreamWithLifecycleCallbacks in baseProvider.ts.
+        return preserveLiveStreamAccessors(result, {
             ...result,
             stream: wrappedStream,
-        };
+        });
     }
     async executeStreamRequest(options) {
         // Dynamic argument resolution — resolve any function-valued options before downstream use
@@ -7567,7 +7575,12 @@ Current user's request: ${currentInput}`;
                 factoryResult,
                 sessionId: enhancedOptions.context?.sessionId,
             });
-            const { stream: mcpStream, provider: providerName, usage: streamUsage, model: streamModel, finishReason: streamFinishReason, toolCalls: streamToolCalls, toolResults: streamToolResults, analytics: streamAnalytics, metadata: providerStreamMetadata, } = await this.createMCPStream(enhancedOptions);
+            // Kept whole (not just destructured) so its toolsUsed/toolExecutions
+            // descriptors can be re-applied onto the final StreamResult near the
+            // bottom of this method, without ever reading — and thereby freezing —
+            // a getter-based provider's value here.
+            const mcpStreamOutcome = await this.createMCPStream(enhancedOptions);
+            const { stream: mcpStream, provider: providerName, usage: streamUsage, model: streamModel, finishReason: streamFinishReason, toolCalls: streamToolCalls, toolResults: streamToolResults, analytics: streamAnalytics, metadata: providerStreamMetadata, } = mcpStreamOutcome;
             let streamedTTSResult;
             const { stream: incrementalStream, ttsMetadata: streamTtsMetadata } = await this.createIncrementalTTSStream({
                 stream: mcpStream,
@@ -7934,6 +7947,7 @@ Current user's request: ${currentInput}`;
                 error: metadata.error,
                 events: eventSequence,
                 providerMetadata: providerStreamMetadata,
+                toolTelemetrySource: mcpStreamOutcome,
             });
         }
         catch (error) {
@@ -8731,7 +8745,11 @@ Current user's request: ${currentInput}`;
                             throw streamConsumeErr;
                         }
                     })();
-                    return {
+                    // toolsUsed/toolExecutions are attached via defineProperties (not
+                    // listed as plain fields above) so a getter-based provider result
+                    // keeps resolving lazily through this boundary instead of being
+                    // read — and frozen — once, right here, before any chunk is drained.
+                    return Object.defineProperties({
                         stream: wrappedStream,
                         provider: poolStreamProviderName,
                         usage: poolStreamResult.usage,
@@ -8741,7 +8759,10 @@ Current user's request: ${currentInput}`;
                         toolResults: poolStreamResult.toolResults ?? [],
                         analytics: poolStreamResult.analytics,
                         metadata: poolStreamResult.metadata,
-                    };
+                    }, pickLiveStreamDescriptors(poolStreamResult, [
+                        "toolsUsed",
+                        "toolExecutions",
+                    ]));
                 }
                 catch (poolStreamError) {
                     if (isAbortError(poolStreamError)) {
@@ -8785,7 +8806,11 @@ Current user's request: ${currentInput}`;
             provider: providerName,
             systemPromptPassedLength: enhancedSystemPrompt.length,
         });
-        return {
+        // toolsUsed/toolExecutions are attached via defineProperties, not listed
+        // as plain fields: see the identical comment on the ModelPool branch
+        // above — a plain `toolsUsed: streamResult.toolsUsed` here would invoke
+        // and freeze a getter-based provider's value before any chunk is drained.
+        return Object.defineProperties({
             stream: streamResult.stream,
             provider: providerName,
             usage: streamResult.usage,
@@ -8800,7 +8825,7 @@ Current user's request: ${currentInput}`;
             // the loop finishes — snapshotting fields here would freeze them as
             // undefined before the stream is drained.
             metadata: streamResult.metadata,
-        };
+        }, pickLiveStreamDescriptors(streamResult, ["toolsUsed", "toolExecutions"]));
     }
     /**
      * Process stream result
@@ -8831,7 +8856,7 @@ Current user's request: ${currentInput}`;
      * Create stream response
      */
     createStreamResponse(streamResult, stream, config) {
-        return {
+        return Object.defineProperties({
             stream,
             provider: config.providerName,
             model: config.options.model,
@@ -8850,7 +8875,12 @@ Current user's request: ${currentInput}`;
                 guardrailsBlocked: config.guardrailsBlocked,
                 error: config.error,
             }),
-        };
+        }, config.toolTelemetrySource
+            ? pickLiveStreamDescriptors(config.toolTelemetrySource, [
+                "toolsUsed",
+                "toolExecutions",
+            ])
+            : {});
     }
     /**
      * Handle stream error with fallback

package/dist/providers/amazonBedrock/client.js

@@ -264,14 +264,30 @@ export class AmazonBedrockProvider extends BaseProvider {
             provider: this.getProviderName(),
             ...(finishReason !== undefined && { finishReason }),
             ...(rawFinishReason !== undefined && { rawFinishReason }),
-            toolsUsed: toolExecutions.map((execution) => execution.name),
+            // `toolsUsed` means RAN, not "was asked for". `runAgenticLoop` records
+            // every dispatch it performed, including the ones that never reached a
+            // tool: a name the model invented (TOOL_NOT_FOUND), one the breaker had
+            // already given up on (TOOL_PERMANENTLY_FAILED), and one that threw.
+            // Exactly those carry `error`; a call that reached the tool and got a
+            // value back does not. That is the same line `nativeGenerateLoop` draws
+            // — its `toolsUsed.push(name)` sits inside the try, after the guarded
+            // call returns — so filtering here makes Bedrock's generate path report
+            // what every other generate path reports, instead of inflating
+            // analytics, cost attribution and audit with calls that never ran.
+            //
+            // `toolCalls` and `toolExecutions` stay complete on purpose: they are
+            // the record of what the turn ATTEMPTED, and a failed attempt is
+            // precisely what a caller debugging a turn needs to see.
+            toolsUsed: toolExecutions
+                .filter((execution) => execution.error === undefined)
+                .map((execution) => execution.name),
             toolCalls: toolExecutions.map((execution) => ({
                 toolCallId: execution.id,
                 toolName: execution.name,
                 args: execution.input,
             })),
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutions)),
-            enhancedWithTools: toolExecutions.length > 0,
+            enhancedWithTools: toolExecutions.some((execution) => execution.error === undefined),
         };
     }
     async conversationLoop(options) {
@@ -983,7 +999,15 @@ export class AmazonBedrockProvider extends BaseProvider {
                 // alone left every streamed Bedrock turn reporting no tool calls,
                 // however many it made.
                 toolExecutions: outcome.result?.toolExecutions ?? [],
-                toolsUsed: (outcome.result?.toolExecutions ?? []).map((execution) => execution.name),
+                // Same "ran, not asked for" rule as the generate path above.
+                // `toolCallCount` still derives from the unfiltered
+                // `toolExecutions`, which is correct — a dispatch that failed was
+                // still a call — so this list is a fallback today rather than an
+                // observable surface. It is filtered anyway so that the moment
+                // anything does surface it, it is not surfacing the same lie.
+                toolsUsed: (outcome.result?.toolExecutions ?? [])
+                    .filter((execution) => execution.error === undefined)
+                    .map((execution) => execution.name),
             }, Date.now() - startTime, {
                 requestId: `bedrock-stream-${Date.now()}`,
                 streamingMode: true,

package/dist/providers/anthropic/loopAdapter.js

@@ -77,6 +77,11 @@ async function readAnthropicStep({ params, client, channel, stepSignal, requestT
     let cacheWrite5mTokens = 0;
     let cacheWrite1hTokens = 0;
     let stepOutputTokens = 0;
+    // Thinking tokens are a SUBSET of output_tokens (Anthropic bills them as
+    // part of the same total), so this is tracked separately for
+    // observability and never added into outputTokens above.
+    let reasoningTokens = 0;
+    let stepReasoningTokens = 0;
     // Anthropic closes every complete message with `message_stop`. Its
     // absence is the only signal that the response ended early, because the
     // content blocks that DID arrive are syntactically complete.
@@ -96,6 +101,9 @@ async function readAnthropicStep({ params, client, channel, stepSignal, requestT
             const startOutput = usage?.output_tokens ?? 0;
             outputTokens += startOutput - stepOutputTokens;
             stepOutputTokens = startOutput;
+            const startReasoning = usage?.output_tokens_details?.thinking_tokens ?? 0;
+            reasoningTokens += startReasoning - stepReasoningTokens;
+            stepReasoningTokens = startReasoning;
             // Anthropic reports cache reads/writes separately from input_tokens
             // on this same event; without these the stream drops all cache
             // accounting.
@@ -186,6 +194,10 @@ async function readAnthropicStep({ params, client, channel, stepSignal, requestT
             const cumulative = event.usage?.output_tokens ?? stepOutputTokens;
             outputTokens += cumulative - stepOutputTokens;
             stepOutputTokens = cumulative;
+            const cumulativeReasoning = event.usage?.output_tokens_details?.thinking_tokens ??
+                stepReasoningTokens;
+            reasoningTokens += cumulativeReasoning - stepReasoningTokens;
+            stepReasoningTokens = cumulativeReasoning;
             continue;
         }
         if (event.type === "message_stop") {
@@ -327,6 +339,7 @@ async function readAnthropicStep({ params, client, channel, stepSignal, requestT
             // in that tier".
             ...(cacheWrite5mTokens ? { cacheWrite5mTokens } : {}),
             ...(cacheWrite1hTokens ? { cacheWrite1hTokens } : {}),
+            ...(reasoningTokens ? { reasoningTokens } : {}),
         },
         rawStopReason,
         raw: blocks,

package/dist/providers/googleNativeGemini3/utils.d.ts

@@ -68,7 +68,11 @@ export declare function buildNativeConfig(options: {
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
-    /** Model id, used for the registry-driven sampling-param strip. */
+    /**
+     * Model id, used for the registry-driven sampling-param strip and to
+     * pick the right thinkingConfig wire shape (thinkingLevel for Gemini 3,
+     * a translated numeric thinkingBudget for Gemini 2.5).
+     */
     model?: string;
     thinkingConfig?: ThinkingConfig;
     /**

package/dist/providers/googleNativeGemini3/utils.js

@@ -435,8 +435,15 @@ export function buildNativeConfig(options, toolsConfig) {
     if (options.systemPrompt) {
         config.systemInstruction = options.systemPrompt;
     }
-    // Add thinking config for Gemini 3
-    const nativeThinkingConfig = createNativeThinkingConfig(options.thinkingConfig);
+    // Add thinking config. `options.model` is the resolved model id (both
+    // call sites in googleAiStudio/client.ts pass their effective `modelName`
+    // in) — createNativeThinkingConfig picks the wire shape from it: Gemini 3
+    // gets thinkingLevel passthrough, Gemini 2.5 gets a translated numeric
+    // thinkingBudget (see thinkingConfig.ts). Mirrors the Vertex call sites
+    // in googleVertex/client.ts, which this native path was previously
+    // missing — Google AI Studio's identical native SDK rejects
+    // thinkingLevel on Gemini 2.5 exactly like Vertex does.
+    const nativeThinkingConfig = createNativeThinkingConfig(options.thinkingConfig, options.model);
     if (nativeThinkingConfig) {
         config.thinkingConfig = nativeThinkingConfig;
     }

package/dist/providers/googleVertex/client.d.ts

@@ -202,6 +202,43 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Execute stream using native @anthropic-ai/vertex-sdk for Claude models on Vertex AI
      * This bypasses @ai-sdk/google-vertex completely and uses Anthropic's native SDK
      */
+    /**
+     * Extended thinking for Claude-on-Vertex.
+     *
+     * The direct Anthropic provider has always translated `thinkingConfig` into
+     * the Messages API's `thinking` field (anthropic/client.ts). This path never
+     * did — it built the request without one — so `thinkingConfig` was accepted
+     * and silently ignored here: no error, `usage.reasoning` 0, no reasoning
+     * content. Measured against the raw @anthropic-ai/vertex-sdk with the same
+     * project, region, credentials and model, `thinking` is supported and
+     * returns a real thinking block, so the capability was ours to send.
+     *
+     * `thinkingLevel` is deliberately not mapped to a budget: the option's
+     * contract reserves `budgetTokens` for Anthropic models and `thinkingLevel`
+     * for Gemini 3, and inventing a conversion here would be guessing at the
+     * caller's intent.
+     *
+     * The budget must leave room inside `max_tokens` for an answer, so it is
+     * clamped below the ceiling rather than passed through — an over-large
+     * budget is a 400 from the API.
+     *
+     * `useFinalResultTool` (schema / structured-output mode) always pairs with
+     * a forced `tool_choice:{type:"any"}` in the request built right after this
+     * call — Anthropic hard-rejects `thinking` combined with a `tool_choice`
+     * that forces tool use: a live 400, "Thinking may not be enabled when
+     * tool_choice forces tool use." So `thinking` is omitted entirely in that
+     * mode, preserving the prior (pre-thinking-fix) behaviour of silently
+     * ignoring `thinkingConfig` for schema calls instead of hard-failing them —
+     * mirrors the same guard already applied to the OAuth proxy path in
+     * `src/lib/proxy/oauthFetch.ts` (`delete parsed.thinking` when
+     * `tool_choice.type` is `"any"` or `"tool"`). The step/context-cap
+     * finalization backstop reuses this same omission for free since it spreads
+     * `...requestParams`. `tool_choice:{type:"none"}` (the separate
+     * tools-disabled backstop, used only outside schema mode) does not force
+     * tool use — it forces the opposite — so it is not gated here, consistent
+     * with oauthFetch.ts leaving `"none"` alone too.
+     */
+    private buildClaudeThinkingParam;
     private executeNativeAnthropicStream;
     /**
      * Execute generate using native @anthropic-ai/vertex-sdk for Claude models on Vertex AI
@@ -366,6 +403,17 @@ export declare class GoogleVertexProvider extends BaseProvider {
     /**
      * Get model suggestions when a model is not found
      */
+    /**
+     * Candidate model ids for a "model not available" error.
+     *
+     * This list is static. It cannot know what the caller's project and region
+     * actually serve, so it must not claim to: it previously announced
+     * "always available" and included the requested model itself, which
+     * produced errors that recommended the very id that had just failed —
+     * `gemini-3-pro-preview-11-2025` suggesting `gemini-3-pro-preview-11-2025`.
+     * The requested model is now filtered out, and the wording says these are
+     * ids to try rather than ids known to work.
+     */
     private getModelSuggestions;
     /**
      * Generate an embedding for `text` using Vertex via @google/genai.