@juspay/neurolink 7.31.0 → 7.32.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [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/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.32.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",