@juspay/neurolink 9.66.0 → 9.67.0

package/dist/lib/voice/providers/CartesiaTTS.js

@@ -0,0 +1,189 @@
+/**
+ * Cartesia TTS Handler (synchronous /tts/bytes endpoint)
+ *
+ * Implements the standard `TTSHandler` synchronous-request contract on top
+ * of Cartesia's REST `/tts/bytes` endpoint. The pre-existing
+ * `adapters/tts/cartesiaHandler.ts` (`CartesiaStream`) targets the
+ * realtime WebSocket flow used by the voice server and does NOT implement
+ * `TTSHandler`; this file fills the gap so `nl.generate({ tts: { provider:
+ * "cartesia" } })` works through the same `TTSProcessor` dispatch as
+ * every other shipped TTS provider.
+ *
+ * @module voice/providers/CartesiaTTS
+ * @see https://docs.cartesia.ai/api-reference/tts/bytes
+ */
+import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
+import { withTimeout, TimeoutError } from "../../utils/async/withTimeout.js";
+import { logger } from "../../utils/logger.js";
+import { TTS_ERROR_CODES, TTSError } from "../../utils/ttsProcessor.js";
+const DEFAULT_BASE_URL = "https://api.cartesia.ai";
+const DEFAULT_API_VERSION = "2025-04-16";
+const DEFAULT_MODEL = "sonic-2";
+// Same default voice as the streaming handler — a publicly available
+// Cartesia voice id ("Bright Female"). Override per-call via TTSOptions.voice.
+const DEFAULT_VOICE_ID = "694f9389-aac1-45b6-b726-9d9369183238";
+const REQUEST_TIMEOUT_MS = 30_000;
+/**
+ * Cartesia synchronous TTS handler.
+ *
+ * Auth: `X-API-Key: ${CARTESIA_API_KEY}` + `Cartesia-Version` header.
+ */
+export class CartesiaTTS {
+    maxTextLength = 5000;
+    apiKey;
+    baseUrl;
+    apiVersion;
+    constructor(apiKey) {
+        const resolved = (apiKey ?? process.env.CARTESIA_API_KEY ?? "").trim();
+        this.apiKey = resolved.length > 0 ? resolved : null;
+        this.baseUrl = (process.env.CARTESIA_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.apiVersion = process.env.CARTESIA_API_VERSION ?? DEFAULT_API_VERSION;
+    }
+    isConfigured() {
+        return this.apiKey !== null;
+    }
+    async synthesize(text, options = {}) {
+        if (!this.apiKey) {
+            throw new TTSError({
+                code: TTS_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+                message: "CARTESIA_API_KEY not configured",
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+            });
+        }
+        const startTime = Date.now();
+        const voiceId = options.voice ?? process.env.CARTESIA_VOICE_ID ?? DEFAULT_VOICE_ID;
+        const requestedFormat = options.format ?? "mp3";
+        const { container, encoding, sampleRate } = this.mapOutputFormat(requestedFormat);
+        const cartesiaOpts = options;
+        const model = cartesiaOpts.model ?? process.env.CARTESIA_MODEL ?? DEFAULT_MODEL;
+        const body = {
+            model_id: model,
+            transcript: text,
+            voice: { mode: "id", id: voiceId },
+            output_format: {
+                container,
+                encoding,
+                sample_rate: sampleRate,
+            },
+            language: cartesiaOpts.language ?? "en",
+        };
+        let response;
+        try {
+            response = await withTimeout(fetch(`${this.baseUrl}/tts/bytes`, {
+                method: "POST",
+                headers: {
+                    "X-API-Key": this.apiKey,
+                    "Cartesia-Version": this.apiVersion,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            }), REQUEST_TIMEOUT_MS, `Cartesia request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`);
+        }
+        catch (err) {
+            if (err instanceof TimeoutError) {
+                throw new TTSError({
+                    code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                    message: err.message,
+                    category: ErrorCategory.NETWORK,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: true,
+                    originalError: err,
+                });
+            }
+            throw new TTSError({
+                code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                message: `Cartesia network error: ${err instanceof Error ? err.message : String(err)}`,
+                category: ErrorCategory.NETWORK,
+                severity: ErrorSeverity.HIGH,
+                retriable: true,
+                originalError: err instanceof Error ? err : undefined,
+            });
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            const retriable = response.status === 408 ||
+                response.status === 429 ||
+                response.status >= 500;
+            throw new TTSError({
+                code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                message: `Cartesia synthesis failed: ${response.status} — ${text}`,
+                category: retriable ? ErrorCategory.NETWORK : ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.HIGH,
+                retriable,
+                context: { status: response.status, voiceId, container, encoding },
+            });
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const audioBuffer = Buffer.from(arrayBuffer);
+        const latency = Date.now() - startTime;
+        const effectiveFormat = this.effectiveFormat(container, encoding);
+        const result = {
+            buffer: audioBuffer,
+            format: effectiveFormat,
+            size: audioBuffer.length,
+            voice: voiceId,
+            sampleRate,
+            metadata: {
+                latency,
+                provider: "cartesia",
+                model,
+                requestedFormat: options.format,
+                container,
+                encoding,
+            },
+        };
+        logger.info(`[CartesiaTTS] Synthesized ${audioBuffer.length} bytes in ${latency}ms`);
+        return result;
+    }
+    mapOutputFormat(format) {
+        switch (format) {
+            case "mp3":
+                return { container: "mp3", encoding: "mp3", sampleRate: 44_100 };
+            case "wav":
+                return { container: "wav", encoding: "pcm_s16le", sampleRate: 44_100 };
+            case "pcm16":
+                return { container: "raw", encoding: "pcm_s16le", sampleRate: 24_000 };
+            default:
+                // Cartesia only supports mp3 / wav / pcm16 today. Fail fast instead
+                // of silently downgrading so callers passing ogg / flac / m4a /
+                // opus / webm see a clear error rather than mislabeled MP3 bytes.
+                throw new TTSError({
+                    code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+                    message: `Cartesia does not support output format "${format}". Supported: mp3, wav, pcm16.`,
+                    category: ErrorCategory.VALIDATION,
+                    severity: ErrorSeverity.MEDIUM,
+                    retriable: false,
+                    context: {
+                        format,
+                        supported: ["mp3", "wav", "pcm16"],
+                    },
+                });
+        }
+    }
+    effectiveFormat(container, encoding) {
+        if (container === "mp3") {
+            return "mp3";
+        }
+        if (container === "wav") {
+            return "wav";
+        }
+        if (encoding === "pcm_s16le") {
+            return "pcm16";
+        }
+        // In practice mapOutputFormat() throws before we reach this branch
+        // (it only emits mp3/wav/raw containers from a validated input).
+        // Throwing here too means a future container/encoding combination
+        // surfaces clearly instead of returning mislabeled bytes as "mp3".
+        throw new TTSError({
+            code: TTS_ERROR_CODES.SYNTHESIS_FAILED,
+            message: `Unsupported Cartesia output combination: container=${container}, encoding=${encoding}`,
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+            context: { container, encoding },
+        });
+    }
+}
+//# sourceMappingURL=CartesiaTTS.js.map

package/dist/lib/workflow/config.d.ts

@@ -41,9 +41,9 @@ export declare const JudgeConfigSchema: z.ZodObject<{
     criteria: z.ZodArray<z.ZodString>;
     outputFormat: z.ZodEnum<{
         scores: "scores";
+        detailed: "detailed";
         ranking: "ranking";
         best: "best";
-        detailed: "detailed";
     }>;
     customPrompt: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
@@ -195,9 +195,9 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
         criteria: z.ZodArray<z.ZodString>;
         outputFormat: z.ZodEnum<{
             scores: "scores";
+            detailed: "detailed";
             ranking: "ranking";
             best: "best";
-            detailed: "detailed";
         }>;
         customPrompt: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;
@@ -219,9 +219,9 @@ export declare const WorkflowConfigSchema: z.ZodObject<{
         criteria: z.ZodArray<z.ZodString>;
         outputFormat: z.ZodEnum<{
             scores: "scores";
+            detailed: "detailed";
             ranking: "ranking";
             best: "best";
-            detailed: "detailed";
         }>;
         customPrompt: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;

package/dist/music/index.d.ts

@@ -7,7 +7,21 @@
  * Use `MusicProcessor.generate(provider, options)` to dispatch to the
  * registered handler for `provider`.
  *
+ * Importing this module also auto-registers every shipped music handler
+ * whose backing API key is present in `process.env`. Registration is
+ * idempotent and silently skipped if a provider is already registered or
+ * its constructor throws (e.g. missing optional native dependency).
+ *
  * @module music
  */
 export { MUSIC_ERROR_CODES, MusicError, MusicProcessor, } from "../utils/musicProcessor.js";
 export { BeatovenMusic, BeatovenMusic as BeatovenMusicHandler, } from "./providers/BeatovenMusic.js";
+export { ElevenLabsMusic, ElevenLabsMusic as ElevenLabsMusicHandler, } from "./providers/ElevenLabsMusic.js";
+export { LyriaMusic, LyriaMusic as LyriaMusicHandler, } from "./providers/LyriaMusic.js";
+export { ReplicateMusic, ReplicateMusic as ReplicateMusicHandler, } from "./providers/ReplicateMusic.js";
+/**
+ * Register every shipped music handler whose backing credentials are
+ * present in the environment. Safe to call multiple times — existing
+ * registrations are preserved.
+ */
+export declare function registerDefaultMusicHandlers(): void;

package/dist/music/index.js

@@ -7,7 +7,87 @@
  * Use `MusicProcessor.generate(provider, options)` to dispatch to the
  * registered handler for `provider`.
  *
+ * Importing this module also auto-registers every shipped music handler
+ * whose backing API key is present in `process.env`. Registration is
+ * idempotent and silently skipped if a provider is already registered or
+ * its constructor throws (e.g. missing optional native dependency).
+ *
  * @module music
  */
+import { logger } from "../utils/logger.js";
+import { MusicProcessor } from "../utils/musicProcessor.js";
 export { MUSIC_ERROR_CODES, MusicError, MusicProcessor, } from "../utils/musicProcessor.js";
+// ============================================================================
+// HANDLER CLASSES
+// ============================================================================
 export { BeatovenMusic, BeatovenMusic as BeatovenMusicHandler, } from "./providers/BeatovenMusic.js";
+export { ElevenLabsMusic, ElevenLabsMusic as ElevenLabsMusicHandler, } from "./providers/ElevenLabsMusic.js";
+export { LyriaMusic, LyriaMusic as LyriaMusicHandler, } from "./providers/LyriaMusic.js";
+export { ReplicateMusic, ReplicateMusic as ReplicateMusicHandler, } from "./providers/ReplicateMusic.js";
+// ============================================================================
+// AUTO-REGISTRATION
+// ============================================================================
+import { BeatovenMusic } from "./providers/BeatovenMusic.js";
+import { ElevenLabsMusic } from "./providers/ElevenLabsMusic.js";
+import { LyriaMusic } from "./providers/LyriaMusic.js";
+import { ReplicateMusic } from "./providers/ReplicateMusic.js";
+const MUSIC_HANDLER_CANDIDATES = [
+    { name: "beatoven", factory: () => new BeatovenMusic() },
+    {
+        name: "elevenlabs-music",
+        aliases: ["elevenlabs-sound"],
+        factory: () => new ElevenLabsMusic(),
+    },
+    { name: "lyria", factory: () => new LyriaMusic() },
+    {
+        name: "replicate",
+        aliases: ["musicgen"],
+        factory: () => new ReplicateMusic(),
+    },
+];
+/**
+ * Register every shipped music handler whose backing credentials are
+ * present in the environment. Safe to call multiple times — existing
+ * registrations are preserved.
+ */
+export function registerDefaultMusicHandlers() {
+    for (const { name, aliases, factory } of MUSIC_HANDLER_CANDIDATES) {
+        // Compute missingName / missingAliases separately so a pre-registered
+        // primary doesn't block alias backfill — keeps "musicgen" reachable
+        // when only "replicate" was wired up via another path (and likewise
+        // "elevenlabs-sound" vs "elevenlabs-music").
+        const missingName = !MusicProcessor.supports(name);
+        const missingAliases = (aliases ?? []).filter((alias) => !MusicProcessor.supports(alias));
+        if (!missingName && missingAliases.length === 0) {
+            continue;
+        }
+        try {
+            // Reuse the already-registered primary's handler for alias backfill
+            // when one exists — wiring an alias to a factory-fresh instance
+            // would silently diverge from the canonical primary's config.
+            let handler;
+            if (!missingName) {
+                handler = MusicProcessor.getHandler(name);
+            }
+            if (!handler) {
+                handler = factory();
+                if (!handler.isConfigured()) {
+                    continue;
+                }
+            }
+            if (missingName) {
+                MusicProcessor.registerHandler(name, handler);
+            }
+            for (const alias of missingAliases) {
+                MusicProcessor.registerHandler(alias, handler);
+            }
+        }
+        catch (err) {
+            logger.debug(`[music] ${name} auto-registration skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+// Run once at module import so consumers who follow the documented
+// `nl.generate(...)` flow get every configured handler without manually
+// calling `registerHandler`.
+registerDefaultMusicHandlers();

package/dist/types/avatar.d.ts

@@ -20,6 +20,13 @@ export type AvatarVideoFormat = "mp4" | "webm" | "mov";
  *   - MuseTalk (Replicate): single quality only; "hd" is no-op
  */
 export type AvatarQuality = "standard" | "hd";
+/**
+ * Known avatar provider identifiers shipped with NeuroLink.
+ *
+ * `(string & {})` keeps the union open for custom provider names
+ * registered via `AvatarProcessor.registerHandler()`.
+ */
+export type AvatarProviderName = "d-id" | "heygen" | "replicate" | "musetalk" | (string & {});
 /**
  * Options for avatar video generation.
  */
@@ -42,7 +49,7 @@ export type AvatarOptions = {
     /** Voice id passed through to the TTS provider when `text` is used. */
     voice?: string;
     /** Avatar provider override (e.g. "d-id", "heygen", "replicate"). */
-    provider?: string;
+    provider?: AvatarProviderName;
     /** Output quality preset. */
     quality?: AvatarQuality;
     /** Output format (default: "mp4"). */

package/dist/types/multimodal.d.ts

@@ -124,6 +124,13 @@ export type AudioContent = {
         language?: string;
     };
 };
+/**
+ * Known video provider identifiers shipped with NeuroLink.
+ *
+ * `(string & {})` keeps the union open for custom provider names
+ * registered via `VideoProcessor.registerHandler()`.
+ */
+export type VideoProviderName = "vertex" | "kling" | "runway" | "replicate" | (string & {});
 /**
  * Video output configuration options for video generation
  *
@@ -148,14 +155,15 @@ export type VideoOutputOptions = {
      */
     abortSignal?: AbortSignal;
     /**
-     * Override the video-gen provider. Defaults to "vertex" or to the LLM
-     * provider name if it is also a registered video handler.
+     * Override the video-gen provider. Defaults to `"vertex"` when omitted.
      *
      * Registered providers are managed via `VideoProcessor.registerHandler`
-     * (see src/lib/utils/videoProcessor.ts). Examples: "vertex", "kling",
-     * "runway", "replicate".
+     * (see src/lib/utils/videoProcessor.ts). Examples: `"vertex"`, `"kling"`,
+     * `"runway"`, `"replicate"`. An unknown provider throws
+     * `VIDEO_ERROR_CODES.PROVIDER_NOT_SUPPORTED` — there is no implicit
+     * fallback to the LLM provider name.
      */
-    provider?: string;
+    provider?: VideoProviderName;
     /**
      * Specific model to use within the provider. Provider-specific shape
      * (e.g. "veo-3.1-generate-001" for vertex; "atonamy/wan-alpha:..." for
@@ -164,8 +172,13 @@ export type VideoOutputOptions = {
     model?: string;
     /** Output resolution - "720p" (1280x720) or "1080p" (1920x1080) */
     resolution?: "720p" | "1080p";
-    /** Video duration in seconds (4, 6, or 8 seconds supported) */
-    length?: 4 | 6 | 8;
+    /**
+     * Video duration in seconds. Provider-specific support — Vertex Veo
+     * accepts 4 / 6 / 8 s, Kling and Runway accept 5 / 10 s, Replicate is
+     * model-specific. The type intentionally enumerates the common shipped
+     * values; pass any other positive number for custom Replicate models.
+     */
+    length?: 4 | 5 | 6 | 8 | 10 | (number & {});
     /** Aspect ratio - "9:16" for portrait, "16:9" for landscape, "1:1" for square */
     aspectRatio?: "9:16" | "16:9" | "1:1";
     /** Enable audio generation (default: true) */

package/dist/types/music.d.ts

@@ -27,6 +27,13 @@ export type MusicGenre = string;
  * "mysterious", "romantic", "epic".
  */
 export type MusicMood = string;
+/**
+ * Known music provider identifiers shipped with NeuroLink.
+ *
+ * `(string & {})` keeps the union open for custom provider names
+ * registered via `MusicProcessor.registerHandler()`.
+ */
+export type MusicProviderName = "beatoven" | "elevenlabs-music" | "elevenlabs-sound" | "lyria" | "replicate" | "musicgen" | (string & {});
 /**
  * Options for music generation requests.
  */
@@ -44,7 +51,7 @@ export type MusicOptions = {
     /** Tempo in BPM (provider-specific support). */
     tempo?: number;
     /** Override the music provider (e.g. "beatoven", "elevenlabs-music", "lyria", "replicate"). */
-    provider?: string;
+    provider?: MusicProviderName;
     /** Reference audio for melody / style guidance (Buffer or path). */
     referenceAudio?: Buffer | string;
     /** Output file path (optional — buffer is always returned in result). */

package/dist/types/tts.d.ts

@@ -17,6 +17,14 @@ export type TTSAudioFormat = "mp3" | "wav" | "ogg" | "opus" | "m4a" | "flac" | "
  * TTS quality settings
  */
 export type TTSQuality = "standard" | "hd";
+/**
+ * Known TTS provider identifiers shipped with NeuroLink.
+ *
+ * The `(string & {})` intersection keeps the union open for custom
+ * provider names registered via `TTSProcessor.registerHandler()` while
+ * still surfacing the built-in choices in editor autocomplete.
+ */
+export type TTSProviderName = "google-ai" | "vertex" | "openai-tts" | "elevenlabs" | "elevenlabs-tts" | "azure-tts" | "fish-audio" | "cartesia" | (string & {});
 /**
  * TTS configuration options
  */
@@ -69,7 +77,7 @@ export type TTSOptions = {
     /** Auto-play audio after generation (default: false) */
     play?: boolean;
     /** Override TTS provider (e.g., "elevenlabs", "openai-tts", "azure-tts") */
-    provider?: string;
+    provider?: TTSProviderName;
 };
 /**
  * TTS audio result returned from generation

package/dist/utils/avatarProcessor.d.ts

@@ -56,7 +56,13 @@ export declare class AvatarProcessor {
      * List the names of all registered providers.
      */
     static listProviders(): string[];
-    private static getHandler;
+    /**
+     * Get a registered avatar handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
+     */
+    static getHandler(providerName: string): AvatarHandler | undefined;
     private static buildSpanAttributes;
     /**
      * Generate an avatar video via the registered handler.

package/dist/utils/avatarProcessor.js

@@ -80,6 +80,12 @@ export class AvatarProcessor {
     static listProviders() {
         return Array.from(this.handlers.keys());
     }
+    /**
+     * Get a registered avatar handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
+     */
     static getHandler(providerName) {
         return this.handlers.get(providerName.toLowerCase());
     }

package/dist/utils/musicProcessor.d.ts

@@ -55,7 +55,13 @@ export declare class MusicProcessor {
      * List the names of all registered providers.
      */
     static listProviders(): string[];
-    private static getHandler;
+    /**
+     * Get a registered music handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
+     */
+    static getHandler(providerName: string): MusicHandler | undefined;
     private static buildSpanAttributes;
     /**
      * Generate a music track via the registered handler.

package/dist/utils/musicProcessor.js

@@ -79,6 +79,12 @@ export class MusicProcessor {
     static listProviders() {
         return Array.from(this.handlers.keys());
     }
+    /**
+     * Get a registered music handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
+     */
     static getHandler(providerName) {
         return this.handlers.get(providerName.toLowerCase());
     }

package/dist/utils/parameterValidation.js

@@ -435,7 +435,11 @@ function toValidationError(error) {
  * Valid video generation options
  */
 const VALID_VIDEO_RESOLUTIONS = ["720p", "1080p"];
-const VALID_VIDEO_LENGTHS = [4, 6, 8];
+// Cross-provider literal whitelist: Vertex Veo uses 4 / 6 / 8 s, Kling and
+// Runway use 5 / 10 s. The handler-level adapter is the source of truth
+// for per-provider rejection (e.g. Runway 400 for length=4); this gate
+// just rejects obviously invalid integers.
+const VALID_VIDEO_LENGTHS = [4, 5, 6, 8, 10];
 const VALID_VIDEO_ASPECT_RATIOS = ["9:16", "16:9"];
 const MAX_VIDEO_PROMPT_LENGTH = 500;
 const MAX_VIDEO_IMAGE_SIZE = 10 * 1024 * 1024; // 10MB

package/dist/utils/sttProcessor.d.ts

@@ -63,13 +63,15 @@ export declare class STTProcessor {
      */
     static registerHandler(providerName: string, handler: STTHandler): void;
     /**
-     * Get a registered STT handler by provider name
+     * Get a registered STT handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
      *
-     * @private
      * @param providerName - Provider identifier
      * @returns Handler instance or undefined if not registered
      */
-    private static getHandler;
+    static getHandler(providerName: string): STTHandler | undefined;
     /**
      * Check if a provider is supported (has a registered STT handler)
      *

package/dist/utils/sttProcessor.js

@@ -80,9 +80,11 @@ export class STTProcessor {
         logger.debug(`[STTProcessor] Registered STT handler for provider: ${normalizedName}`);
     }
     /**
-     * Get a registered STT handler by provider name
+     * Get a registered STT handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
      *
-     * @private
      * @param providerName - Provider identifier
      * @returns Handler instance or undefined if not registered
      */

package/dist/utils/ttsProcessor.d.ts

@@ -90,13 +90,16 @@ export declare class TTSProcessor {
      */
     static registerHandler(providerName: string, handler: TTSHandler): void;
     /**
-     * Get a registered TTS handler by provider name
+     * Get a registered TTS handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases —
+     * see `src/lib/voice/index.ts:registerDefaultTTSHandlers`.
      *
-     * @private
      * @param providerName - Provider identifier
      * @returns Handler instance or undefined if not registered
      */
-    private static getHandler;
+    static getHandler(providerName: string): TTSHandler | undefined;
     /**
      * Check if a provider is supported (has a registered TTS handler)
      *

package/dist/utils/ttsProcessor.js

@@ -107,9 +107,12 @@ export class TTSProcessor {
         logger.debug(`[TTSProcessor] Registered TTS handler for provider: ${normalizedName}`);
     }
     /**
-     * Get a registered TTS handler by provider name
+     * Get a registered TTS handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases —
+     * see `src/lib/voice/index.ts:registerDefaultTTSHandlers`.
      *
-     * @private
      * @param providerName - Provider identifier
      * @returns Handler instance or undefined if not registered
      */

package/dist/voice/RealtimeVoiceAPI.d.ts

@@ -49,9 +49,12 @@ export declare class RealtimeProcessor {
      */
     static registerHandler(providerName: string, handler: RealtimeHandler): void;
     /**
-     * Get a registered Realtime handler by provider name
+     * Get a registered Realtime handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
      */
-    private static getHandler;
+    static getHandler(providerName: string): RealtimeHandler | undefined;
     /**
      * Check if a provider is supported
      */

package/dist/voice/RealtimeVoiceAPI.js

@@ -65,7 +65,10 @@ export class RealtimeProcessor {
         logger.debug(`[RealtimeProcessor] Registered Realtime handler for provider: ${normalizedName}`);
     }
     /**
-     * Get a registered Realtime handler by provider name
+     * Get a registered Realtime handler by provider name.
+     *
+     * Exposed publicly so module-level auto-registration code can reuse an
+     * already-registered primary handler when backfilling its aliases.
      */
     static getHandler(providerName) {
         const normalizedName = providerName.toLowerCase();