@juspay/neurolink 7.30.1 → 7.32.0

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

@@ -5,6 +5,7 @@ import type { EvaluationData } from "../index.js";
 import type { TokenUsage } from "./providers.js";
 import type { UnknownRecord, JsonValue } from "./common.js";
 import type { ChatMessage } from "./conversationTypes.js";
+import type { MiddlewareFactoryOptions } from "../types/middlewareTypes.js";
 /**
  * Interface for tool execution calls (AI SDK compatible)
  */
@@ -65,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";
@@ -111,6 +126,7 @@ export interface StreamOptions {
         fallbackToGenerate?: boolean;
     };
     conversationMessages?: ChatMessage[];
+    middleware?: MiddlewareFactoryOptions;
 }
 /**
  * Stream function result interface - Primary output format for streaming
@@ -119,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/middleware/builtin/analytics.d.ts

@@ -1,4 +1,4 @@
-import type { NeuroLinkMiddleware } from "../types.js";
+import type { NeuroLinkMiddleware } from "../../types/middlewareTypes.js";
 /**
  * Create analytics middleware for tracking AI model usage
  * Collects metrics on token usage, response times, and model performance

package/dist/middleware/builtin/guardrails.d.ts

@@ -1,5 +1,5 @@
 import type { LanguageModelV1 } from "ai";
-import type { NeuroLinkMiddleware } from "../types.js";
+import type { NeuroLinkMiddleware } from "../../types/middlewareTypes.js";
 /**
  * Configuration for the Guardrails middleware.
  */

package/dist/middleware/factory.d.ts

@@ -1,5 +1,5 @@
 import type { LanguageModelV1 } from "ai";
-import type { MiddlewareContext, MiddlewareConfig, MiddlewareFactoryOptions, MiddlewareChainStats, MiddlewarePreset, NeuroLinkMiddleware, MiddlewareRegistrationOptions } from "./types.js";
+import type { MiddlewareContext, MiddlewareConfig, MiddlewareFactoryOptions, MiddlewareChainStats, MiddlewarePreset, NeuroLinkMiddleware, MiddlewareRegistrationOptions } from "../types/middlewareTypes.js";
 import { MiddlewareRegistry } from "./registry.js";
 /**
  * Middleware factory for creating and applying middleware chains.

package/dist/middleware/index.d.ts

@@ -6,7 +6,7 @@
  * of language models with features like analytics, guardrails, caching, and more.
  */
 import { MiddlewareFactory } from "./factory.js";
-export type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareConditions, MiddlewareRegistrationOptions, MiddlewareExecutionResult, MiddlewareChainStats, MiddlewarePreset, MiddlewareFactoryOptions, BuiltInMiddlewareType, } from "./types.js";
+export type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareConditions, MiddlewareRegistrationOptions, MiddlewareExecutionResult, MiddlewareChainStats, MiddlewarePreset, MiddlewareFactoryOptions, BuiltInMiddlewareType, } from "../types/middlewareTypes.js";
 export type { LanguageModelV1Middleware } from "ai";
 export { MiddlewareFactory };
 export default MiddlewareFactory;

package/dist/middleware/registry.d.ts

@@ -1,5 +1,5 @@
 import type { LanguageModelV1Middleware } from "ai";
-import type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareRegistrationOptions, MiddlewareExecutionResult } from "./types.js";
+import type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareRegistrationOptions, MiddlewareExecutionResult } from "../types/middlewareTypes.js";
 /**
  * Manages the registration, configuration, and execution of middleware for a single factory instance.
  */

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) {