@juspay/neurolink 9.26.1 → 9.26.2

package/dist/providers/googleAiStudio.js

@@ -11,7 +11,7 @@ import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
-import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, computeMaxSteps, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
+import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
@@ -578,107 +578,151 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 }
                 const config = buildNativeConfig(options, toolsConfig);
                 const maxSteps = computeMaxSteps(options.maxSteps);
-                let finalText = "";
-                let lastStepText = "";
-                let totalInputTokens = 0;
-                let totalOutputTokens = 0;
-                const allToolCalls = [];
-                let step = 0;
-                const failedTools = new Map();
                 // Compose abort signal from user signal + timeout
                 const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
-                // Agentic loop for tool calling
-                while (step < maxSteps) {
-                    if (composedSignal?.aborted) {
-                        throw composedSignal.reason instanceof Error
-                            ? composedSignal.reason
-                            : new Error("Request aborted");
-                    }
-                    step++;
-                    logger.debug(`[GoogleAIStudio] Native SDK step ${step}/${maxSteps}`);
+                // 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 = [];
+                // 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;
+                });
+                // Shared metadata object mutated by the background loop so the
+                // returned object reflects the final values after stream completion.
+                const metadata = {
+                    streamId: `native-${Date.now()}`,
+                    startTime,
+                    responseTime: 0,
+                    totalToolExecutions: 0,
+                };
+                // 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 {
-                        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 no function calls, we're done
-                        if (chunkResult.stepFunctionCalls.length === 0) {
-                            finalText = stepText;
-                            break;
+                        // Agentic loop for tool calling
+                        while (step < maxSteps) {
+                            if (composedSignal?.aborted) {
+                                throw composedSignal.reason instanceof Error
+                                    ? composedSignal.reason
+                                    : new Error("Request aborted");
+                            }
+                            step++;
+                            logger.debug(`[GoogleAIStudio] 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(`[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 });
+                                // 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,
+                                });
+                            }
+                            catch (error) {
+                                logger.error("[GoogleAIStudio] Native SDK error", error);
+                                throw this.handleProviderError(error);
+                            }
                         }
-                        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,
-                            });
+                        // Handle max-steps termination: if the model was still calling
+                        // tools when we hit the limit, push a synthetic final message.
+                        const hitStepLimitWithoutFinalAnswer = step >= maxSteps && !completedWithFinalAnswer;
+                        if (hitStepLimitWithoutFinalAnswer) {
+                            const fallback = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, "", // finalText is empty — model didn't stop on its own
+                            lastStepText);
+                            if (fallback) {
+                                channel.push(fallback);
+                            }
                         }
-                        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 });
-                        // 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,
+                        const responseTime = Date.now() - startTime;
+                        // Update shared metadata so the returned object reflects final values.
+                        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, hitStepLimitWithoutFinalAnswer ? "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();
                     }
-                    catch (error) {
-                        logger.error("[GoogleAIStudio] Native SDK error", error);
-                        throw this.handleProviderError(error);
+                    catch (err) {
+                        channel.error(err);
+                        analyticsReject(err);
                     }
-                }
-                finalText = handleMaxStepsTermination("[GoogleAIStudio]", 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 };
-                }
+                    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,
-                    toolCalls: allToolCalls.map((tc) => ({
-                        toolName: tc.toolName,
-                        args: tc.args,
-                    })),
-                    analytics: Promise.resolve({
-                        provider: this.providerName,
-                        model: modelName,
-                        tokenUsage: {
-                            input: totalInputTokens,
-                            output: totalOutputTokens,
-                            total: totalInputTokens + totalOutputTokens,
-                        },
-                        requestDuration: responseTime,
-                        timestamp: new Date().toISOString(),
-                    }),
-                    metadata: {
-                        streamId: `native-${Date.now()}`,
-                        startTime,
-                        responseTime,
-                        totalToolExecutions: allToolCalls.length,
-                    },
+                    toolCalls: allToolCalls,
+                    analytics: analyticsPromise,
+                    metadata,
                 };
             }
             finally {
-                timeoutController?.cleanup();
+                // Timeout controller cleanup is managed inside the background loop
             }
         });
     }
@@ -709,7 +753,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     hasTools: !!options.tools && Object.keys(options.tools).length > 0,
                 });
                 // Build contents from input
-                const promptText = options.prompt || options.input?.text || "";
+                // Prefer input.text over prompt — processCSVFilesForNativeSDK enriches
+                // input.text with inlined CSV data, so using prompt first would discard it.
+                const promptText = options.input?.text || options.prompt || "";
                 const currentContents = [{ role: "user", parts: [{ text: promptText }] }];
                 // Convert tools (merge SDK tools with options.tools)
                 let toolsConfig;

package/dist/providers/googleNativeGemini3.d.ts

@@ -98,6 +98,49 @@ export declare function collectStreamChunks(stream: AsyncIterable<{
     functionCalls?: NativeFunctionCall[];
     [key: string]: unknown;
 }>): Promise<CollectedChunkResult>;
+/**
+ * A push-based text channel that decouples producers (agentic loop) from
+ * consumers (the caller's async iterable).
+ *
+ * The producer calls `push(text)` for each chunk and `close()` / `error(err)`
+ * when done.  The consumer iterates the `iterable` async generator.
+ */
+export type TextChannel = {
+    /** Push a text chunk to the consumer. */
+    push(text: string): void;
+    /** Signal that no more chunks will arrive. */
+    close(): void;
+    /** Signal that the producer encountered a fatal error. */
+    error(err: unknown): void;
+    /** Async iterable consumed by the StreamResult. */
+    iterable: AsyncIterable<{
+        content: string;
+    }>;
+};
+/**
+ * Create a push-based text channel that bridges a background producer
+ * (the agentic tool-calling loop) with an async-iterable consumer.
+ *
+ * This enables truly incremental streaming: text parts are yielded to the
+ * caller as they arrive from the network, rather than being buffered until
+ * the model finishes generating.
+ */
+export declare function createTextChannel(): TextChannel;
+/**
+ * Iterate a single stream step incrementally, pushing text parts to `channel`
+ * as they arrive from the network while simultaneously accumulating the full
+ * `CollectedChunkResult` needed for history and token accounting.
+ *
+ * Used for all steps (both intermediate tool-calling steps and the final
+ * text-only step).  Text parts are pushed to the channel as they arrive,
+ * enabling truly incremental streaming.  The complete `rawResponseParts`
+ * (including thoughtSignature) are still returned at the end for use by
+ * `pushModelResponseToHistory`.
+ */
+export declare function collectStreamChunksIncremental(stream: AsyncIterable<{
+    functionCalls?: NativeFunctionCall[];
+    [key: string]: unknown;
+}>, channel: TextChannel): Promise<CollectedChunkResult>;
 /**
  * Extract text from raw response parts, filtering out non-text parts
  * (thoughtSignature, functionCall) to avoid SDK warnings.

package/dist/providers/googleNativeGemini3.js

@@ -158,7 +158,6 @@ export function sanitizeToolsForGemini(tools) {
             logger.warn(`[Gemini] Failed to sanitize tool "${name}", skipping: ${error instanceof Error ? error.message : String(error)}`);
             // Don't fall back to the original tool — an incompatible schema would fail the Gemini request
             dropped.push(name);
-            continue;
         }
     }
     return { tools: sanitized, dropped };
@@ -171,29 +170,45 @@ export function sanitizeToolsForGemini(tools) {
 export function buildNativeToolDeclarations(tools) {
     const functionDeclarations = [];
     const executeMap = new Map();
+    const skippedTools = [];
     for (const [name, tool] of Object.entries(tools)) {
-        const decl = {
-            name,
-            description: tool.description || `Tool: ${name}`,
-        };
-        if (tool.parameters) {
-            let rawSchema;
-            if (isZodSchema(tool.parameters)) {
-                rawSchema = convertZodToJsonSchema(tool.parameters);
-            }
-            else if (typeof tool.parameters === "object") {
-                rawSchema = tool.parameters;
+        try {
+            const decl = {
+                name,
+                description: tool.description || `Tool: ${name}`,
+            };
+            if (tool.parameters) {
+                let rawSchema;
+                if (isZodSchema(tool.parameters)) {
+                    rawSchema = convertZodToJsonSchema(tool.parameters);
+                }
+                else if (typeof tool.parameters === "object") {
+                    rawSchema = tool.parameters;
+                }
+                else {
+                    rawSchema = { type: "object", properties: {} };
+                }
+                // Unwrap Vercel AI SDK's jsonSchema() wrapper: { jsonSchema: { type: "object", ... } }
+                if (rawSchema.jsonSchema &&
+                    typeof rawSchema.jsonSchema === "object" &&
+                    !rawSchema.type) {
+                    rawSchema = rawSchema.jsonSchema;
+                }
+                decl.parametersJsonSchema = sanitizeSchemaForGemini(inlineJsonSchema(rawSchema));
             }
-            else {
-                rawSchema = { type: "object", properties: {} };
+            functionDeclarations.push(decl);
+            if (tool.execute) {
+                executeMap.set(name, tool.execute);
             }
-            decl.parametersJsonSchema = sanitizeSchemaForGemini(inlineJsonSchema(rawSchema));
         }
-        functionDeclarations.push(decl);
-        if (tool.execute) {
-            executeMap.set(name, tool.execute);
+        catch (err) {
+            skippedTools.push(name);
+            logger.error(`[buildNativeToolDeclarations] Failed to convert tool "${name}":`, err);
         }
     }
+    if (skippedTools.length > 0) {
+        logger.warn(`[buildNativeToolDeclarations] ${skippedTools.length} tool(s) skipped due to schema errors: ${skippedTools.join(", ")}`);
+    }
     return { toolsConfig: [{ functionDeclarations }], executeMap };
 }
 /**
@@ -265,6 +280,121 @@ export async function collectStreamChunks(stream) {
     }
     return { rawResponseParts, stepFunctionCalls, inputTokens, outputTokens };
 }
+/**
+ * Create a push-based text channel that bridges a background producer
+ * (the agentic tool-calling loop) with an async-iterable consumer.
+ *
+ * This enables truly incremental streaming: text parts are yielded to the
+ * caller as they arrive from the network, rather than being buffered until
+ * the model finishes generating.
+ */
+export function createTextChannel() {
+    const queue = [];
+    let done = false;
+    let fatalError = undefined;
+    // Resolve the current "wait for data" promise when new data arrives
+    let notify = null;
+    function wake() {
+        if (notify) {
+            const fn = notify;
+            notify = null;
+            fn();
+        }
+    }
+    function push(text) {
+        if (done) {
+            return;
+        }
+        queue.push({ content: text });
+        wake();
+    }
+    function close() {
+        done = true;
+        wake();
+    }
+    function error(err) {
+        done = true;
+        fatalError = err;
+        wake();
+    }
+    let readIndex = 0;
+    async function* iterable() {
+        try {
+            while (true) {
+                if (readIndex < queue.length) {
+                    yield queue[readIndex++];
+                    // Periodically compact consumed chunks to avoid unbounded retention
+                    if (readIndex > 1024 && readIndex * 2 >= queue.length) {
+                        queue.splice(0, readIndex);
+                        readIndex = 0;
+                    }
+                }
+                else if (done) {
+                    if (fatalError !== undefined) {
+                        throw fatalError instanceof Error
+                            ? fatalError
+                            : new Error(String(fatalError));
+                    }
+                    return;
+                }
+                else {
+                    // Wait until the producer pushes data or signals completion
+                    await new Promise((resolve) => {
+                        notify = resolve;
+                    });
+                }
+            }
+        }
+        finally {
+            // Consumer stopped reading (e.g. disconnect/cancel): stop buffering.
+            done = true;
+            queue.length = 0;
+            notify?.();
+        }
+    }
+    return { push, close, error, iterable: iterable() };
+}
+/**
+ * Iterate a single stream step incrementally, pushing text parts to `channel`
+ * as they arrive from the network while simultaneously accumulating the full
+ * `CollectedChunkResult` needed for history and token accounting.
+ *
+ * Used for all steps (both intermediate tool-calling steps and the final
+ * text-only step).  Text parts are pushed to the channel as they arrive,
+ * enabling truly incremental streaming.  The complete `rawResponseParts`
+ * (including thoughtSignature) are still returned at the end for use by
+ * `pushModelResponseToHistory`.
+ */
+export async function collectStreamChunksIncremental(stream, channel) {
+    const rawResponseParts = [];
+    const stepFunctionCalls = [];
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for await (const chunk of stream) {
+        const chunkRecord = chunk;
+        const candidates = chunkRecord.candidates;
+        const firstCandidate = candidates?.[0];
+        const chunkContent = firstCandidate?.content;
+        if (chunkContent && Array.isArray(chunkContent.parts)) {
+            for (const part of chunkContent.parts) {
+                rawResponseParts.push(part);
+                // Forward text parts to the consumer immediately
+                if (typeof part.text === "string" && part.text.length > 0) {
+                    channel.push(part.text);
+                }
+            }
+        }
+        if (chunk.functionCalls) {
+            stepFunctionCalls.push(...chunk.functionCalls);
+        }
+        const usage = chunkRecord.usageMetadata;
+        if (usage) {
+            inputTokens = Math.max(inputTokens, usage.promptTokenCount || 0);
+            outputTokens = Math.max(outputTokens, usage.candidatesTokenCount || 0);
+        }
+    }
+    return { rawResponseParts, stepFunctionCalls, inputTokens, outputTokens };
+}
 /**
  * Extract text from raw response parts, filtering out non-text parts
  * (thoughtSignature, functionCall) to avoid SDK warnings.