@juspay/neurolink 9.54.9 → 9.55.0

package/dist/providers/googleVertex.js

@@ -24,7 +24,7 @@ import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
-import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, normalizeToolsForJsonSchemaProvider, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
+import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, normalizeToolsForJsonSchemaProvider, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { getModelId } from "./providerTypeUtils.js";
 // Import proper types for multimodal message handling
 // Keep-alive note: Node.js native fetch and undici (used by createProxyFetch)
@@ -1310,10 +1310,63 @@ export class GoogleVertexProvider extends BaseProvider {
             return currentContents;
         }
         const history = [];
+        // Composite key: "<turnCounter>:<stepIndex>" ensures step 1 of
+        // conversational turn 1 never collides with step 1 of turn 2.
+        const stepMap = new Map();
+        const segments = [];
+        // Incremented each time a regular user/assistant message is encountered,
+        // acting as a logical turn boundary between agentic loop iterations.
+        let turnCounter = 0;
+        const makeKey = (stepIndex) => `${turnCounter}:${stepIndex ?? "undefined"}`;
+        const getOrCreateStep = (stepIndex) => {
+            const key = makeKey(stepIndex);
+            if (stepMap.has(key)) {
+                return stepMap.get(key);
+            }
+            const step = {
+                type: "tool_step",
+                callParts: [],
+                resultParts: [],
+            };
+            stepMap.set(key, step);
+            segments.push(step);
+            return step;
+        };
         for (const msg of conversationMessages) {
-            // @google/genai only accepts "user" and "model" roles in contents.
-            // Skip system messages (handled via config.systemInstruction).
-            // Map "assistant" → "model" (Gemini convention).
+            if (msg.role === "tool_call") {
+                const step = getOrCreateStep(msg.metadata?.stepIndex);
+                const fcPart = {
+                    functionCall: {
+                        name: msg.tool || "unknown",
+                        args: msg.args || {},
+                    },
+                };
+                if (msg.metadata?.thoughtSignature) {
+                    fcPart.thoughtSignature = msg.metadata.thoughtSignature;
+                }
+                step.callParts.push(fcPart);
+                continue;
+            }
+            if (msg.role === "tool_result") {
+                const step = getOrCreateStep(msg.metadata?.stepIndex);
+                let responsePayload;
+                try {
+                    responsePayload = msg.content
+                        ? { result: JSON.parse(msg.content) }
+                        : { result: "success" };
+                }
+                catch {
+                    responsePayload = { result: msg.content || "success" };
+                }
+                step.resultParts.push({
+                    functionResponse: {
+                        name: msg.tool || "unknown",
+                        response: responsePayload,
+                    },
+                });
+                continue;
+            }
+            // Regular (user / assistant) message — acts as a turn boundary.
             const role = msg.role === "assistant" ? "model" : msg.role;
             if (role !== "user" && role !== "model") {
                 continue;
@@ -1321,9 +1374,29 @@ export class GoogleVertexProvider extends BaseProvider {
             if (!msg.content || msg.content.trim().length === 0) {
                 continue;
             }
-            history.push({ role, parts: [{ text: msg.content }] });
+            // Increment turn counter BEFORE pushing the segment so that any
+            // tool_calls that follow this message get a fresh namespace.
+            turnCounter++;
+            const textPart = { text: msg.content };
+            if (msg.metadata?.thoughtSignature) {
+                textPart.thoughtSignature = msg.metadata.thoughtSignature;
+            }
+            segments.push({ type: "regular", role, parts: [textPart] });
+        }
+        // Emit in order: each ToolStep → model turn (calls) + user turn (results)
+        for (const seg of segments) {
+            if (seg.type === "regular") {
+                history.push({ role: seg.role, parts: seg.parts });
+            }
+            else {
+                if (seg.callParts.length > 0) {
+                    history.push({ role: "model", parts: seg.callParts });
+                }
+                if (seg.resultParts.length > 0) {
+                    history.push({ role: "user", parts: seg.resultParts });
+                }
+            }
         }
-        // Prepend history before current user message
         return [...history, ...currentContents];
     }
     // ── Shared Gemini 3 helpers are now in ./googleNativeGemini3.ts ──
@@ -1425,6 +1498,7 @@ export class GoogleVertexProvider extends BaseProvider {
             timeoutController,
             composedSignal,
             maxSteps,
+            options,
         });
         loopPromise.catch(() => undefined);
         return {
@@ -1438,11 +1512,13 @@ export class GoogleVertexProvider extends BaseProvider {
     }
     async runNativeGemini3StreamLoop(params) {
         let lastStepText = "";
+        let lastThoughtSignature;
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
         let step = 0;
         let completedWithFinalAnswer = false;
         const failedTools = new Map();
+        const toolExecutions = [];
         try {
             while (step < params.maxSteps) {
                 if (params.composedSignal?.aborted) {
@@ -1465,6 +1541,10 @@ export class GoogleVertexProvider extends BaseProvider {
                     totalInputTokens += chunkResult.inputTokens;
                     totalOutputTokens += chunkResult.outputTokens;
                     const stepText = extractTextFromParts(chunkResult.rawResponseParts);
+                    const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                    if (stepThoughtSig) {
+                        lastThoughtSignature = stepThoughtSig;
+                    }
                     if (chunkResult.stepFunctionCalls.length === 0) {
                         completedWithFinalAnswer = true;
                         break;
@@ -1478,7 +1558,36 @@ export class GoogleVertexProvider extends BaseProvider {
                     }
                     logger.debug(`[GoogleVertex] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
                     pushModelResponseToHistory(params.currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                    const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, params.executeMap, failedTools, params.allToolCalls, { abortSignal: params.composedSignal });
+                    // Track array lengths before execution to extract this step's additions
+                    const toolCallsBefore = params.allToolCalls.length;
+                    const toolExecsBefore = toolExecutions.length;
+                    const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, params.executeMap, failedTools, params.allToolCalls, { toolExecutions, abortSignal: params.composedSignal });
+                    // Store this step's tool calls/results in conversation memory
+                    // (mirrors onStepFinish in the standard GenerationHandler path)
+                    const stepToolCalls = params.allToolCalls.slice(toolCallsBefore);
+                    const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                    // Tag each tool call with the step's thoughtSignature and stepIndex
+                    // so they can be stored on the tool_call ChatMessage metadata in Redis
+                    // and reconstructed correctly in prependConversationHistory.
+                    const taggedToolCalls = stepToolCalls.map((tc, i) => ({
+                        ...tc,
+                        ...(i === 0 && stepThoughtSig
+                            ? { thoughtSignature: stepThoughtSig }
+                            : {}),
+                        stepIndex: step,
+                    }));
+                    const taggedToolResults = stepToolExecs.map((te) => ({
+                        toolName: te.name,
+                        result: te.output,
+                        stepIndex: step,
+                    }));
+                    if (taggedToolCalls.length > 0 || taggedToolResults.length > 0) {
+                        this.handleToolExecutionStorage(taggedToolCalls, taggedToolResults, params.options, new Date()).catch((error) => {
+                            logger.warn("[GoogleVertex] Failed to store native stream tool executions", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        });
+                    }
                     params.currentContents.push({
                         role: "user",
                         parts: functionResponses,
@@ -1498,6 +1607,10 @@ export class GoogleVertexProvider extends BaseProvider {
             const responseTime = Date.now() - params.startTime;
             params.metadata.responseTime = responseTime;
             params.metadata.totalToolExecutions = params.allToolCalls.length;
+            if (lastThoughtSignature) {
+                params.metadata.thoughtSignature =
+                    lastThoughtSignature;
+            }
             params.span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
             params.span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
             params.span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= params.maxSteps && !completedWithFinalAnswer
@@ -1603,10 +1716,8 @@ export class GoogleVertexProvider extends BaseProvider {
             // Build config — systemInstruction stays in config for Gemini 3.x.
             // See stream path comment for rationale.
             const config = buildNativeConfig(options, toolsConfig);
-            // Note: Schema/JSON output for Gemini 3 native SDK is complex due to $ref resolution issues
-            // For now, schemas are handled via the AI SDK fallback path, not native SDK
-            // TODO: Implement proper $ref resolution for complex nested schemas
             const startTime = Date.now();
+            // 5-min default: timeout covers ALL agentic steps, 30s is too short.
             const timeout = this.getTimeout(options);
             const timeoutController = createTimeoutController(timeout, this.providerName, "generate");
             const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
@@ -1615,6 +1726,7 @@ export class GoogleVertexProvider extends BaseProvider {
             const currentContents = this.prependConversationHistory([...contents], options.conversationMessages);
             let finalText = "";
             let lastStepText = "";
+            let lastThoughtSignature;
             let totalInputTokens = 0;
             let totalOutputTokens = 0;
             const allToolCalls = [];
@@ -1642,11 +1754,24 @@ export class GoogleVertexProvider extends BaseProvider {
                                 : {}),
                         });
                         const chunkResult = await collectStreamChunks(stream);
+                        // Silent timeout: abort signal may terminate the stream without
+                        // throwing, yielding zero parts. Surface error explicitly.
+                        if (composedSignal?.aborted &&
+                            chunkResult.rawResponseParts.length === 0) {
+                            throw composedSignal.reason instanceof Error
+                                ? composedSignal.reason
+                                : new Error("Request timed out (no response parts received)");
+                        }
                         totalInputTokens += chunkResult.inputTokens;
                         totalOutputTokens += chunkResult.outputTokens;
+                        const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                        if (stepThoughtSig) {
+                            lastThoughtSignature = stepThoughtSig;
+                        }
                         const stepText = extractTextFromParts(chunkResult.rawResponseParts);
                         if (chunkResult.stepFunctionCalls.length === 0) {
-                            finalText = stepText;
+                            // Fall back to lastStepText when final step has no text parts
+                            finalText = stepText || lastStepText;
                             break;
                         }
                         lastStepText = stepText;
@@ -1659,7 +1784,36 @@ export class GoogleVertexProvider extends BaseProvider {
                         }
                         logger.debug(`[GoogleVertex] Generate executing ${chunkResult.stepFunctionCalls.length} function calls`);
                         pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                        // Track array lengths before execution to extract this step's additions
+                        const toolCallsBefore = allToolCalls.length;
+                        const toolExecsBefore = toolExecutions.length;
                         const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { toolExecutions, abortSignal: composedSignal });
+                        // Store this step's tool calls/results in conversation memory
+                        // (mirrors onStepFinish in the standard GenerationHandler path)
+                        const stepToolCalls = allToolCalls.slice(toolCallsBefore);
+                        const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                        // Tag each tool call with the step's thoughtSignature and stepIndex
+                        // so they can be stored on the tool_call ChatMessage metadata in Redis
+                        // and reconstructed correctly in prependConversationHistory.
+                        const taggedToolCalls = stepToolCalls.map((tc, i) => ({
+                            ...tc,
+                            ...(i === 0 && stepThoughtSig
+                                ? { thoughtSignature: stepThoughtSig }
+                                : {}),
+                            stepIndex: step,
+                        }));
+                        const taggedToolResults = stepToolExecs.map((te) => ({
+                            toolName: te.name,
+                            result: te.output,
+                            stepIndex: step,
+                        }));
+                        if (taggedToolCalls.length > 0 || taggedToolResults.length > 0) {
+                            this.handleToolExecutionStorage(taggedToolCalls, taggedToolResults, options, new Date()).catch((error) => {
+                                logger.warn("[GoogleVertex] Failed to store native tool executions", {
+                                    error: error instanceof Error ? error.message : String(error),
+                                });
+                            });
+                        }
                         // Function/tool responses must use role: "user" — the
                         // @google/genai SDK's validateHistory() only accepts "user"
                         // and "model" roles (matching automaticFunctionCalling).
@@ -1720,6 +1874,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 toolsUsed: allToolCalls.map((tc) => tc.toolName),
                 toolExecutions: toolExecutions,
                 enhancedWithTools: allToolCalls.length > 0,
+                ...(lastThoughtSignature && {
+                    thoughtSignature: lastThoughtSignature,
+                }),
             };
         });
     }

package/dist/types/conversation.d.ts

@@ -224,6 +224,8 @@ export type ChatMessageMetadata = {
     thoughtHash?: string;
     /** Whether extended thinking was used for this message */
     thinkingExpanded?: boolean;
+    /** Step index for reconstructing parallel vs sequential tool calls */
+    stepIndex?: number;
     /**
      * Head/tail preview of a large tool output.
      * Only present on tool_result messages where the output exceeded truncation limits.
@@ -371,6 +373,8 @@ export type StoreConversationTurnOptions = {
         cacheReadTokens?: number;
         cacheWriteTokens?: number;
     };
+    /** Gemini 3 thought signature for reasoning continuity across turns */
+    thoughtSignature?: string;
 };
 /**
  * Lightweight session metadata for efficient session listing

package/dist/types/generate.d.ts

@@ -999,6 +999,8 @@ export type TextGenerationResult = {
     imageOutput?: {
         base64: string;
     } | null;
+    /** Gemini 3 thought signature for reasoning continuity across turns */
+    thoughtSignature?: string;
     retries?: {
         count: number;
         errors: Array<{

package/dist/types/providers.d.ts

@@ -1577,3 +1577,18 @@ export type VertexNativePart = {
         data: string;
     };
 };
+/**
+ * Internal helpers used by the conversation-history builder in
+ * providers/googleVertex.ts to merge interleaved tool call / result turns.
+ */
+export type VertexToolStep = {
+    type: "tool_step";
+    callParts: unknown[];
+    resultParts: unknown[];
+};
+export type VertexRegularSegment = {
+    type: "regular";
+    role: string;
+    parts: unknown[];
+};
+export type VertexSegment = VertexToolStep | VertexRegularSegment;

package/dist/types/tools.d.ts

@@ -432,13 +432,17 @@ export type PendingToolExecution = {
         toolName?: string;
         args?: Record<string, unknown>;
         timestamp?: Date;
+        thoughtSignature?: string;
+        stepIndex?: number;
         [key: string]: unknown;
     }>;
     toolResults: Array<{
         toolCallId?: string;
+        toolName?: string;
         result?: unknown;
         error?: string;
         timestamp?: Date;
+        stepIndex?: number;
         [key: string]: unknown;
     }>;
     timestamp: number;

package/dist/utils/conversationMemory.js

@@ -170,6 +170,7 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
                         cacheWriteTokens: result.usage.cacheCreationTokens,
                     }
                     : undefined,
+                thoughtSignature: result.thoughtSignature,
             });
             logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
                 requestId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.54.9",
+  "version": "9.55.0",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {