@juspay/neurolink 11.11.3 → 11.11.5

package/dist/cli/commands/proxy.d.ts

@@ -58,6 +58,23 @@ export declare function isRollingHandoffCapable(state: ProxySupervisorState | nu
  *   confirm a mismatch" and falls through to the args-only result.
  */
 export declare function processLooksLikeProxySupervisor(pid: number, expectedStartTimeIso?: string): Promise<boolean>;
+declare function getOpenCodeConfigDir(): string;
+declare function getOpenCodeConfigPath(): string;
+declare function setOpenCodeProxySettings(baseUrl: string, proxyKey?: string): Promise<boolean>;
+declare function clearOpenCodeProxySettings(expectedBaseUrl?: string): Promise<boolean>;
+/**
+ * Test-only export (CLAUDE.md rule 15 determinism exception). The OpenCode
+ * client writers resolve paths from the environment and are only reachable
+ * from `proxy start` / `proxy setup`, neither of which can be driven against a
+ * throwaway HOME without starting a real server. Consumed by
+ * test/continuous-test-suite-proxy.ts.
+ */
+export declare const __openCodeTestHooks: {
+    getOpenCodeConfigDir: typeof getOpenCodeConfigDir;
+    getOpenCodeConfigPath: typeof getOpenCodeConfigPath;
+    setOpenCodeProxySettings: typeof setOpenCodeProxySettings;
+    clearOpenCodeProxySettings: typeof clearOpenCodeProxySettings;
+};
 export declare function probeProxyHealth(host: string, port: number, timeoutMs: number): Promise<ProxyHealthProbe>;
 export declare function mapClaudeErrorTypeToStatus(errorType?: string): number;
 export declare function createProxyStartApp(params: {
@@ -84,3 +101,4 @@ export declare const proxyGuardCommand: CommandModule<object, ProxyGuardArgs>;
 export declare const proxySetupCommand: CommandModule;
 export declare const proxyInstallCommand: CommandModule;
 export declare const proxyUninstallCommand: CommandModule;
+export {};

package/dist/cli/commands/proxy.js

@@ -513,13 +513,17 @@ async function clearClaudeProxySettings(expectedBaseUrl) {
 // OPENCODE AUTO-CONFIGURATION
 // =============================================================================
 function getOpenCodeConfigDir() {
-    if (process.platform === "darwin") {
-        return join(homedir(), "Library", "Application Support", "opencode");
-    }
-    // Linux/other: XDG_CONFIG_HOME or ~/.config
+    // OpenCode resolves this with the unmodified `xdg-basedir` package —
+    // `XDG_CONFIG_HOME || ~/.config` — on every platform, macOS included. There
+    // is deliberately no darwin branch here: `~/Library/Application Support/
+    // opencode` is not a path OpenCode reads. (The similar-looking literal in
+    // OpenCode's binary is `systemManagedConfigDir()`, an MDM policy directory
+    // at the filesystem root with no $HOME prefix.)
     return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
 }
-const OPENCODE_CONFIG_PATH = join(getOpenCodeConfigDir(), "opencode.json");
+function getOpenCodeConfigPath() {
+    return join(getOpenCodeConfigDir(), "opencode.json");
+}
 /**
  * Key under which we persist the snapshot of the user's pre-existing
  * `provider.neurolink` config inside `opencode.json` itself. Persisting (rather
@@ -536,12 +540,14 @@ async function setOpenCodeProxySettings(baseUrl, proxyKey) {
         fs.accessSync(configDir);
     }
     catch {
-        // OpenCode not installed — config directory does not exist, skip silently
-        return;
+        // OpenCode not installed — config directory does not exist. Report the
+        // skip so the caller does not print a success message for work that did
+        // not happen.
+        return false;
     }
     let config;
     try {
-        config = JSON.parse(fs.readFileSync(OPENCODE_CONFIG_PATH, "utf8"));
+        config = JSON.parse(fs.readFileSync(getOpenCodeConfigPath(), "utf8"));
     }
     catch {
         // file missing/invalid — create fresh config object
@@ -571,13 +577,14 @@ async function setOpenCodeProxySettings(baseUrl, proxyKey) {
         },
     };
     config.provider = provider;
-    fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+    fs.writeFileSync(getOpenCodeConfigPath(), JSON.stringify(config, null, 2));
+    return true;
 }
 async function clearOpenCodeProxySettings(expectedBaseUrl) {
     const fs = await import("fs");
     let config;
     try {
-        config = JSON.parse(fs.readFileSync(OPENCODE_CONFIG_PATH, "utf8"));
+        config = JSON.parse(fs.readFileSync(getOpenCodeConfigPath(), "utf8"));
     }
     catch {
         return false;
@@ -622,9 +629,22 @@ async function clearOpenCodeProxySettings(expectedBaseUrl) {
         return false;
     }
     config.provider = provider;
-    fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+    fs.writeFileSync(getOpenCodeConfigPath(), JSON.stringify(config, null, 2));
     return hadNeurolink;
 }
+/**
+ * Test-only export (CLAUDE.md rule 15 determinism exception). The OpenCode
+ * client writers resolve paths from the environment and are only reachable
+ * from `proxy start` / `proxy setup`, neither of which can be driven against a
+ * throwaway HOME without starting a real server. Consumed by
+ * test/continuous-test-suite-proxy.ts.
+ */
+export const __openCodeTestHooks = {
+    getOpenCodeConfigDir,
+    getOpenCodeConfigPath,
+    setOpenCodeProxySettings,
+    clearOpenCodeProxySettings,
+};
 // =============================================================================
 // CODEX (ChatGPT) AUTO-CONFIGURATION
 // =============================================================================
@@ -2709,9 +2729,10 @@ async function startProxyRuntime(params) {
                 (error instanceof Error ? error.message : String(error)));
         }
         try {
-            await setOpenCodeProxySettings(`${url}/v1`);
-            logger.always(chalk.green("  ✓ Auto-configured OpenCode settings"));
-            logger.always(chalk.dim("    Restart OpenCode to connect through proxy"));
+            if (await setOpenCodeProxySettings(`${url}/v1`)) {
+                logger.always(chalk.green("  ✓ Auto-configured OpenCode settings"));
+                logger.always(chalk.dim("    Restart OpenCode to connect through proxy"));
+            }
         }
         catch (error) {
             logger.debug("[proxy] Failed to auto-configure OpenCode: " +
@@ -4155,8 +4176,9 @@ export const proxySetupCommand = {
                 console.info(chalk.yellow(`  Set manually: ANTHROPIC_BASE_URL=${url}`));
             }
             try {
-                await setOpenCodeProxySettings(`${url}/v1`);
-                console.info(chalk.green("  ✓ OpenCode configured"));
+                if (await setOpenCodeProxySettings(`${url}/v1`)) {
+                    console.info(chalk.green("  ✓ OpenCode configured"));
+                }
             }
             catch (e) {
                 console.info(chalk.yellow(`  ⚠ Could not auto-configure OpenCode: ${e instanceof Error ? e.message : String(e)}`));

package/dist/lib/providers/googleAiStudio/client.js

@@ -17,7 +17,7 @@ import { withTimeout } from "../../utils/async/index.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
-import { buildGeminiResponseSchema, buildNativeConfig, collectStreamChunks, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { buildGeminiResponseSchema, buildNativeConfig, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, } from "../googleNativeGemini3/index.js";
 import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
@@ -1004,8 +1004,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 });
                 // Convert tools (a0269210: trust options.tools — already merged + filtered upstream)
                 let toolsConfig;
-                let executeMap = new DedupExecuteMap();
-                let originalNameMap = new Map();
                 let declarationsResult;
                 const shouldUseTools = !options.disableTools;
                 // Structured output (JSON format or schema) is incompatible with
@@ -1032,8 +1030,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         const result = toNativeToolDeclarations(tools, "functionDeclarations");
                         declarationsResult = result;
                         toolsConfig = result.toolsConfig;
-                        executeMap = result.executeMap;
-                        originalNameMap = result.originalNameMap;
                         logger.debug("[GoogleAIStudio] Converted tools for native SDK generate", {
                             toolCount: toolsConfig[0].functionDeclarations.length,
                             toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
@@ -1066,114 +1062,128 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 const allToolCalls = [];
                 const toolExecutions = [];
                 let step = 0;
-                const failedTools = new Map();
                 // Cheap reclaim trigger — see the stream twin.
                 const contextGuard = createContextGuard(getContextWindowSize("googleAiStudio", modelName));
                 // Agentic loop for tool calling
-                while (step < maxSteps) {
-                    // In-turn context guard — see the stream twin.
-                    if (step === 0 || contextGuard.shouldStop()) {
-                        if (reclaimAiStudioContext(currentContents, modelName, contextGuard.projectedNextPromptTokens)) {
-                            contextGuard.resetAfterReclaim();
+                // Same shared engine as the streaming twin. This path has no
+                // consumer channel — generate() returns one result rather than
+                // streaming — so the engine's stream is drained and discarded, and
+                // the turn's text comes from the result.
+                const baseAdapter = createGeminiLoopAdapter({
+                    providerLabel: "GoogleAIStudio",
+                    maxSteps,
+                    toolFailureBreaker: { maxRetries: DEFAULT_TOOL_MAX_RETRIES },
+                    liveTools: options.tools ?? {},
+                    ...(declarationsResult ? { declarations: declarationsResult } : {}),
+                    buildRequest: (contents) => ({
+                        model: modelName,
+                        contents,
+                        config,
+                        ...(composedSignal
+                            ? { httpOptions: { signal: composedSignal } }
+                            : {}),
+                    }),
+                    sendStep: async (request) => client.models.generateContentStream(request),
+                    noteUsage: (inputTokens, outputTokens) => {
+                        contextGuard.noteUsage(inputTokens, outputTokens);
+                    },
+                    planReclaim: (contents, stepIndex) => {
+                        if (stepIndex !== 0 && !contextGuard.shouldStop()) {
+                            return undefined;
                         }
-                    }
-                    if (composedSignal?.aborted) {
-                        throw composedSignal.reason instanceof Error
-                            ? composedSignal.reason
-                            : new Error("Request aborted");
-                    }
-                    step++;
-                    // Mid-turn discovery sync — see the stream twin.
-                    if (declarationsResult) {
-                        refreshNativeToolDeclarations(options.tools, declarationsResult);
-                    }
-                    logger.debug(`[GoogleAIStudio] Native SDK generate step ${step}/${maxSteps}`);
-                    try {
-                        const stream = await client.models.generateContentStream({
-                            model: modelName,
-                            contents: currentContents,
-                            config,
-                            ...(composedSignal
-                                ? { httpOptions: { signal: composedSignal } }
-                                : {}),
-                        });
-                        const chunkResult = await collectStreamChunks(stream);
-                        totalInputTokens += chunkResult.inputTokens;
-                        totalOutputTokens += chunkResult.outputTokens;
-                        totalCacheReadTokens += chunkResult.cacheReadTokens ?? 0;
-                        totalReasoningTokens += chunkResult.reasoningTokens ?? 0;
-                        contextGuard.noteUsage(chunkResult.inputTokens, chunkResult.outputTokens);
-                        const stepText = extractTextFromParts(chunkResult.rawResponseParts);
-                        // If no function calls, we're done
-                        if (chunkResult.stepFunctionCalls.length === 0) {
-                            finalText = stepText;
-                            break;
+                        const working = [...contents];
+                        if (!reclaimAiStudioContext(working, modelName, contextGuard.projectedNextPromptTokens)) {
+                            return undefined;
                         }
-                        lastStepText = stepText;
-                        // Record tool call events on the span
-                        for (const fc of chunkResult.stepFunctionCalls) {
+                        contextGuard.resetAfterReclaim();
+                        return working;
+                    },
+                });
+                const adapter = {
+                    ...baseAdapter,
+                    buildToolResultMessages: (contents, stepResult, toolResults) => {
+                        step++;
+                        for (const call of stepResult.toolCalls) {
                             span.addEvent("gen_ai.tool_call", {
-                                "tool.name": fc.name,
+                                "tool.name": call.name,
                                 "tool.step": step,
                             });
+                            allToolCalls.push({ toolName: call.name, args: call.args });
                         }
-                        logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls in generate`);
-                        // 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,
-                            liveTools: options.tools,
-                            declarations: declarationsResult,
-                        });
-                        // 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,
+                        lastStepText = stepResult.text || lastStepText;
+                        for (const result of toolResults) {
+                            toolExecutions.push({
+                                name: result.name,
+                                input: result.args,
+                                output: result.output,
+                            });
+                        }
+                        if (toolResults.length > 0) {
+                            const stepThoughtSig = extractThoughtSignature(stepResult.raw.rawResponseParts);
+                            withTimeout(this.handleToolExecutionStorage(stepResult.toolCalls.map((call, i) => ({
+                                toolName: call.name,
+                                args: call.args,
                                 ...(i === 0 && stepThoughtSig
                                     ? { thoughtSignature: stepThoughtSig }
                                     : {}),
                                 stepIndex: step,
-                            })), stepToolExecs.map((te) => ({
-                                toolName: te.name,
-                                output: te.output,
+                            })), toolResults.map((result) => ({
+                                toolName: result.name,
+                                output: result.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", {
+                                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
-                        // SDK's own automaticFunctionCalling implementation).
-                        currentContents.push({
-                            role: "user",
-                            parts: functionResponses,
-                        });
-                        // Project this step's growth: the appended tool results ride
-                        // the next prompt, which the provider has not reported on yet.
+                        const next = baseAdapter.buildToolResultMessages(contents, stepResult, toolResults);
                         try {
-                            contextGuard.noteAppendedChars(JSON.stringify(functionResponses).length);
+                            const appended = next[next.length - 1];
+                            contextGuard.noteAppendedChars(JSON.stringify(appended?.parts ?? []).length);
                         }
                         catch {
                             /* estimation is best-effort — never break the loop */
                         }
+                        return next;
+                    },
+                };
+                const engineTools = {};
+                for (const [name, tool] of Object.entries(options.tools ?? {})) {
+                    const execute = tool?.execute;
+                    if (!execute) {
+                        continue;
                     }
-                    catch (error) {
-                        logger.error("[GoogleAIStudio] Native SDK generate error", error);
-                        throw this.handleProviderError(error);
+                    engineTools[name] = {
+                        execute: async (args, opts) => execute(args, opts),
+                    };
+                }
+                const { stream: engineStream, resultPromise } = runAgenticLoop(adapter, currentContents, {
+                    tools: engineTools,
+                    ...(composedSignal ? { abortSignal: composedSignal } : {}),
+                });
+                // Drained, not consumed: nothing streams out of generate(), but an
+                // undrained channel would stall the engine mid-turn.
+                const drain = (async () => {
+                    for await (const chunk of engineStream) {
+                        void chunk;
                     }
+                })();
+                let engineResult;
+                try {
+                    engineResult = await resultPromise;
+                }
+                catch (error) {
+                    await drain.catch(() => { });
+                    logger.error("[GoogleAIStudio] Native SDK generate error", error);
+                    throw this.handleProviderError(error);
                 }
+                await drain;
+                totalInputTokens += engineResult.usage.inputTokens;
+                totalOutputTokens += engineResult.usage.outputTokens;
+                totalCacheReadTokens += engineResult.usage.cacheReadTokens ?? 0;
+                totalReasoningTokens += engineResult.usage.reasoningTokens ?? 0;
+                finalText = engineResult.text;
                 finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
                 const responseTime = Date.now() - startTime;
                 // Set token usage and finish reason on the span

package/dist/providers/googleAiStudio/client.js

@@ -17,7 +17,7 @@ import { withTimeout } from "../../utils/async/index.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
-import { buildGeminiResponseSchema, buildNativeConfig, collectStreamChunks, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { buildGeminiResponseSchema, buildNativeConfig, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, } from "../googleNativeGemini3/index.js";
 import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
@@ -1004,8 +1004,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 });
                 // Convert tools (a0269210: trust options.tools — already merged + filtered upstream)
                 let toolsConfig;
-                let executeMap = new DedupExecuteMap();
-                let originalNameMap = new Map();
                 let declarationsResult;
                 const shouldUseTools = !options.disableTools;
                 // Structured output (JSON format or schema) is incompatible with
@@ -1032,8 +1030,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
                         const result = toNativeToolDeclarations(tools, "functionDeclarations");
                         declarationsResult = result;
                         toolsConfig = result.toolsConfig;
-                        executeMap = result.executeMap;
-                        originalNameMap = result.originalNameMap;
                         logger.debug("[GoogleAIStudio] Converted tools for native SDK generate", {
                             toolCount: toolsConfig[0].functionDeclarations.length,
                             toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
@@ -1066,114 +1062,128 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 const allToolCalls = [];
                 const toolExecutions = [];
                 let step = 0;
-                const failedTools = new Map();
                 // Cheap reclaim trigger — see the stream twin.
                 const contextGuard = createContextGuard(getContextWindowSize("googleAiStudio", modelName));
                 // Agentic loop for tool calling
-                while (step < maxSteps) {
-                    // In-turn context guard — see the stream twin.
-                    if (step === 0 || contextGuard.shouldStop()) {
-                        if (reclaimAiStudioContext(currentContents, modelName, contextGuard.projectedNextPromptTokens)) {
-                            contextGuard.resetAfterReclaim();
+                // Same shared engine as the streaming twin. This path has no
+                // consumer channel — generate() returns one result rather than
+                // streaming — so the engine's stream is drained and discarded, and
+                // the turn's text comes from the result.
+                const baseAdapter = createGeminiLoopAdapter({
+                    providerLabel: "GoogleAIStudio",
+                    maxSteps,
+                    toolFailureBreaker: { maxRetries: DEFAULT_TOOL_MAX_RETRIES },
+                    liveTools: options.tools ?? {},
+                    ...(declarationsResult ? { declarations: declarationsResult } : {}),
+                    buildRequest: (contents) => ({
+                        model: modelName,
+                        contents,
+                        config,
+                        ...(composedSignal
+                            ? { httpOptions: { signal: composedSignal } }
+                            : {}),
+                    }),
+                    sendStep: async (request) => client.models.generateContentStream(request),
+                    noteUsage: (inputTokens, outputTokens) => {
+                        contextGuard.noteUsage(inputTokens, outputTokens);
+                    },
+                    planReclaim: (contents, stepIndex) => {
+                        if (stepIndex !== 0 && !contextGuard.shouldStop()) {
+                            return undefined;
                         }
-                    }
-                    if (composedSignal?.aborted) {
-                        throw composedSignal.reason instanceof Error
-                            ? composedSignal.reason
-                            : new Error("Request aborted");
-                    }
-                    step++;
-                    // Mid-turn discovery sync — see the stream twin.
-                    if (declarationsResult) {
-                        refreshNativeToolDeclarations(options.tools, declarationsResult);
-                    }
-                    logger.debug(`[GoogleAIStudio] Native SDK generate step ${step}/${maxSteps}`);
-                    try {
-                        const stream = await client.models.generateContentStream({
-                            model: modelName,
-                            contents: currentContents,
-                            config,
-                            ...(composedSignal
-                                ? { httpOptions: { signal: composedSignal } }
-                                : {}),
-                        });
-                        const chunkResult = await collectStreamChunks(stream);
-                        totalInputTokens += chunkResult.inputTokens;
-                        totalOutputTokens += chunkResult.outputTokens;
-                        totalCacheReadTokens += chunkResult.cacheReadTokens ?? 0;
-                        totalReasoningTokens += chunkResult.reasoningTokens ?? 0;
-                        contextGuard.noteUsage(chunkResult.inputTokens, chunkResult.outputTokens);
-                        const stepText = extractTextFromParts(chunkResult.rawResponseParts);
-                        // If no function calls, we're done
-                        if (chunkResult.stepFunctionCalls.length === 0) {
-                            finalText = stepText;
-                            break;
+                        const working = [...contents];
+                        if (!reclaimAiStudioContext(working, modelName, contextGuard.projectedNextPromptTokens)) {
+                            return undefined;
                         }
-                        lastStepText = stepText;
-                        // Record tool call events on the span
-                        for (const fc of chunkResult.stepFunctionCalls) {
+                        contextGuard.resetAfterReclaim();
+                        return working;
+                    },
+                });
+                const adapter = {
+                    ...baseAdapter,
+                    buildToolResultMessages: (contents, stepResult, toolResults) => {
+                        step++;
+                        for (const call of stepResult.toolCalls) {
                             span.addEvent("gen_ai.tool_call", {
-                                "tool.name": fc.name,
+                                "tool.name": call.name,
                                 "tool.step": step,
                             });
+                            allToolCalls.push({ toolName: call.name, args: call.args });
                         }
-                        logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls in generate`);
-                        // 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,
-                            liveTools: options.tools,
-                            declarations: declarationsResult,
-                        });
-                        // 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,
+                        lastStepText = stepResult.text || lastStepText;
+                        for (const result of toolResults) {
+                            toolExecutions.push({
+                                name: result.name,
+                                input: result.args,
+                                output: result.output,
+                            });
+                        }
+                        if (toolResults.length > 0) {
+                            const stepThoughtSig = extractThoughtSignature(stepResult.raw.rawResponseParts);
+                            withTimeout(this.handleToolExecutionStorage(stepResult.toolCalls.map((call, i) => ({
+                                toolName: call.name,
+                                args: call.args,
                                 ...(i === 0 && stepThoughtSig
                                     ? { thoughtSignature: stepThoughtSig }
                                     : {}),
                                 stepIndex: step,
-                            })), stepToolExecs.map((te) => ({
-                                toolName: te.name,
-                                output: te.output,
+                            })), toolResults.map((result) => ({
+                                toolName: result.name,
+                                output: result.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", {
+                                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
-                        // SDK's own automaticFunctionCalling implementation).
-                        currentContents.push({
-                            role: "user",
-                            parts: functionResponses,
-                        });
-                        // Project this step's growth: the appended tool results ride
-                        // the next prompt, which the provider has not reported on yet.
+                        const next = baseAdapter.buildToolResultMessages(contents, stepResult, toolResults);
                         try {
-                            contextGuard.noteAppendedChars(JSON.stringify(functionResponses).length);
+                            const appended = next[next.length - 1];
+                            contextGuard.noteAppendedChars(JSON.stringify(appended?.parts ?? []).length);
                         }
                         catch {
                             /* estimation is best-effort — never break the loop */
                         }
+                        return next;
+                    },
+                };
+                const engineTools = {};
+                for (const [name, tool] of Object.entries(options.tools ?? {})) {
+                    const execute = tool?.execute;
+                    if (!execute) {
+                        continue;
                     }
-                    catch (error) {
-                        logger.error("[GoogleAIStudio] Native SDK generate error", error);
-                        throw this.handleProviderError(error);
+                    engineTools[name] = {
+                        execute: async (args, opts) => execute(args, opts),
+                    };
+                }
+                const { stream: engineStream, resultPromise } = runAgenticLoop(adapter, currentContents, {
+                    tools: engineTools,
+                    ...(composedSignal ? { abortSignal: composedSignal } : {}),
+                });
+                // Drained, not consumed: nothing streams out of generate(), but an
+                // undrained channel would stall the engine mid-turn.
+                const drain = (async () => {
+                    for await (const chunk of engineStream) {
+                        void chunk;
                     }
+                })();
+                let engineResult;
+                try {
+                    engineResult = await resultPromise;
+                }
+                catch (error) {
+                    await drain.catch(() => { });
+                    logger.error("[GoogleAIStudio] Native SDK generate error", error);
+                    throw this.handleProviderError(error);
                 }
+                await drain;
+                totalInputTokens += engineResult.usage.inputTokens;
+                totalOutputTokens += engineResult.usage.outputTokens;
+                totalCacheReadTokens += engineResult.usage.cacheReadTokens ?? 0;
+                totalReasoningTokens += engineResult.usage.reasoningTokens ?? 0;
+                finalText = engineResult.text;
                 finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
                 const responseTime = Date.now() - startTime;
                 // Set token usage and finish reason on the span

package/package.json

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