@juspay/neurolink 9.26.0 → 9.26.2

package/dist/providers/googleVertex.js

@@ -1,8 +1,8 @@
+import dns from "node:dns";
 import { createVertex, } from "@ai-sdk/google-vertex";
 import { createVertexAnthropic, } from "@ai-sdk/google-vertex/anthropic";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { embed, embedMany, Output, streamText, } from "ai";
-import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-import dns from "node:dns";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -11,18 +11,18 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS, GLOBAL_LOCATION_MODELS, } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { AuthenticationError, NetworkError, ProviderError, RateLimitError, InvalidModelError, } from "../types/errors.js";
+import { ATTR, tracers, withClientSpan } from "../telemetry/index.js";
+import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
 import { FileDetector } from "../utils/fileDetector.js";
 import { logger } from "../utils/logger.js";
-import { estimateTokens } from "../utils/tokenEstimation.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
 import { calculateCost } from "../utils/pricing.js";
-import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
 import { createGoogleAuthConfig, createVertexProjectConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { buildNativeToolDeclarations, buildNativeConfig, computeMaxSteps as computeMaxStepsShared, collectStreamChunks, extractTextFromParts, executeNativeToolCalls, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
+import { estimateTokens } from "../utils/tokenEstimation.js";
+import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 // Import proper types for multimodal message handling
 // Keep-alive note: Node.js native fetch and undici (used by createProxyFetch)
 // handle HTTP keep-alive internally. The fetchWithRetry wrapper in proxyFetch.ts
@@ -1217,15 +1217,13 @@ export class GoogleVertexProvider extends BaseProvider {
                     toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
                 });
             }
-            // Build config
+            // Build config — systemInstruction stays in config for Gemini 3.x.
+            // The @google/genai SDK maps config.systemInstruction to the HTTP-level
+            // system_instruction field, which is the correct mechanism for all
+            // Gemini 3.x models (including global endpoint).  Older workaround
+            // that moved systemInstruction into user/model content messages caused
+            // "Please use a valid role: user, model" on Gemini 3.1+ preview models.
             const config = buildNativeConfig(options, toolsConfig);
-            // Global endpoint rejects systemInstruction for Gemini 3.x —
-            // move it into a prefixed user message (same fix as generate path)
-            let streamSystemPreamble;
-            if (effectiveLocation === "global" && config.systemInstruction) {
-                streamSystemPreamble = config.systemInstruction;
-                delete config.systemInstruction;
-            }
             // Add JSON output format support for native SDK stream
             if (streamOptions.output?.format === "json" || streamOptions.schema) {
                 config.responseMimeType = "application/json";
@@ -1247,110 +1245,146 @@ export class GoogleVertexProvider extends BaseProvider {
             const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
             const maxSteps = computeMaxStepsShared(options.maxSteps);
             // Inject conversation history so the native path has multi-turn context
-            let currentContents = this.prependConversationHistory([...contents], options.conversationMessages);
-            // Prepend system prompt as a user message for the global endpoint
-            if (streamSystemPreamble) {
-                currentContents = [
-                    {
-                        role: "user",
-                        parts: [
-                            { text: `[System Instructions]\n${streamSystemPreamble}` },
-                        ],
-                    },
-                    {
-                        role: "model",
-                        parts: [{ text: "OK" }],
-                    },
-                    ...currentContents,
-                ];
-            }
-            let finalText = "";
-            let lastStepText = "";
-            let totalInputTokens = 0;
-            let totalOutputTokens = 0;
+            const currentContents = this.prependConversationHistory([...contents], options.conversationMessages);
+            // Create a push-based text channel so the caller receives tokens as
+            // they arrive from the network rather than after full buffering.
+            const channel = createTextChannel();
+            // Shared mutable state updated by the background agentic loop.
             const allToolCalls = [];
-            let step = 0;
-            const failedTools = new Map();
-            // Agentic loop for tool calling
-            try {
-                while (step < maxSteps) {
-                    if (timeoutController?.controller.signal.aborted) {
-                        break;
-                    }
-                    step++;
-                    logger.debug(`[GoogleVertex] Native SDK 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;
-                        const stepText = extractTextFromParts(chunkResult.rawResponseParts);
-                        if (chunkResult.stepFunctionCalls.length === 0) {
-                            finalText = stepText;
-                            break;
+            // Shared metadata object mutated by the background loop so that
+            // responseTime and totalToolExecutions reflect final values.
+            const metadata = {
+                streamId: `native-vertex-${Date.now()}`,
+                startTime,
+                responseTime: 0,
+                totalToolExecutions: 0,
+            };
+            // analyticsResolvers lets the background loop settle the analytics
+            // promise once token counts are known (after the loop completes).
+            let analyticsResolve;
+            let analyticsReject;
+            const analyticsPromise = new Promise((res, rej) => {
+                analyticsResolve = res;
+                analyticsReject = rej;
+            });
+            // Run the agentic loop in the background without awaiting it here,
+            // so we can return the StreamResult (with channel.iterable) immediately.
+            const loopPromise = (async () => {
+                let lastStepText = "";
+                let totalInputTokens = 0;
+                let totalOutputTokens = 0;
+                let step = 0;
+                let completedWithFinalAnswer = false;
+                const failedTools = new Map();
+                try {
+                    // Agentic loop for tool calling
+                    while (step < maxSteps) {
+                        if (composedSignal?.aborted) {
+                            throw composedSignal.reason instanceof Error
+                                ? composedSignal.reason
+                                : new Error("Request aborted");
                         }
-                        lastStepText = stepText;
-                        // Record tool call events on the span
-                        for (const fc of chunkResult.stepFunctionCalls) {
-                            span.addEvent("gen_ai.tool_call", {
-                                "tool.name": fc.name,
-                                "tool.step": step,
+                        step++;
+                        logger.debug(`[GoogleVertex] Native SDK step ${step}/${maxSteps}`);
+                        try {
+                            const rawStream = await client.models.generateContentStream({
+                                model: modelName,
+                                contents: currentContents,
+                                config,
+                                ...(composedSignal
+                                    ? { httpOptions: { signal: composedSignal } }
+                                    : {}),
+                            });
+                            // For every step, use incremental collection so text parts
+                            // are pushed to the channel as they arrive.  For intermediate
+                            // steps (those that produce function calls) we still need the
+                            // complete rawResponseParts for pushModelResponseToHistory,
+                            // which collectStreamChunksIncremental provides at stream end.
+                            const chunkResult = await collectStreamChunksIncremental(rawStream, channel);
+                            totalInputTokens += chunkResult.inputTokens;
+                            totalOutputTokens += chunkResult.outputTokens;
+                            const stepText = extractTextFromParts(chunkResult.rawResponseParts);
+                            // If no function calls, this was the final step — channel
+                            // already received all text parts incrementally.
+                            if (chunkResult.stepFunctionCalls.length === 0) {
+                                completedWithFinalAnswer = true;
+                                break;
+                            }
+                            lastStepText = stepText;
+                            // Record tool call events on the span
+                            for (const fc of chunkResult.stepFunctionCalls) {
+                                span.addEvent("gen_ai.tool_call", {
+                                    "tool.name": fc.name,
+                                    "tool.step": step,
+                                });
+                            }
+                            logger.debug(`[GoogleVertex] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
+                            pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                            const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal });
+                            // Function/tool responses must use role: "user" — the
+                            // @google/genai SDK's validateHistory() only accepts "user"
+                            // and "model" roles (matching automaticFunctionCalling).
+                            currentContents.push({
+                                role: "user",
+                                parts: functionResponses,
                             });
                         }
-                        logger.debug(`[GoogleVertex] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
-                        pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                        const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal });
-                        // Add function responses to history
-                        currentContents.push({
-                            role: "function",
-                            parts: functionResponses,
-                        });
+                        catch (error) {
+                            logger.error("[GoogleVertex] Native SDK error", error);
+                            throw this.handleProviderError(error);
+                        }
                     }
-                    catch (error) {
-                        logger.error("[GoogleVertex] Native SDK error", error);
-                        throw this.handleProviderError(error);
+                    // Handle max-steps termination: if the model was still calling
+                    // tools when we hit the limit, push a synthetic final message.
+                    if (step >= maxSteps && !completedWithFinalAnswer) {
+                        const fallback = handleMaxStepsTermination("[GoogleVertex]", step, maxSteps, "", // finalText is empty — model didn't stop on its own
+                        lastStepText);
+                        if (fallback) {
+                            channel.push(fallback);
+                        }
                     }
+                    const responseTime = Date.now() - startTime;
+                    // Propagate final values to the shared metadata object so that
+                    // the already-returned StreamResult reflects accurate telemetry.
+                    metadata.responseTime = responseTime;
+                    metadata.totalToolExecutions = allToolCalls.length;
+                    // Set token usage and finish reason on the span
+                    span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
+                    span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
+                    span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= maxSteps && !completedWithFinalAnswer
+                        ? "max_steps"
+                        : "stop");
+                    analyticsResolve({
+                        provider: this.providerName,
+                        model: modelName,
+                        tokenUsage: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        },
+                        requestDuration: responseTime,
+                        timestamp: new Date().toISOString(),
+                    });
+                    channel.close();
                 }
-            }
-            finally {
-                timeoutController?.cleanup();
-            }
-            finalText = handleMaxStepsTermination("[GoogleVertex]", step, maxSteps, finalText, lastStepText);
-            const responseTime = Date.now() - startTime;
-            // Set token usage and finish reason on the span
-            span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
-            span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
-            span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= maxSteps ? "max_steps" : "stop");
-            // Create async iterable for streaming result
-            async function* createTextStream() {
-                yield { content: finalText };
-            }
+                catch (err) {
+                    channel.error(err);
+                    analyticsReject(err);
+                }
+                finally {
+                    timeoutController?.cleanup();
+                }
+            })();
+            // Suppress unhandled-rejection warnings on loopPromise — errors are
+            // forwarded to the channel and will surface when the caller iterates.
+            loopPromise.catch(() => undefined);
             return {
-                stream: createTextStream(),
+                stream: channel.iterable,
                 provider: this.providerName,
                 model: modelName,
-                usage: {
-                    input: totalInputTokens,
-                    output: totalOutputTokens,
-                    total: totalInputTokens + totalOutputTokens,
-                },
-                toolCalls: allToolCalls.map((tc) => ({
-                    toolName: tc.toolName,
-                    args: tc.args,
-                })),
-                metadata: {
-                    streamId: `native-vertex-${Date.now()}`,
-                    startTime,
-                    responseTime,
-                    totalToolExecutions: allToolCalls.length,
-                },
+                toolCalls: allToolCalls,
+                analytics: analyticsPromise,
+                metadata,
             };
         });
     }
@@ -1378,7 +1412,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 location: effectiveLocation,
             });
             // Build contents from input with multimodal support
-            const inputText = options.prompt || options.input?.text || "Please respond.";
+            // Prefer input.text over prompt — processCSVFilesForNativeSDK enriches
+            // input.text with inlined CSV data, so using prompt first would discard it.
+            const inputText = options.input?.text || options.prompt || "Please respond.";
             const multimodalInput = options.input;
             const contents = this.buildNativeContentParts(inputText, multimodalInput, "native generate");
             // Get tools from SDK and options
@@ -1404,16 +1440,9 @@ export class GoogleVertexProvider extends BaseProvider {
                     toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
                 });
             }
-            // Build config
+            // Build config — systemInstruction stays in config for Gemini 3.x.
+            // See stream path comment for rationale.
             const config = buildNativeConfig(options, toolsConfig);
-            // Global endpoint rejects systemInstruction for Gemini 3.x, returning
-            // "Please use a valid role: user, model." Move it into a prefixed
-            // user message so the model still receives the system context.
-            let systemPreamble;
-            if (effectiveLocation === "global" && config.systemInstruction) {
-                systemPreamble = config.systemInstruction;
-                delete config.systemInstruction;
-            }
             // 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
@@ -1423,21 +1452,7 @@ export class GoogleVertexProvider extends BaseProvider {
             const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
             const maxSteps = computeMaxStepsShared(options.maxSteps);
             // Inject conversation history so the native path has multi-turn context
-            let currentContents = this.prependConversationHistory([...contents], options.conversationMessages);
-            // Prepend system prompt as a user message for the global endpoint
-            if (systemPreamble) {
-                currentContents = [
-                    {
-                        role: "user",
-                        parts: [{ text: `[System Instructions]\n${systemPreamble}` }],
-                    },
-                    {
-                        role: "model",
-                        parts: [{ text: "OK" }],
-                    },
-                    ...currentContents,
-                ];
-            }
+            const currentContents = this.prependConversationHistory([...contents], options.conversationMessages);
             let finalText = "";
             let lastStepText = "";
             let totalInputTokens = 0;
@@ -1449,8 +1464,10 @@ export class GoogleVertexProvider extends BaseProvider {
             try {
                 // Agentic loop for tool calling
                 while (step < maxSteps) {
-                    if (timeoutController?.controller.signal.aborted) {
-                        break;
+                    if (composedSignal?.aborted) {
+                        throw composedSignal.reason instanceof Error
+                            ? composedSignal.reason
+                            : new Error("Request aborted");
                     }
                     step++;
                     logger.debug(`[GoogleVertex] Native SDK generate step ${step}/${maxSteps}`);
@@ -1483,9 +1500,11 @@ export class GoogleVertexProvider extends BaseProvider {
                         logger.debug(`[GoogleVertex] Generate executing ${chunkResult.stepFunctionCalls.length} function calls`);
                         pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
                         const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { toolExecutions, abortSignal: composedSignal });
-                        // Add function responses to history
+                        // Function/tool responses must use role: "user" — the
+                        // @google/genai SDK's validateHistory() only accepts "user"
+                        // and "model" roles (matching automaticFunctionCalling).
                         currentContents.push({
-                            role: "function",
+                            role: "user",
                             parts: functionResponses,
                         });
                     }
@@ -1598,13 +1617,16 @@ export class GoogleVertexProvider extends BaseProvider {
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
         const modelName = this.resolveAlias(options.model || this.modelName || getDefaultVertexModel());
+        // Structured output (JSON format or schema) is incompatible with tools on Gemini.
+        // Mirror the stream path pattern to prevent silent downgrade on the generate path.
+        const wantsStructuredOutput = options.output?.format === "json" || !!options.schema;
         // Check if we should use native SDK for Gemini 3 with tools
-        const shouldUseTools = !options.disableTools && this.supportsTools();
+        const shouldUseTools = !options.disableTools && this.supportsTools() && !wantsStructuredOutput;
         const sdkTools = shouldUseTools ? await this.getAllTools() : {};
         const hasTools = shouldUseTools &&
             (Object.keys(sdkTools).length > 0 ||
                 (options.tools && Object.keys(options.tools).length > 0));
-        if (isGemini3Model(modelName) && hasTools) {
+        if (isGemini3Model(modelName) && hasTools && !wantsStructuredOutput) {
             // Process CSV files before routing to native SDK (bypasses normal message builder)
             const processedOptions = await this.processCSVFilesForNativeSDK(options);
             // Merge SDK tools into options for native SDK path
@@ -2434,7 +2456,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 if (!isRetryable || attempt === maxRetries) {
                     throw error;
                 }
-                const delay = baseDelay * Math.pow(2, attempt - 1);
+                const delay = baseDelay * 2 ** (attempt - 1);
                 logger.warn(`[GoogleVertexProvider] Auth token transient error (${err?.code || err?.message}), retrying in ${delay}ms (attempt ${attempt}/${maxRetries})`);
                 await new Promise((r) => setTimeout(r, delay));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.26.0",
+  "version": "9.26.2",
   "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": {
     "name": "Juspay Technologies",
@@ -59,22 +59,23 @@
     "// Shell Script Conversion": "",
     "convert:shell-scripts": "tsx tools/automation/shellConverter.ts",
     "convert:specific": "tsx tools/automation/shellConverter.ts --specific",
-    "// Testing (Enhanced Vitest Framework)": "",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage",
-    "test:providers": "vitest run test/unit/providers",
-    "test:cli": "vitest run test/integration/cli",
-    "test:sdk": "vitest run test/unit/sdk",
-    "test:integration": "vitest run test/integration",
-    "test:e2e": "vitest run test/e2e",
-    "test:ci": "vitest run --coverage --reporter=junit --reporter=verbose",
-    "test:debug": "vitest --inspect-brk",
+    "// Testing (Continuous Test Suites)": "",
+    "test": "npx tsx test/continuous-test-suite.ts",
+    "test:context": "npx tsx test/continuous-test-suite-context.ts",
+    "test:evaluation": "npx tsx test/continuous-test-suite-evaluation.ts",
+    "test:mcp": "npx tsx test/continuous-test-suite-mcp-http.ts",
+    "test:media": "npx tsx test/continuous-test-suite-media-gen.ts",
+    "test:memory": "npx tsx test/continuous-test-suite-memory.ts",
+    "test:observability": "npx tsx test/continuous-test-suite-observability.ts",
+    "test:ppt": "npx tsx test/continuous-test-suite-ppt.ts",
+    "test:providers": "npx tsx test/continuous-test-suite-providers.ts",
+    "test:rag": "npx tsx test/continuous-test-suite-rag.ts",
+    "test:servers": "npx tsx test/continuous-test-suite-servers.ts",
+    "test:tracing": "npx tsx test/continuous-test-suite-tracing.ts",
+    "test:tts": "npx tsx test/continuous-test-suite-tts.ts",
+    "test:workflow": "npx tsx test/continuous-test-suite-workflow.ts",
+    "test:ci": "pnpm run test",
     "test:performance": "tsx tools/testing/performanceMonitor.ts",
-    "// Legacy Testing Support (during transition)": "",
-    "test:legacy": "npx tsx test/continuous-test-suite.ts",
-    "test:comparison": "pnpm run test && pnpm run test:legacy",
     "// Content Generation (Cross-platform JS)": "",
     "content:videos": "tsx tools/converted-scripts/generateAllVideos.ts",
     "content:cleanup": "tsx tools/converted-scripts/cleanupHashNamedVideos.ts",
@@ -116,7 +117,7 @@
     "quality:metrics": "tsx scripts/quality-metrics.ts",
     "quality:report": "pnpm run quality:metrics && echo 'Quality metrics saved to quality-metrics.json'",
     "pre-commit": "lint-staged",
-    "pre-push": "pnpm run validate:commit && pnpm run validate:env && pnpm run validate && pnpm run test",
+    "pre-push": "pnpm run validate:commit && pnpm run validate:env && pnpm run validate && pnpm run test:ci",
     "check:all": "pnpm run lint && pnpm run format --check && pnpm run validate && pnpm run validate:commit"
   },
   "files": [