@juspay/neurolink 9.61.2 → 9.62.0

package/dist/cli/commands/serve.js

@@ -145,6 +145,15 @@ export class ServeCommandFactory {
             builder: (yargs) => {
                 return yargs
                     .command("status", "Show server status", (yargs) => ServeCommandFactory.buildStatusOptions(yargs), (argv) => ServeCommandFactory.executeStatus(argv))
+                    .command("voice", "Start the real-time voice assistant server (OpenAI Realtime / Gemini Live)", (yargs) => yargs.option("port", {
+                    alias: "p",
+                    type: "number",
+                    default: 3000,
+                    describe: "Port to listen on",
+                }), async (argv) => {
+                    const { startVoiceServer } = await import("../../lib/server/voice/voiceServerApp.js");
+                    await startVoiceServer(argv.port);
+                })
                     .option("port", {
                     type: "number",
                     alias: "p",

package/dist/cli/commands/voiceServer.d.ts

@@ -1,3 +1,10 @@
 import type { CommandModule } from "yargs";
 import type { VoiceServerArgs } from "../../lib/types/index.js";
+/**
+ * @deprecated Use `neurolink serve voice` instead. This top-level alias is
+ * kept for one release for backwards compatibility and will be removed in a
+ * future version. The voice server is now subsumed under the existing
+ * `serve` infra command per CLAUDE.md's "everything via generate/stream/serve
+ * only" contract.
+ */
 export declare const voiceServerCommand: CommandModule<object, VoiceServerArgs>;

package/dist/cli/commands/voiceServer.js

@@ -1,8 +1,15 @@
 import { startVoiceServer } from "../../lib/server/voice/voiceServerApp.js";
 import { configureVoiceServerEnvironment } from "../../lib/server/voice/voiceWebSocketHandler.js";
+/**
+ * @deprecated Use `neurolink serve voice` instead. This top-level alias is
+ * kept for one release for backwards compatibility and will be removed in a
+ * future version. The voice server is now subsumed under the existing
+ * `serve` infra command per CLAUDE.md's "everything via generate/stream/serve
+ * only" contract.
+ */
 export const voiceServerCommand = {
     command: "voice-server",
-    describe: "Start the real-time voice assistant server (Soniox STT + Cartesia TTS + Cobra VAD)",
+    describe: "[DEPRECATED — use 'neurolink serve voice'] Start the real-time voice assistant server",
     builder: (yargs) => yargs.option("port", {
         alias: "p",
         type: "number",
@@ -10,6 +17,7 @@ export const voiceServerCommand = {
         describe: "Port to listen on",
     }),
     handler: async (argv) => {
+        console.warn("[deprecation] 'neurolink voice-server' is deprecated. Use 'neurolink serve voice' instead. This alias will be removed in a future release.");
         configureVoiceServerEnvironment();
         await startVoiceServer(argv.port);
     },

package/dist/cli/factories/commandFactory.js

@@ -276,9 +276,25 @@ export class CLICommandFactory {
             type: "string",
             description: "TTS voice to use (e.g., 'en-US-Neural2-C')",
         },
+        ttsProvider: {
+            type: "string",
+            choices: ["google-ai", "vertex", "openai-tts", "elevenlabs", "azure-tts"],
+            description: "TTS provider (overrides --provider for speech synthesis)",
+        },
         ttsFormat: {
             type: "string",
-            choices: ["mp3", "wav", "ogg", "opus"],
+            choices: [
+                "mp3",
+                "wav",
+                "ogg",
+                "opus",
+                "m4a",
+                "flac",
+                "webm",
+                "mp4",
+                "mpeg",
+                "mpga",
+            ],
             default: "mp3",
             description: "Audio output format",
         },
@@ -302,6 +318,25 @@ export class CLICommandFactory {
             default: false,
             description: "Auto-play generated audio",
         },
+        // STT (Speech-to-Text) options
+        stt: {
+            type: "boolean",
+            default: false,
+            description: "Enable speech-to-text transcription of input audio",
+        },
+        sttProvider: {
+            type: "string",
+            choices: ["whisper", "deepgram", "google-stt", "azure-stt"],
+            description: "STT provider to use",
+        },
+        sttLanguage: {
+            type: "string",
+            description: "Audio language code for STT (e.g., en-US)",
+        },
+        inputAudio: {
+            type: "string",
+            description: "Path to audio file for STT transcription",
+        },
         // Video Generation options (Veo 3.1)
         outputMode: {
             type: "string",
@@ -439,10 +474,16 @@ export class CLICommandFactory {
     };
     // Helper method to build options for commands
     static buildOptions(yargs, additionalOptions = {}) {
-        return yargs.options({
+        return (yargs
+            .options({
             ...CLICommandFactory.commonOptions,
             ...additionalOptions,
-        });
+        })
+            // NEW9: implies relationships so users who pass --stt-provider or
+            // --input-audio without --stt get an actionable error from yargs
+            // instead of silently skipping STT.
+            .implies("sttProvider", "stt")
+            .implies("inputAudio", "stt"));
     }
     // Helper method to process CLI images with smart auto-detection
     static processCliImages(images) {
@@ -603,11 +644,17 @@ export class CLICommandFactory {
             // TTS options
             tts: argv.tts,
             ttsVoice: argv.ttsVoice,
+            ttsProvider: argv.ttsProvider,
             ttsFormat: argv.ttsFormat,
             ttsSpeed: argv.ttsSpeed,
             ttsQuality: argv.ttsQuality,
             ttsOutput: argv.ttsOutput,
             ttsPlay: argv.ttsPlay,
+            // STT options
+            stt: argv.stt,
+            sttProvider: argv.sttProvider,
+            sttLanguage: argv.sttLanguage,
+            inputAudio: argv.inputAudio,
             // Video generation options (Veo 3.1)
             outputMode: argv.outputMode,
             videoOutput: argv.videoOutput,
@@ -1080,7 +1127,7 @@ export class CLICommandFactory {
      */
     static createGenerateCommand() {
         return {
-            command: ["generate <input>", "gen <input>"],
+            command: ["generate [input]", "gen [input]"],
             describe: "Generate content using AI providers",
             builder: (yargs) => {
                 return CLICommandFactory.buildOptions(yargs
@@ -1113,7 +1160,7 @@ export class CLICommandFactory {
      */
     static createStreamCommand() {
         return {
-            command: "stream <input>",
+            command: "stream [input]",
             describe: "Stream generation in real-time",
             builder: (yargs) => {
                 return CLICommandFactory.buildOptions(yargs
@@ -1642,6 +1689,12 @@ export class CLICommandFactory {
      * Handle stdin input for generate command
      */
     static async handleGenerateStdinInput(argv) {
+        // M10: STT-only runs (--stt + --input-audio with no positional prompt)
+        // are valid — the transcription becomes the prompt downstream. Skip the
+        // stdin/empty-input check in that case so users don't get
+        // "Input required..." for an STT-only command.
+        const isSttOnly = !!(argv.stt &&
+            argv.inputAudio);
         if (!argv.input && !process.stdin.isTTY) {
             let stdinData = "";
             process.stdin.setEncoding("utf8");
@@ -1650,11 +1703,17 @@ export class CLICommandFactory {
             }
             const trimmedData = stdinData.trim();
             if (!trimmedData) {
+                if (isSttOnly) {
+                    return "";
+                }
                 throw new Error("No input received from stdin");
             }
             return trimmedData;
         }
         else if (!argv.input) {
+            if (isSttOnly) {
+                return "";
+            }
             throw new Error('Input required. Use: neurolink generate "your prompt" or echo "prompt" | neurolink generate');
         }
         return argv.input;
@@ -1903,6 +1962,20 @@ export class CLICommandFactory {
             // Build multimodal input and output configuration
             const generateInput = CLICommandFactory.buildGenerateMultimodalInput(inputText, argv);
             const outputConfig = CLICommandFactory.buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions);
+            // Read audio file for STT if --input-audio is provided.
+            // NEW10: existsSync guard mirrors the stream handler so a missing file
+            // produces a friendly error here too instead of a raw ENOENT crash.
+            const inputAudioPath = enhancedOptions.inputAudio;
+            if (inputAudioPath && !fs.existsSync(inputAudioPath)) {
+                throw new Error(`--input-audio file not found: ${inputAudioPath}`);
+            }
+            const inputAudioBuffer = inputAudioPath
+                ? fs.readFileSync(inputAudioPath)
+                : undefined;
+            // m2: shared format helper (was duplicated in generate + stream
+            // handlers; now lives in src/lib/utils/audioFormatDetector.ts).
+            const { inferAudioFormatFromPath } = await import("../../lib/utils/audioFormatDetector.js");
+            const inputAudioFormat = inferAudioFormatFromPath(inputAudioPath);
             const runGenerate = () => sdk.generate({
                 input: generateInput,
                 csvOptions: {
@@ -1956,6 +2029,7 @@ export class CLICommandFactory {
                         enabled: true,
                         useAiResponse: true,
                         voice: enhancedOptions.ttsVoice,
+                        provider: enhancedOptions.ttsProvider,
                         format: enhancedOptions.ttsFormat || undefined,
                         speed: enhancedOptions.ttsSpeed,
                         quality: enhancedOptions.ttsQuality,
@@ -1963,6 +2037,16 @@ export class CLICommandFactory {
                         play: enhancedOptions.ttsPlay,
                     }
                     : undefined,
+                // STT configuration
+                stt: enhancedOptions.stt
+                    ? {
+                        enabled: true,
+                        provider: enhancedOptions.sttProvider,
+                        language: enhancedOptions.sttLanguage,
+                        ...(inputAudioBuffer && { audio: inputAudioBuffer }),
+                        ...(inputAudioFormat && { format: inputAudioFormat }),
+                    }
+                    : undefined,
             });
             const result = await runGenerate();
             // Handle successful result
@@ -2094,7 +2178,7 @@ export class CLICommandFactory {
         const pdfFiles = CLICommandFactory.processCliPDFFiles(argv.pdf);
         const videoFiles = CLICommandFactory.processCliVideoFiles(argv.video);
         const files = CLICommandFactory.processCliFiles(argv.file);
-        const runStream = () => sdk.stream({
+        const runStream = async () => sdk.stream({
             input: {
                 text: inputText,
                 ...(imageBuffers && { images: imageBuffers }),
@@ -2153,14 +2237,39 @@ export class CLICommandFactory {
                     enabled: true,
                     useAiResponse: true,
                     voice: enhancedOptions.ttsVoice,
-                    format: enhancedOptions.ttsFormat ||
-                        undefined,
+                    provider: enhancedOptions.ttsProvider,
+                    format: enhancedOptions.ttsFormat || undefined,
                     speed: enhancedOptions.ttsSpeed,
                     quality: enhancedOptions.ttsQuality,
                     output: enhancedOptions.ttsOutput,
                     play: enhancedOptions.ttsPlay,
                 }
                 : undefined,
+            // STT configuration. m2: shared format helper (was duplicated with
+            // the generate handler; now lives in audioFormatDetector.ts).
+            stt: enhancedOptions.stt
+                ? await (async () => {
+                    const streamSttAudioPath = enhancedOptions.inputAudio;
+                    // Fail fast on a missing --input-audio so a CLI typo doesn't
+                    // turn into a confusing provider/validation error later
+                    // (matches the generate path).
+                    if (streamSttAudioPath && !fs.existsSync(streamSttAudioPath)) {
+                        throw new Error(`--input-audio file not found: ${streamSttAudioPath}`);
+                    }
+                    const streamSttAudio = streamSttAudioPath
+                        ? fs.readFileSync(streamSttAudioPath)
+                        : undefined;
+                    const { inferAudioFormatFromPath: inferFmt } = await import("../../lib/utils/audioFormatDetector.js");
+                    const streamSttFormat = inferFmt(streamSttAudioPath);
+                    return {
+                        enabled: true,
+                        provider: enhancedOptions.sttProvider,
+                        language: enhancedOptions.sttLanguage,
+                        ...(streamSttAudio && { audio: streamSttAudio }),
+                        ...(streamSttFormat && { format: streamSttFormat }),
+                    };
+                })()
+                : undefined,
         });
         const stream = await runStream();
         const streamResult = await CLICommandFactory.processStreamWithTimeout(stream, options);
@@ -2277,9 +2386,13 @@ export class CLICommandFactory {
                 const isText = (o) => !!o &&
                     typeof o === "object" &&
                     typeof o.content === "string";
-                const isAudio = (o) => !!o &&
-                    typeof o === "object" &&
-                    o.type === "audio";
+                const isAudio = (o) => {
+                    if (!o || typeof o !== "object") {
+                        return false;
+                    }
+                    const t = o.type;
+                    return t === "audio" || t === "tts_audio";
+                };
                 const isImage = (o) => {
                     if (!o || typeof o !== "object") {
                         return false;
@@ -2433,6 +2546,10 @@ export class CLICommandFactory {
      * Handle stdin input for stream command
      */
     static async handleStdinInput(argv) {
+        // STT-only flow: --stt --input-audio <file> with no text prompt is now
+        // valid (the stream pipeline transcribes the audio and uses the result
+        // as the prompt). Skip the stdin/empty-input rejection in that case.
+        const isSttOnly = !!argv.stt && !!argv.inputAudio;
         if (!argv.input && !process.stdin.isTTY) {
             let stdinData = "";
             process.stdin.setEncoding("utf8");
@@ -2441,10 +2558,18 @@ export class CLICommandFactory {
             }
             argv.input = stdinData.trim();
             if (!argv.input) {
+                if (isSttOnly) {
+                    argv.input = "";
+                    return;
+                }
                 throw new Error("No input received from stdin");
             }
         }
         else if (!argv.input) {
+            if (isSttOnly) {
+                argv.input = "";
+                return;
+            }
             throw new Error('Input required. Use: neurolink stream "your prompt" or echo "prompt" | neurolink stream');
         }
     }

package/dist/cli/loop/optionsSchema.d.ts

@@ -4,4 +4,4 @@ import type { OptionSchema, TextGenerationOptions } from "../../lib/types/index.
  * This object provides metadata for validation and help text in the CLI loop.
  * It is derived from the main TextGenerationOptions interface to ensure consistency.
  */
-export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "tts" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials">, OptionSchema>;
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "tts" | "stt" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials">, OptionSchema>;

package/dist/cli/utils/audioFileUtils.d.ts

@@ -6,7 +6,7 @@
  *
  * @module cli/utils/audioFileUtils
  */
-import type { TTSResult, AudioSaveResult, AudioFormat } from "../../lib/types/index.js";
+import type { TTSResult, AudioSaveResult, TTSAudioFormat } from "../../lib/types/index.js";
 /**
  * Format file size in human-readable format
  *
@@ -33,7 +33,7 @@ export declare function ensureDirectoryExists(filePath: string): Promise<void>;
  * @param format - Audio format
  * @returns File extension (including dot)
  */
-export declare function getAudioExtension(format: AudioFormat): string;
+export declare function getAudioExtension(format: TTSAudioFormat): string;
 /**
  * Validate and normalize output path, adding extension if needed
  *
@@ -41,7 +41,7 @@ export declare function getAudioExtension(format: AudioFormat): string;
  * @param format - Audio format for extension
  * @returns Normalized output path
  */
-export declare function normalizeOutputPath(outputPath: string, format?: AudioFormat): string;
+export declare function normalizeOutputPath(outputPath: string, format?: TTSAudioFormat): string;
 /**
  * Save TTS audio result to a file
  *

package/dist/cli/utils/audioFileUtils.js

@@ -71,6 +71,10 @@ export function getAudioExtension(format) {
             return ".ogg";
         case "opus":
             return ".opus";
+        case "pcm16":
+            // Raw PCM16 (no RIFF/WAV header) — write to .pcm so consumers don't
+            // mistake it for a parseable WAV file.
+            return ".pcm";
         default:
             return ".mp3";
     }
@@ -86,7 +90,7 @@ export function normalizeOutputPath(outputPath, format = "mp3") {
     const resolvedPath = resolveOutputPath(outputPath);
     const ext = path.extname(resolvedPath).toLowerCase();
     // If no extension or wrong extension, add the correct one
-    const validExtensions = [".mp3", ".wav", ".ogg", ".opus"];
+    const validExtensions = [".mp3", ".wav", ".ogg", ".opus", ".pcm"];
     if (!ext || !validExtensions.includes(ext)) {
         return resolvedPath + getAudioExtension(format);
     }

package/dist/core/baseProvider.js

@@ -249,6 +249,11 @@ export class BaseProvider {
                 excludeTools: options.excludeTools,
                 skipToolPromptInjection: options.skipToolPromptInjection,
                 timeout: options.timeout,
+                stt: options.stt,
+                // Forward TTS options too — without this, the fake-streaming fallback
+                // path silently drops `tts` and the resulting StreamResult never
+                // produces a `tts_audio` chunk even when synthesis was requested.
+                tts: options.tts,
             };
             logger.debug(`Calling generate for fake streaming`, {
                 provider: this.providerName,
@@ -299,6 +304,23 @@ export class BaseProvider {
                             imageOutput: result.imageOutput,
                         };
                     }
+                    // Yield synthesized audio so callers using stream() with tts.enabled
+                    // still receive a tts_audio chunk on the fake-streaming fallback
+                    // path (matches the discriminator used by the real streaming path).
+                    if (result?.audio) {
+                        yield {
+                            type: "tts_audio",
+                            audio: {
+                                data: result.audio.buffer,
+                                format: result.audio.format,
+                                index: 0,
+                                isFinal: true,
+                                cumulativeSize: result.audio.size,
+                                voice: result.audio.voice,
+                                sampleRate: result.audio.sampleRate,
+                            },
+                        };
+                    }
                 })(),
                 usage: result?.usage,
                 provider: result?.provider,
@@ -587,7 +609,7 @@ export class BaseProvider {
             if (!options.tts) {
                 return this.enhanceResult(baseResult, options, startTime);
             }
-            baseResult.audio = await TTSProcessor.synthesize(textToSynthesize, options.provider ?? this.providerName, options.tts);
+            baseResult.audio = await TTSProcessor.synthesize(textToSynthesize, options.tts.provider ?? options.provider ?? this.providerName, options.tts);
         }
         catch (ttsError) {
             logger.error(`TTS synthesis failed in Mode 1 (direct input synthesis):`, ttsError);
@@ -691,20 +713,21 @@ export class BaseProvider {
         const { toolsUsed, toolExecutions } = this.extractToolInformation(generateResult);
         let enhancedResult = this.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options);
         enhancedResult = await this.synthesizeAIResponseIfNeeded(enhancedResult, options);
-        return this.enhanceResult(enhancedResult, options, startTime);
+        const finalResult = await this.enhanceResult(enhancedResult, options, startTime);
+        return finalResult;
     }
     async synthesizeAIResponseIfNeeded(enhancedResult, options) {
         if (!options.tts?.enabled || !options.tts?.useAiResponse) {
             return enhancedResult;
         }
         const aiResponse = enhancedResult.content;
-        const provider = options.provider ?? this.providerName;
-        if (!aiResponse || !provider) {
+        const ttsProvider = options.tts?.provider ?? options.provider ?? this.providerName;
+        if (!aiResponse || !ttsProvider) {
             logger.warn(`TTS synthesis skipped despite being enabled`, {
                 provider: this.providerName,
                 hasAiResponse: !!aiResponse,
                 aiResponseLength: aiResponse?.length ?? 0,
-                hasProvider: !!provider,
+                hasProvider: !!ttsProvider,
                 ttsConfig: {
                     enabled: options.tts?.enabled,
                     useAiResponse: options.tts?.useAiResponse,
@@ -716,7 +739,7 @@ export class BaseProvider {
             return enhancedResult;
         }
         try {
-            const ttsResult = await TTSProcessor.synthesize(aiResponse, provider, options.tts);
+            const ttsResult = await TTSProcessor.synthesize(aiResponse, ttsProvider, options.tts);
             return {
                 ...enhancedResult,
                 audio: ttsResult,

package/dist/factories/providerRegistry.d.ts

@@ -7,6 +7,20 @@ export declare class ProviderRegistry {
     private static registered;
     private static registrationPromise;
     private static options;
+    /**
+     * NEW4: per-handler registration outcomes for the realtime voice
+     * providers. `"ok"` = registered; any other string = the error message.
+     * Empty until the first `registerAllProviders()` call.
+     */
+    static realtimeRegistration: Record<string, "ok" | string>;
+    /**
+     * Returns a snapshot of voice provider registration outcomes so callers
+     * can detect at runtime which voice handlers are usable. Useful in
+     * health-check endpoints and CI startup probes.
+     */
+    static getRegistrationReport(): {
+        realtime: Record<string, "ok" | string>;
+    };
     /**
      * Register all providers with the factory
      */

package/dist/factories/providerRegistry.js

@@ -11,6 +11,20 @@ export class ProviderRegistry {
     static options = {
         enableManualMCP: false, // Default to disabled for safety
     };
+    /**
+     * NEW4: per-handler registration outcomes for the realtime voice
+     * providers. `"ok"` = registered; any other string = the error message.
+     * Empty until the first `registerAllProviders()` call.
+     */
+    static realtimeRegistration = {};
+    /**
+     * Returns a snapshot of voice provider registration outcomes so callers
+     * can detect at runtime which voice handlers are usable. Useful in
+     * health-check endpoints and CI startup probes.
+     */
+    static getRegistrationReport() {
+        return { realtime: { ...this.realtimeRegistration } };
+    }
     /**
      * Register all providers with the factory
      */
@@ -152,8 +166,7 @@ export class ProviderRegistry {
                 const { LlamaCppProvider } = await import("../providers/llamaCpp.js");
                 return new LlamaCppProvider(modelName, sdk, undefined, llamaCppCreds);
             }, process.env.LLAMACPP_MODEL || undefined, ["llamacpp", "llama.cpp", "llama-cpp"]);
-            logger.debug("All providers registered successfully");
-            this.registered = true;
+            logger.debug("All AI providers registered successfully");
             // ===== TTS HANDLER REGISTRATION =====
             try {
                 // Create handler instance and register explicitly
@@ -172,6 +185,128 @@ export class ProviderRegistry {
                 });
                 // Don't throw - TTS is optional functionality
             }
+            // New TTS providers
+            try {
+                const { TTSProcessor } = await import("../utils/ttsProcessor.js");
+                const { OpenAITTS } = await import("../voice/providers/OpenAITTS.js");
+                TTSProcessor.registerHandler("openai-tts", new OpenAITTS());
+            }
+            catch (err) {
+                logger.debug(`[ProviderRegistry] openai-tts registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            try {
+                const { TTSProcessor } = await import("../utils/ttsProcessor.js");
+                const { ElevenLabsTTS } = await import("../voice/providers/ElevenLabsTTS.js");
+                const elevenLabsHandler = new ElevenLabsTTS();
+                TTSProcessor.registerHandler("elevenlabs", elevenLabsHandler);
+                TTSProcessor.registerHandler("elevenlabs-tts", elevenLabsHandler);
+            }
+            catch (err) {
+                logger.debug(`[ProviderRegistry] elevenlabs registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            try {
+                const { TTSProcessor } = await import("../utils/ttsProcessor.js");
+                const { AzureTTS } = await import("../voice/providers/AzureTTS.js");
+                TTSProcessor.registerHandler("azure-tts", new AzureTTS());
+            }
+            catch (err) {
+                logger.debug(`[ProviderRegistry] azure-tts registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            // ===== STT HANDLER REGISTRATION =====
+            try {
+                const { STTProcessor } = await import("../utils/sttProcessor.js");
+                try {
+                    const { OpenAISTT } = await import("../voice/providers/OpenAISTT.js");
+                    const openAISTT = new OpenAISTT();
+                    STTProcessor.registerHandler("whisper", openAISTT);
+                    STTProcessor.registerHandler("openai-stt", openAISTT);
+                }
+                catch (err) {
+                    logger.debug(`[ProviderRegistry] whisper/openai-stt registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                try {
+                    const { DeepgramSTT } = await import("../voice/providers/DeepgramSTT.js");
+                    STTProcessor.registerHandler("deepgram", new DeepgramSTT());
+                }
+                catch (err) {
+                    logger.debug(`[ProviderRegistry] deepgram registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                try {
+                    const { GoogleSTT } = await import("../voice/providers/GoogleSTT.js");
+                    STTProcessor.registerHandler("google-stt", new GoogleSTT());
+                }
+                catch (err) {
+                    logger.debug(`[ProviderRegistry] google-stt registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                try {
+                    const { AzureSTT } = await import("../voice/providers/AzureSTT.js");
+                    STTProcessor.registerHandler("azure-stt", new AzureSTT());
+                }
+                catch (err) {
+                    logger.debug(`[ProviderRegistry] azure-stt registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                logger.debug("STT handlers registered successfully", {
+                    providers: ["whisper", "deepgram", "google-stt", "azure-stt"],
+                });
+            }
+            catch (sttError) {
+                logger.warn("Failed to register STT handlers - STT functionality will be unavailable", {
+                    error: sttError instanceof Error ? sttError.message : String(sttError),
+                });
+            }
+            // ===== REALTIME HANDLER REGISTRATION =====
+            try {
+                const { RealtimeProcessor } = await import("../voice/RealtimeVoiceAPI.js");
+                // M9 + NEW4: track per-handler registration outcomes so the final
+                // log accurately reflects which voice providers succeeded vs which
+                // were skipped — instead of unconditionally claiming "registered
+                // successfully" or hiding failures at debug level.
+                const realtimeOutcomes = {};
+                try {
+                    const { OpenAIRealtime } = await import("../voice/providers/OpenAIRealtime.js");
+                    RealtimeProcessor.registerHandler("openai-realtime", new OpenAIRealtime());
+                    realtimeOutcomes["openai-realtime"] = "ok";
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    realtimeOutcomes["openai-realtime"] = msg;
+                    // M9: promote per-handler failures to error level so users can
+                    // see which shipped voice provider failed to register at startup.
+                    logger.error(`[ProviderRegistry] openai-realtime registration failed: ${msg}`);
+                }
+                try {
+                    const { GeminiLive } = await import("../voice/providers/GeminiLive.js");
+                    RealtimeProcessor.registerHandler("gemini-live", new GeminiLive());
+                    realtimeOutcomes["gemini-live"] = "ok";
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    realtimeOutcomes["gemini-live"] = msg;
+                    logger.error(`[ProviderRegistry] gemini-live registration failed: ${msg}`);
+                }
+                // NEW4: report the actual per-handler outcomes instead of an
+                // unconditional success log. Stored on the registry so callers can
+                // introspect via getRegistrationReport().
+                ProviderRegistry.realtimeRegistration = realtimeOutcomes;
+                const skipped = Object.entries(realtimeOutcomes).filter(([, v]) => v !== "ok");
+                if (skipped.length === 0) {
+                    logger.info("[ProviderRegistry] Realtime handlers registered: openai-realtime, gemini-live");
+                }
+                else {
+                    logger.warn(`[ProviderRegistry] Realtime handlers partial: ${skipped.length} skipped`, { outcomes: realtimeOutcomes });
+                }
+            }
+            catch (realtimeError) {
+                logger.warn("Failed to register Realtime handlers - Realtime functionality will be unavailable", {
+                    error: realtimeError instanceof Error
+                        ? realtimeError.message
+                        : String(realtimeError),
+                });
+            }
+            // Mark registered ONLY after all blocks (AI + voice) attempted, so a
+            // subsequent registerAllProviders() call does not short-circuit when an
+            // optional handler block silently failed.
+            this.registered = true;
         }
         catch (error) {
             logger.error("Failed to register providers:", error);
@@ -191,6 +326,10 @@ export class ProviderRegistry {
         ProviderFactory.clearRegistrations();
         this.registered = false;
         this.registrationPromise = null;
+        // Reset realtime registration too — otherwise getRegistrationReport()
+        // can surface stale data from a previous run if the realtime block
+        // failed before reaching `realtimeRegistration = realtimeOutcomes`.
+        ProviderRegistry.realtimeRegistration = {};
     }
     /**
      * Set registry options (should be called before initialization)