@juspay/neurolink 7.31.0 → 7.33.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [7.33.0](https://github.com/juspay/neurolink/compare/v7.32.0...v7.33.0) (2025-09-03)
+
+### Features
+
+- **(provider):** refactor generate method to use streamText for improved performance and consistency ([a118300](https://github.com/juspay/neurolink/commit/a11830088376b899725bcb1dc2467cb73f44f5b9))
+
+## [7.32.0](https://github.com/juspay/neurolink/compare/v7.31.0...v7.32.0) (2025-09-03)
+
+### Features
+
+- **(sdk):** Add Speech to Speech agents implementation ([a8bf953](https://github.com/juspay/neurolink/commit/a8bf953993a16303d3c4a5b3a94d5ea5b6bd83d7))
+
 ## [7.31.0](https://github.com/juspay/neurolink/compare/v7.30.1...v7.31.0) (2025-09-01)
 
 ### Features

package/dist/cli/factories/commandFactory.js

@@ -1054,8 +1054,22 @@ export class CLICommandFactory {
                         // Demo mode - add delay between chunks
                         await new Promise((resolve) => setTimeout(resolve, options.delay));
                     }
-                    process.stdout.write(nextResult.value.content);
-                    fullContent += nextResult.value.content;
+                    const evt = nextResult.value;
+                    const isText = (o) => !!o &&
+                        typeof o === "object" &&
+                        typeof o.content === "string";
+                    const isAudio = (o) => !!o &&
+                        typeof o === "object" &&
+                        o.type === "audio";
+                    if (isText(evt)) {
+                        process.stdout.write(evt.content);
+                        fullContent += evt.content;
+                    }
+                    else if (isAudio(evt)) {
+                        if (options.debug && !options.quiet) {
+                            process.stdout.write("[audio-chunk]");
+                        }
+                    }
                 }
             }
             catch (error) {

package/dist/core/baseProvider.d.ts

@@ -37,6 +37,8 @@ export declare abstract class BaseProvider implements AIProvider {
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
+     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
+     * for consistency and better performance
      */
     generate(optionsOrPrompt: TextGenerationOptions | string, _analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     /**
@@ -110,6 +112,10 @@ export declare abstract class BaseProvider implements AIProvider {
      * MCP tools are added when available (without blocking)
      */
     protected getAllTools(): Promise<Record<string, Tool>>;
+    /**
+     * Calculate actual cost based on token usage and provider configuration
+     */
+    private calculateActualCost;
     /**
      * Convert MCP JSON Schema to Zod schema for AI SDK tools
      * Handles common MCP schema patterns safely

package/dist/core/baseProvider.js

@@ -146,6 +146,8 @@ export class BaseProvider {
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
+     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
+     * for consistency and better performance
      */
     async generate(optionsOrPrompt, _analysisSchema) {
         const options = this.normalizeTextOptions(optionsOrPrompt);
@@ -153,8 +155,9 @@ export class BaseProvider {
         this.validateOptions(options);
         const startTime = Date.now();
         try {
-            // Import generateText dynamically to avoid circular dependencies
-            const { generateText } = await import("ai");
+            // Import streamText dynamically to avoid circular dependencies
+            // Using streamText instead of generateText for unified implementation
+            const { streamText } = await import("ai");
             // Get ALL available tools (direct + MCP + external from options)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const baseTools = shouldUseTools ? await this.getAllTools() : {};
@@ -175,7 +178,8 @@ export class BaseProvider {
             const model = await this.getAISDKModelWithMiddleware(options);
             // Build proper message array with conversation history
             const messages = buildMessagesArray(options);
-            const result = await generateText({
+            // Use streamText and accumulate results instead of generateText
+            const streamResult = await streamText({
                 model,
                 messages: messages,
                 tools,
@@ -184,31 +188,30 @@ export class BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
             });
+            // Accumulate the streamed content
+            let accumulatedContent = "";
+            // Wait for the stream to complete and accumulate content
+            for await (const chunk of streamResult.textStream) {
+                accumulatedContent += chunk;
+            }
+            // Get the final result - this should include usage, toolCalls, etc.
+            const usage = await streamResult.usage;
+            const toolCalls = await streamResult.toolCalls;
+            const toolResults = await streamResult.toolResults;
             const responseTime = Date.now() - startTime;
+            // Create a result object compatible with generateText format
+            const result = {
+                text: accumulatedContent,
+                usage: usage,
+                toolCalls: toolCalls,
+                toolResults: toolResults,
+                steps: streamResult.steps, // Include steps for tool execution tracking
+            };
             try {
-                // Calculate actual cost based on token usage and provider configuration
-                const calculateActualCost = () => {
-                    try {
-                        const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
-                        if (!costInfo) {
-                            return 0; // No cost info available
-                        }
-                        const promptTokens = result.usage?.promptTokens || 0;
-                        const completionTokens = result.usage?.completionTokens || 0;
-                        // Calculate cost per 1K tokens
-                        const inputCost = (promptTokens / 1000) * costInfo.input;
-                        const outputCost = (completionTokens / 1000) * costInfo.output;
-                        return inputCost + outputCost;
-                    }
-                    catch (error) {
-                        logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
-                        return 0; // Fallback to 0 on any error
-                    }
-                };
-                const actualCost = calculateActualCost();
+                const actualCost = await this.calculateActualCost(usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 });
                 recordProviderPerformanceFromMetrics(this.providerName, {
                     responseTime,
-                    tokensGenerated: result.usage?.totalTokens || 0,
+                    tokensGenerated: usage?.totalTokens || 0,
                     cost: actualCost,
                     success: true,
                 });
@@ -216,7 +219,7 @@ export class BaseProvider {
                 const optimizedProvider = getPerformanceOptimizedProvider("speed");
                 logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
                     responseTime: `${responseTime}ms`,
-                    tokens: result.usage?.totalTokens || 0,
+                    tokens: usage?.totalTokens || 0,
                     estimatedCost: `$${actualCost.toFixed(6)}`,
                     recommendedSpeedProvider: optimizedProvider?.provider || "none",
                 });
@@ -228,11 +231,9 @@ export class BaseProvider {
             // AI SDK puts tool calls in steps array for multi-step generation
             const toolsUsed = [];
             // First check direct tool calls (fallback)
-            if (result.toolCalls && result.toolCalls.length > 0) {
-                toolsUsed.push(...result.toolCalls.map((tc) => {
-                    return (tc.toolName ||
-                        tc.name ||
-                        "unknown");
+            if (toolCalls && toolCalls.length > 0) {
+                toolsUsed.push(...toolCalls.map((tc) => {
+                    return tc.toolName || "unknown";
                 }));
             }
             // Then check steps for tool calls (primary source for multi-step)
@@ -326,20 +327,14 @@ export class BaseProvider {
                 },
                 provider: this.providerName,
                 model: this.modelName,
-                toolCalls: result.toolCalls
-                    ? result.toolCalls.map((tc) => ({
-                        toolCallId: tc.toolCallId ||
-                            tc.id ||
-                            "unknown",
-                        toolName: tc.toolName ||
-                            tc.name ||
-                            "unknown",
-                        args: tc.args ||
-                            tc.parameters ||
-                            {},
+                toolCalls: toolCalls
+                    ? toolCalls.map((tc) => ({
+                        toolCallId: tc.toolCallId || "unknown",
+                        toolName: tc.toolName || "unknown",
+                        args: tc.args || {},
                     }))
                     : [],
-                toolResults: result.toolResults,
+                toolResults: toolResults || [],
                 toolsUsed: uniqueToolsUsed,
                 toolExecutions, // ✅ Add extracted tool executions
                 availableTools: Object.keys(tools).map((name) => {
@@ -655,6 +650,27 @@ export class BaseProvider {
         logger.debug(`[BaseProvider] getAllTools returning tools: ${getKeysAsString(tools)}`);
         return tools;
     }
+    /**
+     * Calculate actual cost based on token usage and provider configuration
+     */
+    async calculateActualCost(usage) {
+        try {
+            const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
+            if (!costInfo) {
+                return 0; // No cost info available
+            }
+            const promptTokens = usage?.promptTokens || 0;
+            const completionTokens = usage?.completionTokens || 0;
+            // Calculate cost per 1K tokens
+            const inputCost = (promptTokens / 1000) * costInfo.input;
+            const outputCost = (completionTokens / 1000) * costInfo.output;
+            return inputCost + outputCost;
+        }
+        catch (error) {
+            logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
+            return 0; // Fallback to 0 on any error
+        }
+    }
     /**
      * Convert MCP JSON Schema to Zod schema for AI SDK tools
      * Handles common MCP schema patterns safely

package/dist/lib/core/baseProvider.d.ts

@@ -37,6 +37,8 @@ export declare abstract class BaseProvider implements AIProvider {
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
+     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
+     * for consistency and better performance
      */
     generate(optionsOrPrompt: TextGenerationOptions | string, _analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     /**
@@ -110,6 +112,10 @@ export declare abstract class BaseProvider implements AIProvider {
      * MCP tools are added when available (without blocking)
      */
     protected getAllTools(): Promise<Record<string, Tool>>;
+    /**
+     * Calculate actual cost based on token usage and provider configuration
+     */
+    private calculateActualCost;
     /**
      * Convert MCP JSON Schema to Zod schema for AI SDK tools
      * Handles common MCP schema patterns safely

package/dist/lib/core/baseProvider.js

@@ -146,6 +146,8 @@ export class BaseProvider {
     /**
      * Text generation method - implements AIProvider interface
      * Tools are always available unless explicitly disabled
+     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
+     * for consistency and better performance
      */
     async generate(optionsOrPrompt, _analysisSchema) {
         const options = this.normalizeTextOptions(optionsOrPrompt);
@@ -153,8 +155,9 @@ export class BaseProvider {
         this.validateOptions(options);
         const startTime = Date.now();
         try {
-            // Import generateText dynamically to avoid circular dependencies
-            const { generateText } = await import("ai");
+            // Import streamText dynamically to avoid circular dependencies
+            // Using streamText instead of generateText for unified implementation
+            const { streamText } = await import("ai");
             // Get ALL available tools (direct + MCP + external from options)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const baseTools = shouldUseTools ? await this.getAllTools() : {};
@@ -175,7 +178,8 @@ export class BaseProvider {
             const model = await this.getAISDKModelWithMiddleware(options);
             // Build proper message array with conversation history
             const messages = buildMessagesArray(options);
-            const result = await generateText({
+            // Use streamText and accumulate results instead of generateText
+            const streamResult = await streamText({
                 model,
                 messages: messages,
                 tools,
@@ -184,31 +188,30 @@ export class BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
             });
+            // Accumulate the streamed content
+            let accumulatedContent = "";
+            // Wait for the stream to complete and accumulate content
+            for await (const chunk of streamResult.textStream) {
+                accumulatedContent += chunk;
+            }
+            // Get the final result - this should include usage, toolCalls, etc.
+            const usage = await streamResult.usage;
+            const toolCalls = await streamResult.toolCalls;
+            const toolResults = await streamResult.toolResults;
             const responseTime = Date.now() - startTime;
+            // Create a result object compatible with generateText format
+            const result = {
+                text: accumulatedContent,
+                usage: usage,
+                toolCalls: toolCalls,
+                toolResults: toolResults,
+                steps: streamResult.steps, // Include steps for tool execution tracking
+            };
             try {
-                // Calculate actual cost based on token usage and provider configuration
-                const calculateActualCost = () => {
-                    try {
-                        const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
-                        if (!costInfo) {
-                            return 0; // No cost info available
-                        }
-                        const promptTokens = result.usage?.promptTokens || 0;
-                        const completionTokens = result.usage?.completionTokens || 0;
-                        // Calculate cost per 1K tokens
-                        const inputCost = (promptTokens / 1000) * costInfo.input;
-                        const outputCost = (completionTokens / 1000) * costInfo.output;
-                        return inputCost + outputCost;
-                    }
-                    catch (error) {
-                        logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
-                        return 0; // Fallback to 0 on any error
-                    }
-                };
-                const actualCost = calculateActualCost();
+                const actualCost = await this.calculateActualCost(usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 });
                 recordProviderPerformanceFromMetrics(this.providerName, {
                     responseTime,
-                    tokensGenerated: result.usage?.totalTokens || 0,
+                    tokensGenerated: usage?.totalTokens || 0,
                     cost: actualCost,
                     success: true,
                 });
@@ -216,7 +219,7 @@ export class BaseProvider {
                 const optimizedProvider = getPerformanceOptimizedProvider("speed");
                 logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
                     responseTime: `${responseTime}ms`,
-                    tokens: result.usage?.totalTokens || 0,
+                    tokens: usage?.totalTokens || 0,
                     estimatedCost: `$${actualCost.toFixed(6)}`,
                     recommendedSpeedProvider: optimizedProvider?.provider || "none",
                 });
@@ -228,11 +231,9 @@ export class BaseProvider {
             // AI SDK puts tool calls in steps array for multi-step generation
             const toolsUsed = [];
             // First check direct tool calls (fallback)
-            if (result.toolCalls && result.toolCalls.length > 0) {
-                toolsUsed.push(...result.toolCalls.map((tc) => {
-                    return (tc.toolName ||
-                        tc.name ||
-                        "unknown");
+            if (toolCalls && toolCalls.length > 0) {
+                toolsUsed.push(...toolCalls.map((tc) => {
+                    return tc.toolName || "unknown";
                 }));
             }
             // Then check steps for tool calls (primary source for multi-step)
@@ -326,20 +327,14 @@ export class BaseProvider {
                 },
                 provider: this.providerName,
                 model: this.modelName,
-                toolCalls: result.toolCalls
-                    ? result.toolCalls.map((tc) => ({
-                        toolCallId: tc.toolCallId ||
-                            tc.id ||
-                            "unknown",
-                        toolName: tc.toolName ||
-                            tc.name ||
-                            "unknown",
-                        args: tc.args ||
-                            tc.parameters ||
-                            {},
+                toolCalls: toolCalls
+                    ? toolCalls.map((tc) => ({
+                        toolCallId: tc.toolCallId || "unknown",
+                        toolName: tc.toolName || "unknown",
+                        args: tc.args || {},
                     }))
                     : [],
-                toolResults: result.toolResults,
+                toolResults: toolResults || [],
                 toolsUsed: uniqueToolsUsed,
                 toolExecutions, // ✅ Add extracted tool executions
                 availableTools: Object.keys(tools).map((name) => {
@@ -655,6 +650,27 @@ export class BaseProvider {
         logger.debug(`[BaseProvider] getAllTools returning tools: ${getKeysAsString(tools)}`);
         return tools;
     }
+    /**
+     * Calculate actual cost based on token usage and provider configuration
+     */
+    async calculateActualCost(usage) {
+        try {
+            const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
+            if (!costInfo) {
+                return 0; // No cost info available
+            }
+            const promptTokens = usage?.promptTokens || 0;
+            const completionTokens = usage?.completionTokens || 0;
+            // Calculate cost per 1K tokens
+            const inputCost = (promptTokens / 1000) * costInfo.input;
+            const outputCost = (completionTokens / 1000) * costInfo.output;
+            return inputCost + outputCost;
+        }
+        catch (error) {
+            logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
+            return 0; // Fallback to 0 on any error
+        }
+    }
     /**
      * Convert MCP JSON Schema to Zod schema for AI SDK tools
      * Handles common MCP schema patterns safely

package/dist/lib/neurolink.js

@@ -1312,8 +1312,10 @@ export class NeuroLink {
                 needsInitialization: !this.mcpInitialized,
                 message: "Checking MCP initialization status before generation",
             });
-            // Initialize MCP if needed
-            await this.initializeMCP();
+            // Initialize MCP only when tools are enabled
+            if (!options.disableTools) {
+                await this.initializeMCP();
+            }
             const mcpInitCheckEndTime = process.hrtime.bigint();
             const mcpInitCheckDurationNs = mcpInitCheckEndTime - mcpInitCheckStartTime;
             logger.debug(`[NeuroLink] ✅ LOG_POINT_T003_MCP_INIT_CHECK_COMPLETE`, {
@@ -1573,10 +1575,16 @@ export class NeuroLink {
         };
         // Call the new stream method
         const result = await this.stream(streamOptions);
-        // Convert StreamResult to simple string async iterable
+        // Convert StreamResult to simple string async iterable (filter text events only)
         async function* stringStream() {
-            for await (const chunk of result.stream) {
-                yield chunk.content;
+            for await (const evt of result.stream) {
+                const anyEvt = evt;
+                if (anyEvt && typeof anyEvt === "object" && "content" in anyEvt) {
+                    const content = anyEvt.content;
+                    if (typeof content === "string") {
+                        yield content;
+                    }
+                }
             }
         }
         return stringStream();
@@ -1646,12 +1654,13 @@ export class NeuroLink {
         let factoryResult;
         try {
             await this.initializeMCP();
-            const _originalPrompt = options.input.text;
             factoryResult = processStreamingFactoryOptions(options);
             enhancedOptions = createCleanStreamOptions(options);
-            const { toolResults: _toolResults, enhancedPrompt } = await this.detectAndExecuteTools(options.input.text, undefined);
-            if (enhancedPrompt !== options.input.text) {
-                enhancedOptions.input.text = enhancedPrompt;
+            if (options.input?.text) {
+                const { toolResults: _toolResults, enhancedPrompt } = await this.detectAndExecuteTools(options.input.text, undefined);
+                if (enhancedPrompt !== options.input.text) {
+                    enhancedOptions.input.text = enhancedPrompt;
+                }
             }
             const { stream: mcpStream, provider: providerName } = await this.createMCPStream(enhancedOptions);
             const streamResult = await this.processStreamResult(mcpStream, enhancedOptions, factoryResult);
@@ -1756,9 +1765,13 @@ export class NeuroLink {
             validationStartTimeNs: validationStartTime.toString(),
             message: "Starting comprehensive input validation process",
         });
-        if (!options?.input?.text ||
-            typeof options.input.text !== "string" ||
-            options.input.text.trim() === "") {
+        const hasText = typeof options?.input?.text === "string" &&
+            options.input.text.trim().length > 0;
+        // Accept audio when frames are present; sampleRateHz is optional (defaults applied later)
+        const hasAudio = !!(options?.input?.audio &&
+            options.input.audio.frames &&
+            typeof options.input.audio.frames[Symbol.asyncIterator] !== "undefined");
+        if (!hasText && !hasAudio) {
             const validationFailTime = process.hrtime.bigint();
             const validationDurationNs = validationFailTime - validationStartTime;
             logger.debug(`[NeuroLink] 💥 LOG_POINT_005_VALIDATION_FAILED`, {
@@ -1769,10 +1782,10 @@ export class NeuroLink {
                 elapsedNs: (process.hrtime.bigint() - hrTimeStart).toString(),
                 validationDurationNs: validationDurationNs.toString(),
                 validationDurationMs: Number(validationDurationNs) / 1000000,
-                validationError: "Stream options must include input.text as a non-empty string",
+                validationError: "Stream options must include either input.text or input.audio",
                 message: "EXHAUSTIVE validation failure analysis with character-level debugging",
             });
-            throw new Error("Stream options must include input.text as a non-empty string");
+            throw new Error("Stream options must include either input.text or input.audio");
         }
         const validationSuccessTime = process.hrtime.bigint();
         const validationDurationNs = validationSuccessTime - validationStartTime;
@@ -1784,10 +1797,11 @@ export class NeuroLink {
             elapsedNs: (process.hrtime.bigint() - hrTimeStart).toString(),
             validationDurationNs: validationDurationNs.toString(),
             validationDurationMs: Number(validationDurationNs) / 1000000,
-            inputTextValid: true,
-            inputTextLength: options.input.text.length,
-            inputTextTrimmedLength: options.input.text.trim().length,
-            inputTextPreview: options.input.text.substring(0, 100),
+            inputTextValid: hasText,
+            inputAudioPresent: hasAudio,
+            inputTextLength: hasText ? options.input.text.length : 0,
+            inputTextTrimmedLength: hasText ? options.input.text.trim().length : 0,
+            inputTextPreview: hasText ? options.input.text.substring(0, 100) : "",
             message: "EXHAUSTIVE validation success - proceeding with stream processing",
         });
     }

package/dist/lib/providers/googleAiStudio.d.ts

@@ -17,6 +17,7 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     protected getAISDKModel(): LanguageModelV1;
     protected handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
+    private executeAudioStreamViaGeminiLive;
     private getApiKey;
 }
 export default GoogleAIStudioProvider;

package/dist/lib/providers/googleAiStudio.js

@@ -8,6 +8,16 @@ import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } fro
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
+// Create Google GenAI client
+async function createGoogleGenAIClient(apiKey) {
+    const mod = await import("@google/genai");
+    const ctor = mod.GoogleGenAI;
+    if (!ctor) {
+        throw new Error("@google/genai does not export GoogleGenAI");
+    }
+    const Ctor = ctor;
+    return new Ctor({ apiKey });
+}
 // Environment variable setup
 if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY &&
     process.env.GOOGLE_AI_API_KEY) {
@@ -61,6 +71,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, _analysisSchema) {
+        // Phase 1: if audio input present, bridge to Gemini Live (Studio) using @google/genai
+        if (options.input?.audio) {
+            return await this.executeAudioStreamViaGeminiLive(options);
+        }
         this.validateStreamOptions(options);
         const startTime = Date.now();
         const apiKey = this.getApiKey();
@@ -115,6 +129,188 @@ export class GoogleAIStudioProvider extends BaseProvider {
     // ===================
     // HELPER METHODS
     // ===================
+    async executeAudioStreamViaGeminiLive(options) {
+        const startTime = Date.now();
+        const apiKey = this.getApiKey();
+        // Dynamic import to avoid hard dependency unless audio streaming is used
+        let client;
+        try {
+            client = await createGoogleGenAIClient(apiKey);
+        }
+        catch {
+            throw new AuthenticationError("Missing '@google/genai'. Install with: pnpm add @google/genai", this.providerName);
+        }
+        const model = this.modelName ||
+            process.env.GOOGLE_VOICE_AI_MODEL ||
+            "gemini-2.5-flash-preview-native-audio-dialog";
+        const queue = [];
+        let resolveNext = null;
+        let done = false;
+        const push = (item) => {
+            if (done) {
+                return;
+            }
+            if (item.type === "audio") {
+                if (resolveNext) {
+                    const fn = resolveNext;
+                    resolveNext = null;
+                    fn({ value: { type: "audio", audio: item.audio }, done: false });
+                    return;
+                }
+            }
+            queue.push(item);
+        };
+        const session = await client.live.connect({
+            model,
+            callbacks: {
+                onopen: () => {
+                    // no-op
+                },
+                onmessage: async (message) => {
+                    try {
+                        const audio = message?.serverContent?.modelTurn?.parts?.[0]?.inlineData;
+                        if (audio?.data) {
+                            const buf = Buffer.from(String(audio.data), "base64");
+                            const chunk = {
+                                data: buf,
+                                sampleRateHz: 24000,
+                                channels: 1,
+                                encoding: "PCM16LE",
+                            };
+                            push({ type: "audio", audio: chunk });
+                        }
+                        if (message?.serverContent?.interrupted) {
+                            // allow consumer to handle; no special action required here
+                        }
+                    }
+                    catch (e) {
+                        push({ type: "error", error: e });
+                    }
+                },
+                onerror: (e) => {
+                    push({ type: "error", error: e });
+                },
+                onclose: (_e) => {
+                    push({ type: "end" });
+                },
+            },
+            config: {
+                responseModalities: ["AUDIO"],
+                speechConfig: {
+                    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Orus" } },
+                },
+            },
+        });
+        // Feed upstream audio frames concurrently
+        (async () => {
+            try {
+                const spec = options.input?.audio;
+                if (!spec) {
+                    logger.debug("[GeminiLive] No audio spec found on input; skipping upstream send");
+                    return;
+                }
+                for await (const frame of spec.frames) {
+                    // Zero-length frame acts as a 'flush' control signal
+                    if (!frame || frame.byteLength === 0) {
+                        try {
+                            if (session.sendInput) {
+                                await session.sendInput({ event: "flush" });
+                            }
+                            else if (session.sendRealtimeInput) {
+                                await session.sendRealtimeInput({ event: "flush" });
+                            }
+                        }
+                        catch (err) {
+                            logger.debug("[GeminiLive] flush control failed (non-fatal)", {
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                        }
+                        continue;
+                    }
+                    // Convert PCM16LE buffer to base64 and wrap in genai Blob-like object
+                    const base64 = frame.toString("base64");
+                    const mimeType = `audio/pcm;rate=${spec.sampleRateHz || 16000}`;
+                    await session.sendRealtimeInput?.({
+                        media: { data: base64, mimeType },
+                    });
+                }
+                // Best-effort flush signal if supported
+                try {
+                    if (session.sendInput) {
+                        await session.sendInput({ event: "flush" });
+                    }
+                    else if (session.sendRealtimeInput) {
+                        await session.sendRealtimeInput({ event: "flush" });
+                    }
+                }
+                catch (err) {
+                    logger.debug("[GeminiLive] final flush failed (non-fatal)", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            catch (e) {
+                push({ type: "error", error: e });
+            }
+        })().catch(() => {
+            // ignore
+        });
+        // AsyncIterable for stream events
+        const asyncIterable = {
+            [Symbol.asyncIterator]() {
+                return {
+                    async next() {
+                        if (queue.length > 0) {
+                            const item = queue.shift();
+                            if (!item) {
+                                return {
+                                    value: undefined,
+                                    done: true,
+                                };
+                            }
+                            if (item.type === "audio") {
+                                return {
+                                    value: { type: "audio", audio: item.audio },
+                                    done: false,
+                                };
+                            }
+                            if (item.type === "end") {
+                                done = true;
+                                return {
+                                    value: undefined,
+                                    done: true,
+                                };
+                            }
+                            if (item.type === "error") {
+                                done = true;
+                                throw item.error instanceof Error
+                                    ? item.error
+                                    : new Error(String(item.error));
+                            }
+                        }
+                        if (done) {
+                            return {
+                                value: undefined,
+                                done: true,
+                            };
+                        }
+                        return await new Promise((resolve) => {
+                            resolveNext = resolve;
+                        });
+                    },
+                };
+            },
+        };
+        return {
+            stream: asyncIterable,
+            provider: this.providerName,
+            model: model,
+            metadata: {
+                startTime,
+                streamId: `google-ai-audio-${Date.now()}`,
+            },
+        };
+    }
     getApiKey() {
         const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
         if (!apiKey) {

package/dist/lib/providers/googleVertex.js

@@ -834,6 +834,7 @@ export class GoogleVertexProvider extends BaseProvider {
             message: "Message array built successfully",
         });
     }
+    /* eslint-disable-next-line max-lines-per-function */
     async executeStream(options, analysisSchema) {
         // Initialize stream execution tracking
         const streamExecutionId = `vertex-stream-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
@@ -863,7 +864,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 streamExecutionId,
                 streamRequestDetails: {
                     modelName: this.modelName,
-                    promptLength: options.input.text.length,
+                    promptLength: typeof options.input?.text === "string"
+                        ? options.input.text.length
+                        : 0,
                     hasSchema: !!analysisSchema,
                     messagesCount: Array.isArray(messages) ? messages.length : 0,
                     temperature: options?.temperature,

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

@@ -66,9 +66,23 @@ export interface StreamAnalyticsData {
  * Stream function options interface - Primary method for streaming content
  * Future-ready for multi-modal capabilities while maintaining text focus
  */
+export type PCMEncoding = "PCM16LE";
+export interface AudioInputSpec {
+    frames: AsyncIterable<Buffer>;
+    sampleRateHz?: number;
+    encoding?: PCMEncoding;
+    channels?: 1;
+}
+export interface AudioChunk {
+    data: Buffer;
+    sampleRateHz: number;
+    channels: number;
+    encoding: PCMEncoding;
+}
 export interface StreamOptions {
     input: {
-        text: string;
+        text?: string;
+        audio?: AudioInputSpec;
     };
     output?: {
         format?: "text" | "structured" | "json";
@@ -121,6 +135,9 @@ export interface StreamOptions {
 export interface StreamResult {
     stream: AsyncIterable<{
         content: string;
+    } | {
+        type: "audio";
+        audio: AudioChunk;
     }>;
     provider?: string;
     model?: string;

package/dist/lib/utils/optionsConversion.js

@@ -44,7 +44,7 @@ export function convertGenerateToStreamOptions(generateOptions) {
 export function convertStreamToGenerateOptions(streamOptions) {
     const generateOptions = {
         // Core input mapping
-        input: streamOptions.input,
+        input: { text: (streamOptions.input && streamOptions.input.text) || "" },
         // Provider and model settings
         provider: streamOptions.provider,
         model: streamOptions.model,

package/dist/neurolink.js

@@ -1312,8 +1312,10 @@ export class NeuroLink {
                 needsInitialization: !this.mcpInitialized,
                 message: "Checking MCP initialization status before generation",
             });
-            // Initialize MCP if needed
-            await this.initializeMCP();
+            // Initialize MCP only when tools are enabled
+            if (!options.disableTools) {
+                await this.initializeMCP();
+            }
             const mcpInitCheckEndTime = process.hrtime.bigint();
             const mcpInitCheckDurationNs = mcpInitCheckEndTime - mcpInitCheckStartTime;
             logger.debug(`[NeuroLink] ✅ LOG_POINT_T003_MCP_INIT_CHECK_COMPLETE`, {
@@ -1573,10 +1575,16 @@ export class NeuroLink {
         };
         // Call the new stream method
         const result = await this.stream(streamOptions);
-        // Convert StreamResult to simple string async iterable
+        // Convert StreamResult to simple string async iterable (filter text events only)
         async function* stringStream() {
-            for await (const chunk of result.stream) {
-                yield chunk.content;
+            for await (const evt of result.stream) {
+                const anyEvt = evt;
+                if (anyEvt && typeof anyEvt === "object" && "content" in anyEvt) {
+                    const content = anyEvt.content;
+                    if (typeof content === "string") {
+                        yield content;
+                    }
+                }
             }
         }
         return stringStream();
@@ -1646,12 +1654,13 @@ export class NeuroLink {
         let factoryResult;
         try {
             await this.initializeMCP();
-            const _originalPrompt = options.input.text;
             factoryResult = processStreamingFactoryOptions(options);
             enhancedOptions = createCleanStreamOptions(options);
-            const { toolResults: _toolResults, enhancedPrompt } = await this.detectAndExecuteTools(options.input.text, undefined);
-            if (enhancedPrompt !== options.input.text) {
-                enhancedOptions.input.text = enhancedPrompt;
+            if (options.input?.text) {
+                const { toolResults: _toolResults, enhancedPrompt } = await this.detectAndExecuteTools(options.input.text, undefined);
+                if (enhancedPrompt !== options.input.text) {
+                    enhancedOptions.input.text = enhancedPrompt;
+                }
             }
             const { stream: mcpStream, provider: providerName } = await this.createMCPStream(enhancedOptions);
             const streamResult = await this.processStreamResult(mcpStream, enhancedOptions, factoryResult);
@@ -1756,9 +1765,13 @@ export class NeuroLink {
             validationStartTimeNs: validationStartTime.toString(),
             message: "Starting comprehensive input validation process",
         });
-        if (!options?.input?.text ||
-            typeof options.input.text !== "string" ||
-            options.input.text.trim() === "") {
+        const hasText = typeof options?.input?.text === "string" &&
+            options.input.text.trim().length > 0;
+        // Accept audio when frames are present; sampleRateHz is optional (defaults applied later)
+        const hasAudio = !!(options?.input?.audio &&
+            options.input.audio.frames &&
+            typeof options.input.audio.frames[Symbol.asyncIterator] !== "undefined");
+        if (!hasText && !hasAudio) {
             const validationFailTime = process.hrtime.bigint();
             const validationDurationNs = validationFailTime - validationStartTime;
             logger.debug(`[NeuroLink] 💥 LOG_POINT_005_VALIDATION_FAILED`, {
@@ -1769,10 +1782,10 @@ export class NeuroLink {
                 elapsedNs: (process.hrtime.bigint() - hrTimeStart).toString(),
                 validationDurationNs: validationDurationNs.toString(),
                 validationDurationMs: Number(validationDurationNs) / 1000000,
-                validationError: "Stream options must include input.text as a non-empty string",
+                validationError: "Stream options must include either input.text or input.audio",
                 message: "EXHAUSTIVE validation failure analysis with character-level debugging",
             });
-            throw new Error("Stream options must include input.text as a non-empty string");
+            throw new Error("Stream options must include either input.text or input.audio");
         }
         const validationSuccessTime = process.hrtime.bigint();
         const validationDurationNs = validationSuccessTime - validationStartTime;
@@ -1784,10 +1797,11 @@ export class NeuroLink {
             elapsedNs: (process.hrtime.bigint() - hrTimeStart).toString(),
             validationDurationNs: validationDurationNs.toString(),
             validationDurationMs: Number(validationDurationNs) / 1000000,
-            inputTextValid: true,
-            inputTextLength: options.input.text.length,
-            inputTextTrimmedLength: options.input.text.trim().length,
-            inputTextPreview: options.input.text.substring(0, 100),
+            inputTextValid: hasText,
+            inputAudioPresent: hasAudio,
+            inputTextLength: hasText ? options.input.text.length : 0,
+            inputTextTrimmedLength: hasText ? options.input.text.trim().length : 0,
+            inputTextPreview: hasText ? options.input.text.substring(0, 100) : "",
             message: "EXHAUSTIVE validation success - proceeding with stream processing",
         });
     }

package/dist/providers/googleAiStudio.d.ts

@@ -17,6 +17,7 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     protected getAISDKModel(): LanguageModelV1;
     protected handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
+    private executeAudioStreamViaGeminiLive;
     private getApiKey;
 }
 export default GoogleAIStudioProvider;

package/dist/providers/googleAiStudio.js

@@ -8,6 +8,16 @@ import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } fro
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
+// Create Google GenAI client
+async function createGoogleGenAIClient(apiKey) {
+    const mod = await import("@google/genai");
+    const ctor = mod.GoogleGenAI;
+    if (!ctor) {
+        throw new Error("@google/genai does not export GoogleGenAI");
+    }
+    const Ctor = ctor;
+    return new Ctor({ apiKey });
+}
 // Environment variable setup
 if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY &&
     process.env.GOOGLE_AI_API_KEY) {
@@ -61,6 +71,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, _analysisSchema) {
+        // Phase 1: if audio input present, bridge to Gemini Live (Studio) using @google/genai
+        if (options.input?.audio) {
+            return await this.executeAudioStreamViaGeminiLive(options);
+        }
         this.validateStreamOptions(options);
         const startTime = Date.now();
         const apiKey = this.getApiKey();
@@ -115,6 +129,188 @@ export class GoogleAIStudioProvider extends BaseProvider {
     // ===================
     // HELPER METHODS
     // ===================
+    async executeAudioStreamViaGeminiLive(options) {
+        const startTime = Date.now();
+        const apiKey = this.getApiKey();
+        // Dynamic import to avoid hard dependency unless audio streaming is used
+        let client;
+        try {
+            client = await createGoogleGenAIClient(apiKey);
+        }
+        catch {
+            throw new AuthenticationError("Missing '@google/genai'. Install with: pnpm add @google/genai", this.providerName);
+        }
+        const model = this.modelName ||
+            process.env.GOOGLE_VOICE_AI_MODEL ||
+            "gemini-2.5-flash-preview-native-audio-dialog";
+        const queue = [];
+        let resolveNext = null;
+        let done = false;
+        const push = (item) => {
+            if (done) {
+                return;
+            }
+            if (item.type === "audio") {
+                if (resolveNext) {
+                    const fn = resolveNext;
+                    resolveNext = null;
+                    fn({ value: { type: "audio", audio: item.audio }, done: false });
+                    return;
+                }
+            }
+            queue.push(item);
+        };
+        const session = await client.live.connect({
+            model,
+            callbacks: {
+                onopen: () => {
+                    // no-op
+                },
+                onmessage: async (message) => {
+                    try {
+                        const audio = message?.serverContent?.modelTurn?.parts?.[0]?.inlineData;
+                        if (audio?.data) {
+                            const buf = Buffer.from(String(audio.data), "base64");
+                            const chunk = {
+                                data: buf,
+                                sampleRateHz: 24000,
+                                channels: 1,
+                                encoding: "PCM16LE",
+                            };
+                            push({ type: "audio", audio: chunk });
+                        }
+                        if (message?.serverContent?.interrupted) {
+                            // allow consumer to handle; no special action required here
+                        }
+                    }
+                    catch (e) {
+                        push({ type: "error", error: e });
+                    }
+                },
+                onerror: (e) => {
+                    push({ type: "error", error: e });
+                },
+                onclose: (_e) => {
+                    push({ type: "end" });
+                },
+            },
+            config: {
+                responseModalities: ["AUDIO"],
+                speechConfig: {
+                    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Orus" } },
+                },
+            },
+        });
+        // Feed upstream audio frames concurrently
+        (async () => {
+            try {
+                const spec = options.input?.audio;
+                if (!spec) {
+                    logger.debug("[GeminiLive] No audio spec found on input; skipping upstream send");
+                    return;
+                }
+                for await (const frame of spec.frames) {
+                    // Zero-length frame acts as a 'flush' control signal
+                    if (!frame || frame.byteLength === 0) {
+                        try {
+                            if (session.sendInput) {
+                                await session.sendInput({ event: "flush" });
+                            }
+                            else if (session.sendRealtimeInput) {
+                                await session.sendRealtimeInput({ event: "flush" });
+                            }
+                        }
+                        catch (err) {
+                            logger.debug("[GeminiLive] flush control failed (non-fatal)", {
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                        }
+                        continue;
+                    }
+                    // Convert PCM16LE buffer to base64 and wrap in genai Blob-like object
+                    const base64 = frame.toString("base64");
+                    const mimeType = `audio/pcm;rate=${spec.sampleRateHz || 16000}`;
+                    await session.sendRealtimeInput?.({
+                        media: { data: base64, mimeType },
+                    });
+                }
+                // Best-effort flush signal if supported
+                try {
+                    if (session.sendInput) {
+                        await session.sendInput({ event: "flush" });
+                    }
+                    else if (session.sendRealtimeInput) {
+                        await session.sendRealtimeInput({ event: "flush" });
+                    }
+                }
+                catch (err) {
+                    logger.debug("[GeminiLive] final flush failed (non-fatal)", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            catch (e) {
+                push({ type: "error", error: e });
+            }
+        })().catch(() => {
+            // ignore
+        });
+        // AsyncIterable for stream events
+        const asyncIterable = {
+            [Symbol.asyncIterator]() {
+                return {
+                    async next() {
+                        if (queue.length > 0) {
+                            const item = queue.shift();
+                            if (!item) {
+                                return {
+                                    value: undefined,
+                                    done: true,
+                                };
+                            }
+                            if (item.type === "audio") {
+                                return {
+                                    value: { type: "audio", audio: item.audio },
+                                    done: false,
+                                };
+                            }
+                            if (item.type === "end") {
+                                done = true;
+                                return {
+                                    value: undefined,
+                                    done: true,
+                                };
+                            }
+                            if (item.type === "error") {
+                                done = true;
+                                throw item.error instanceof Error
+                                    ? item.error
+                                    : new Error(String(item.error));
+                            }
+                        }
+                        if (done) {
+                            return {
+                                value: undefined,
+                                done: true,
+                            };
+                        }
+                        return await new Promise((resolve) => {
+                            resolveNext = resolve;
+                        });
+                    },
+                };
+            },
+        };
+        return {
+            stream: asyncIterable,
+            provider: this.providerName,
+            model: model,
+            metadata: {
+                startTime,
+                streamId: `google-ai-audio-${Date.now()}`,
+            },
+        };
+    }
     getApiKey() {
         const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
         if (!apiKey) {

package/dist/providers/googleVertex.js

@@ -834,6 +834,7 @@ export class GoogleVertexProvider extends BaseProvider {
             message: "Message array built successfully",
         });
     }
+    /* eslint-disable-next-line max-lines-per-function */
     async executeStream(options, analysisSchema) {
         // Initialize stream execution tracking
         const streamExecutionId = `vertex-stream-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
@@ -863,7 +864,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 streamExecutionId,
                 streamRequestDetails: {
                     modelName: this.modelName,
-                    promptLength: options.input.text.length,
+                    promptLength: typeof options.input?.text === "string"
+                        ? options.input.text.length
+                        : 0,
                     hasSchema: !!analysisSchema,
                     messagesCount: Array.isArray(messages) ? messages.length : 0,
                     temperature: options?.temperature,

package/dist/types/streamTypes.d.ts

@@ -66,9 +66,23 @@ export interface StreamAnalyticsData {
  * Stream function options interface - Primary method for streaming content
  * Future-ready for multi-modal capabilities while maintaining text focus
  */
+export type PCMEncoding = "PCM16LE";
+export interface AudioInputSpec {
+    frames: AsyncIterable<Buffer>;
+    sampleRateHz?: number;
+    encoding?: PCMEncoding;
+    channels?: 1;
+}
+export interface AudioChunk {
+    data: Buffer;
+    sampleRateHz: number;
+    channels: number;
+    encoding: PCMEncoding;
+}
 export interface StreamOptions {
     input: {
-        text: string;
+        text?: string;
+        audio?: AudioInputSpec;
     };
     output?: {
         format?: "text" | "structured" | "json";
@@ -121,6 +135,9 @@ export interface StreamOptions {
 export interface StreamResult {
     stream: AsyncIterable<{
         content: string;
+    } | {
+        type: "audio";
+        audio: AudioChunk;
     }>;
     provider?: string;
     model?: string;

package/dist/utils/optionsConversion.js

@@ -44,7 +44,7 @@ export function convertGenerateToStreamOptions(generateOptions) {
 export function convertStreamToGenerateOptions(streamOptions) {
     const generateOptions = {
         // Core input mapping
-        input: streamOptions.input,
+        input: { text: (streamOptions.input && streamOptions.input.text) || "" },
         // Provider and model settings
         provider: streamOptions.provider,
         model: streamOptions.model,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.31.0",
+  "version": "7.33.0",
   "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 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -78,6 +78,7 @@
     "dev:full": "node tools/development/dev-server.js",
     "dev:health": "node tools/development/healthMonitor.js",
     "dev:demo": "concurrently \"pnpm run dev\" \"node neurolink-demo/complete-enhanced-server.js\"",
+    "demo:voice": "pnpm build && node examples/voice-demo/server.mjs",
     "// Build & Deploy (Complete Pipeline)": "",
     "build:complete": "node tools/automation/buildSystem.js",
     "build:analyze": "node tools/development/dependency-analyzer.js",
@@ -151,6 +152,7 @@
     "@aws-sdk/credential-provider-node": "^3.876.0",
     "@aws-sdk/types": "^3.862.0",
     "@google-cloud/vertexai": "^1.10.0",
+    "@google/genai": "^1.16.0",
     "@google/generative-ai": "^0.24.1",
     "@huggingface/inference": "^2.8.0",
     "@modelcontextprotocol/sdk": "^1.13.0",