@juspay/neurolink 9.65.0 → 9.65.1

package/dist/lib/types/conversation.d.ts

@@ -544,3 +544,19 @@ export type ProviderDetails = {
     provider: string;
     model: string;
 };
+/**
+ * Reduced ChatMessage shape used by callers (typically tests and history
+ * reconstructors) that pass synthetic entries into the Gemini history
+ * reconstructor without filling every `ChatMessage` field. Mirrors the
+ * fields actually read by `prependConversationMessages`.
+ */
+export type MinimalChatMessage = {
+    role: ChatMessage["role"];
+    content: string;
+    tool?: string;
+    args?: Record<string, unknown>;
+    metadata?: {
+        stepIndex?: number;
+        thoughtSignature?: string;
+    };
+};

package/dist/providers/googleAiStudio.js

@@ -1,14 +1,16 @@
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { IMAGE_GENERATION_MODELS } from "../core/constants.js";
+import { IMAGE_GENERATION_MODELS, TOOL_STORAGE_TIMEOUT_MS, } from "../core/constants.js";
 import { processUnifiedFilesArray } from "../utils/messageBuilder.js";
 import { ATTR, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../telemetry/index.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { withTimeout } from "../utils/async/index.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
-import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
+import { transformToolExecutions } from "../utils/transformationUtils.js";
+import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
@@ -556,6 +558,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 const channel = createTextChannel();
                 // Shared mutable state updated by the background agentic loop.
                 const allToolCalls = [];
+                // Mirror the Vertex Gemini stream path: track tool executions so
+                // the storage hook can persist real outputs and StreamResult can
+                // surface toolsUsed/toolExecutions for tool-bearing turns.
+                const toolExecutions = [];
                 // analyticsResolvers lets the background loop settle the analytics
                 // promise once token counts are known (after the loop completes).
                 let analyticsResolve;
@@ -626,7 +632,40 @@ export class GoogleAIStudioProvider extends BaseProvider {
                                 logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
                                 // Add model response with ALL parts (including thoughtSignature) to history
                                 pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                                const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal, originalNameMap });
+                                const toolCallsBefore = allToolCalls.length;
+                                const toolExecsBefore = toolExecutions.length;
+                                const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, {
+                                    abortSignal: composedSignal,
+                                    originalNameMap,
+                                    toolExecutions,
+                                });
+                                // Persist this step's tool calls/results into conversation
+                                // memory. Without this, tool_call / tool_result rows never
+                                // reach Redis and the chat-history UI loses every tool
+                                // invocation.
+                                const stepToolCalls = allToolCalls.slice(toolCallsBefore);
+                                const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                                if (stepToolCalls.length > 0 || stepToolExecs.length > 0) {
+                                    const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                                    withTimeout(this.handleToolExecutionStorage(stepToolCalls.map((tc, i) => ({
+                                        toolName: tc.toolName,
+                                        args: tc.args,
+                                        ...(i === 0 && stepThoughtSig
+                                            ? { thoughtSignature: stepThoughtSig }
+                                            : {}),
+                                        stepIndex: step,
+                                    })), stepToolExecs.map((te) => ({
+                                        toolName: te.name,
+                                        output: te.output,
+                                        stepIndex: step,
+                                    })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
+                                        logger.warn("[GoogleAIStudio] Failed to store native tool executions", {
+                                            error: error instanceof Error
+                                                ? error.message
+                                                : String(error),
+                                        });
+                                    });
+                                }
                                 // Add function responses to history — the @google/genai SDK
                                 // only accepts "user" and "model" as valid roles in contents.
                                 // Function/tool responses must use role: "user" (matching the
@@ -683,7 +722,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 // Suppress unhandled-rejection warnings on loopPromise — errors are
                 // forwarded to the channel and will surface when the caller iterates.
                 loopPromise.catch(() => undefined);
-                return {
+                const result = {
                     stream: channel.iterable,
                     provider: this.providerName,
                     model: modelName,
@@ -691,6 +730,20 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     analytics: analyticsPromise,
                     metadata,
                 };
+                // Surface tools-used + executions via getters so they resolve at
+                // access time, after the background loop has populated the live
+                // arrays. Same lazy pattern used for `structuredOutput` elsewhere.
+                Object.defineProperty(result, "toolsUsed", {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => allToolCalls.map((tc) => tc.toolName),
+                });
+                Object.defineProperty(result, "toolExecutions", {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => transformToolExecutions(toolExecutions),
+                });
+                return result;
             }
             finally {
                 // Timeout controller cleanup is managed inside the background loop
@@ -821,11 +874,35 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         // Add model response with ALL parts (including thoughtSignature) to history
                         // This is critical for Gemini 3 - it requires thought signatures in subsequent turns
                         pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                        const toolCallsBefore = allToolCalls.length;
+                        const toolExecsBefore = toolExecutions.length;
                         const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, {
                             toolExecutions,
                             abortSignal: composedSignal,
                             originalNameMap,
                         });
+                        // Persist this step's tool calls/results into conversation memory.
+                        const stepToolCalls = allToolCalls.slice(toolCallsBefore);
+                        const stepToolExecs = toolExecutions.slice(toolExecsBefore);
+                        if (stepToolCalls.length > 0 || stepToolExecs.length > 0) {
+                            const stepThoughtSig = extractThoughtSignature(chunkResult.rawResponseParts);
+                            withTimeout(this.handleToolExecutionStorage(stepToolCalls.map((tc, i) => ({
+                                toolName: tc.toolName,
+                                args: tc.args,
+                                ...(i === 0 && stepThoughtSig
+                                    ? { thoughtSignature: stepThoughtSig }
+                                    : {}),
+                                stepIndex: step,
+                            })), stepToolExecs.map((te) => ({
+                                toolName: te.name,
+                                output: te.output,
+                                stepIndex: step,
+                            })), options, new Date()), TOOL_STORAGE_TIMEOUT_MS, "tool storage write timed out").catch((error) => {
+                                logger.warn("[GoogleAIStudio] Failed to store native generate tool executions", {
+                                    error: error instanceof Error ? error.message : String(error),
+                                });
+                            });
+                        }
                         // Add function responses to history — the @google/genai SDK
                         // only accepts "user" and "model" as valid roles in contents.
                         // Function/tool responses must use role: "user" (matching the
@@ -861,7 +938,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     },
                     responseTime,
                     toolsUsed: allToolCalls.map((tc) => tc.toolName),
-                    toolExecutions: toolExecutions,
+                    toolExecutions: transformToolExecutions(toolExecutions),
                     enhancedWithTools: allToolCalls.length > 0,
                 };
                 return this.enhanceResult(baseResult, options, startTime);

package/dist/providers/googleNativeGemini3.d.ts

@@ -9,7 +9,7 @@
  * providers so they can share a single implementation.
  */
 import { type Tool } from "ai";
-import type { ThinkingConfig, CollectedChunkResult, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, VertexNativePart, GeminiMultimodalInput } from "../types/index.js";
+import type { ThinkingConfig, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, VertexNativePart, GeminiMultimodalInput } from "../types/index.js";
 export declare function sanitizeForGoogleFunctionName(name: string): string;
 /**
  * Resolve a sanitized Gemini tool name to one that is both unique within
@@ -218,10 +218,7 @@ export declare function buildGeminiResponseSchema(schema: unknown): Record<strin
 export declare function prependConversationMessages(contents: Array<{
     role: string;
     parts: unknown[];
-}>, conversationMessages?: Array<{
-    role: string;
-    content: string;
-}>): void;
+}>, conversationMessages?: Array<ChatMessage | MinimalChatMessage>): void;
 /**
  * Build the `parts` array for the current user turn of a Gemini native
  * `generateContent` request, including inline image + PDF blobs.

package/dist/providers/googleNativeGemini3.js

@@ -646,6 +646,10 @@ export async function executeNativeToolCalls(logLabel, stepFunctionCalls, execut
     // original name. Falls back to the safe name if the map is missing or
     // doesn't contain the call (e.g. tool added mid-conversation).
     const externalName = (safeName) => options?.originalNameMap?.get(safeName) ?? safeName;
+    // Note: tool:start / tool:end events are emitted by ToolsManager's
+    // `execute` wrapper (see src/lib/core/modules/ToolsManager.ts:355 and :790)
+    // around every tool's execute function. The native paths invoke that same
+    // wrapped execute via the executeMap, so emitting here would duplicate.
     for (const call of stepFunctionCalls) {
         const exposedName = externalName(call.name);
         allToolCalls.push({ toolName: exposedName, args: call.args });
@@ -808,22 +812,113 @@ export function buildGeminiResponseSchema(schema) {
  *  - The current user input should be appended AFTER calling this helper
  *    so the prior turns appear first in chronological order.
  */
-export function prependConversationMessages(contents, conversationMessages) {
+export function prependConversationMessages(contents, 
+// Accept either the full ChatMessage shape (when callers pass real Redis-
+// backed history) or the reduced MinimalChatMessage shape (tests / synthetic
+// callers). Only role, content, tool, args, and metadata.* are read here.
+conversationMessages) {
     if (!conversationMessages || conversationMessages.length === 0) {
         return;
     }
+    // Walk prior turns building ordered segments. Tool_call / tool_result rows
+    // get grouped by (turnCounter, stepIndex) so parallel calls within a step
+    // stay together and don't bleed across turn boundaries. Regular user/
+    // assistant messages act as those boundaries.
+    //
+    // Without this reconstruction, a text-only mapper would strip tool rows
+    // from history — leaving the model unaware of any tools it called in
+    // prior turns. The grouped emit (model with functionCall parts → user
+    // with functionResponse parts) is what @google/genai's own
+    // automaticFunctionCalling produces, so the SDK validates it as a
+    // well-formed multi-turn conversation.
+    const stepMap = new Map();
+    const segments = [];
+    let turnCounter = 0;
+    const makeKey = (stepIndex) => `${turnCounter}:${stepIndex ?? "undefined"}`;
+    const getOrCreateStep = (stepIndex) => {
+        const key = makeKey(stepIndex);
+        const existing = stepMap.get(key);
+        if (existing) {
+            return existing;
+        }
+        const step = {
+            type: "tool_step",
+            callParts: [],
+            resultParts: [],
+        };
+        stepMap.set(key, step);
+        segments.push(step);
+        return step;
+    };
     for (const msg of conversationMessages) {
-        if (msg.role !== "user" && msg.role !== "assistant") {
+        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;
         }
-        const text = typeof msg.content === "string" ? msg.content : "";
-        if (text.length === 0) {
+        if (msg.role === "tool_result") {
+            const step = getOrCreateStep(msg.metadata?.stepIndex);
+            let responsePayload;
+            try {
+                responsePayload =
+                    msg.content !== undefined && msg.content !== null
+                        ? { result: JSON.parse(msg.content) }
+                        : { result: "success" };
+            }
+            catch {
+                responsePayload = { result: msg.content ?? "success" };
+            }
+            step.resultParts.push({
+                functionResponse: {
+                    name: msg.tool || "unknown",
+                    response: responsePayload,
+                },
+            });
             continue;
         }
-        contents.push({
-            role: msg.role === "assistant" ? "model" : "user",
-            parts: [{ text }],
-        });
+        // Regular (user / assistant) message — acts as a turn boundary.
+        const role = msg.role === "assistant" ? "model" : msg.role;
+        if (role !== "user" && role !== "model") {
+            continue;
+        }
+        if (!msg.content || msg.content.trim().length === 0) {
+            continue;
+        }
+        // Increment turn counter BEFORE pushing the segment so any tool_calls
+        // that follow this message get a fresh (turnCounter, stepIndex) 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)
+    // — same ordering @google/genai's automaticFunctionCalling produces.
+    for (const seg of segments) {
+        if (seg.type === "regular") {
+            contents.push({ role: seg.role, parts: seg.parts });
+            continue;
+        }
+        if (seg.callParts.length === 0) {
+            if (seg.resultParts.length > 0) {
+                logger.debug("[GoogleNativeGemini3] Dropping orphan tool_result segment with no matching tool_call rows", { resultCount: seg.resultParts.length });
+            }
+            continue;
+        }
+        contents.push({ role: "model", parts: seg.callParts });
+        if (seg.resultParts.length > 0) {
+            contents.push({ role: "user", parts: seg.resultParts });
+        }
     }
 }
 /**