@juspay/neurolink 11.9.0 → 11.11.0

package/dist/providers/anthropic/loopAdapter.js

@@ -23,6 +23,7 @@
  */
 import { resolveDeferredTool } from "../../tools/toolDiscovery.js";
 import { stringifyAnthropicToolOutput } from "./toolOutput.js";
+import { stringifyFinalResultInput } from "./structuredOutput.js";
 /** Map Anthropic's stop_reason onto the unified finish reason. */
 function mapAnthropicFinishReason(rawStopReason, hadToolCallsAtCap) {
     switch (rawStopReason) {
@@ -271,10 +272,19 @@ export function createAnthropicLoopAdapter(config) {
             // never dispatched, never counted against the breaker, and never shows
             // up as a tool execution.
             const terminal = config.finalResultToolName
-                ? allCalls.find((call) => call.name === config.finalResultToolName)
+                ? [...toolByIndex.values()].find((pending) => pending.name === config.finalResultToolName)
                 : undefined;
             const toolCalls = terminal ? [] : allCalls;
-            const finalText = terminal ? JSON.stringify(terminal.args) : text;
+            // The RAW accumulated input_json, never the parsed-then-restringified
+            // args. `parseArgs` yields {} for a payload the token cap cut off
+            // mid-string, so re-stringifying would turn a truncated answer into
+            // "{}" and lose it outright. `stringifyFinalResultInput` canonicalizes
+            // when the JSON parses and returns it verbatim when it does not, which
+            // is what lets the caller's coercion layer repair a partial payload
+            // into a partial object instead of nothing.
+            const finalText = terminal
+                ? stringifyFinalResultInput(terminal.inputJson)
+                : text;
             return {
                 text: finalText,
                 ...(reasoning ? { reasoning } : {}),

package/dist/providers/googleNativeGemini3/utils.js

@@ -657,10 +657,18 @@ export async function collectStreamChunksIncremental(stream, channel) {
     let outputTokens = 0;
     let cacheReadTokens = 0;
     let reasoningTokens = 0;
+    // Surfaced so a caller can map SAFETY / MALFORMED_FUNCTION_CALL rather
+    // than inferring the turn ended normally. Additive: existing callers that
+    // ignore it are unaffected.
+    let finishReason;
     for await (const chunk of stream) {
         const chunkRecord = chunk;
         const candidates = chunkRecord.candidates;
         const firstCandidate = candidates?.[0];
+        const candidateFinish = firstCandidate?.finishReason;
+        if (typeof candidateFinish === "string") {
+            finishReason = candidateFinish;
+        }
         const chunkContent = firstCandidate?.content;
         if (chunkContent && Array.isArray(chunkContent.parts)) {
             for (const part of chunkContent.parts) {
@@ -689,6 +697,7 @@ export async function collectStreamChunksIncremental(stream, channel) {
     return {
         rawResponseParts,
         stepFunctionCalls,
+        finishReason,
         inputTokens,
         outputTokens,
         cacheReadTokens,

package/dist/types/loopEngine.d.ts

@@ -1,5 +1,6 @@
 import type Anthropic from "@anthropic-ai/sdk";
 import type { Tool } from "./tools.js";
+import type { NativeFunctionCall, NativeToolDeclarationsResult } from "./providers.js";
 /**
  * One chunk on the engine's stream.
  *
@@ -173,6 +174,94 @@ export type AnthropicLoopAdapterConfig = {
     noteObservedPromptTokens?: (promptTokens: number) => void;
     abortSignal?: AbortSignal;
 };
+/** What one Gemini step produced, carried to `buildToolResultMessages`. */
+export type GeminiStepRaw = {
+    rawResponseParts: unknown[];
+    stepFunctionCalls: NativeFunctionCall[];
+};
+/** One turn entry in a Gemini conversation: a role plus its content parts. */
+export type GeminiTurnContent = {
+    role: string;
+    parts: unknown[];
+};
+/**
+ * Construction input for `createGeminiLoopAdapter`, shared by Google AI Studio
+ * and Vertex Gemini. Both issue `models.generateContentStream` and consume the
+ * same response shape, so one adapter serves four hand-rolled loops.
+ */
+export type GeminiLoopAdapterCoreConfig = {
+    /** Used in log lines and generated tool-call ids. */
+    providerLabel: string;
+    maxSteps: number;
+    /** Build one step's request object (model, contents, config). */
+    buildRequest: (conversation: GeminiTurnContent[], step: number) => unknown;
+    /** Issue the request. Kept injectable so each provider keeps its own client. */
+    sendStep: (request: unknown, signal: AbortSignal) => Promise<AsyncIterable<{
+        functionCalls?: NativeFunctionCall[];
+        [key: string]: unknown;
+    }>>;
+    /**
+     * The turn's live tool record. Mid-turn `search_tools` discovery hydrates
+     * into this, which is what both the declaration refresh and
+     * `resolveToolOnMiss` read.
+     */
+    liveTools: Record<string, Tool>;
+    /**
+     * Declarations built for this turn. Carries `originalNameMap`, which keeps
+     * Google's function-name sanitization on the adapter side of the engine
+     * boundary.
+     */
+    declarations?: NativeToolDeclarationsResult;
+    toolFailureBreaker?: AgenticLoopToolFailureBreaker;
+    /**
+     * In-turn context reclaim, run once per step before the request is built.
+     * Returns the rebuilt conversation when it reclaimed, undefined when the
+     * request still fits.
+     *
+     * Provider-supplied rather than engine-owned because the two Gemini
+     * providers reclaim differently (reclaimAiStudioContext vs
+     * reclaimVertexLoopContext) while the engine only decides WHEN to ask. The
+     * loops append a model turn plus a tool turn every step with nothing else
+     * bounding growth, so a migration that drops this overflows the context
+     * window mid-turn and loses every completed step.
+     */
+    planReclaim?: (conversation: GeminiTurnContent[], step: number) => GeminiTurnContent[] | undefined;
+    /**
+     * Usage feedback for the provider's own context guard, called after each
+     * step with that step's real token counts.
+     */
+    noteUsage?: (inputTokens: number, outputTokens: number) => void;
+};
+/**
+ * Opt in to the single MALFORMED_FUNCTION_CALL retry.
+ *
+ * Vertex Gemini only. AI Studio has no such retry today (confirmed: zero
+ * MALFORMED_FUNCTION_CALL handling in its client), and turning it on there
+ * would be a behaviour change disguised as a shared refactor. The engine owns
+ * the one-retry budget; this only says whether to ask.
+ *
+ * A union rather than two independent optional fields because the retry is
+ * only worth spending a step on if the re-issued request differs from the one
+ * that just failed. `runAgenticLoop` falls back to the unchanged conversation
+ * when no note builder is supplied (`buildMalformedRetryNote?.(…) ??
+ * conversation`), so enabling the retry without one re-sends a byte-identical
+ * request and most often reproduces the same malformed call — a step burned
+ * for nothing. Requiring the builder here makes that combination unsayable
+ * instead of merely discouraged.
+ */
+export type GeminiMalformedRetryConfig = {
+    enableMalformedRetry: true;
+    /**
+     * Append the corrective turn that the retry re-issues with.
+     * Provider-supplied because the note is written in the provider's own
+     * content shape.
+     */
+    buildMalformedRetryNote: (conversation: GeminiTurnContent[]) => GeminiTurnContent[];
+} | {
+    enableMalformedRetry?: false;
+    buildMalformedRetryNote?: never;
+};
+export type GeminiLoopAdapterConfig = GeminiLoopAdapterCoreConfig & GeminiMalformedRetryConfig;
 export type AgenticLoopOptions = {
     tools?: Record<string, {
         execute?: (args: Record<string, unknown>, opts: unknown) => Promise<unknown>;
@@ -182,10 +271,24 @@ export type AgenticLoopOptions = {
 export type AgenticLoopResult<TConversation> = {
     text: string;
     toolCalls: AgenticLoopToolCall[];
+    /**
+     * Every tool dispatch the loop performed, in order, including the ones that
+     * failed.
+     *
+     * `id` and `error` are carried because providers persist tool activity as
+     * paired call/result records keyed by the provider's own tool-call id, and
+     * a result that failed is stored differently from one that succeeded. A
+     * shape with only name/input/output cannot reconstruct either, so a
+     * provider migrating its hand-rolled loop onto this engine would have to
+     * silently drop both from its history — which is a behaviour change, not a
+     * refactor.
+     */
     toolExecutions: Array<{
+        id: string;
         name: string;
         input: Record<string, unknown>;
         output: unknown;
+        error?: string;
     }>;
     usage: AgenticLoopUsage;
     finishReason: string;

package/dist/types/providers.d.ts

@@ -1738,6 +1738,8 @@ export type NativeFunctionResponse = {
 export type CollectedChunkResult = {
     rawResponseParts: unknown[];
     stepFunctionCalls: NativeFunctionCall[];
+    /** Raw `Candidate.finishReason` from the last chunk that carried one. */
+    finishReason?: string;
     inputTokens: number;
     outputTokens: number;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.9.0",
+  "version": "11.11.0",
   "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": {