voice-runtime 1.1.0 → 1.2.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import WebSocket from 'ws';
+import * as WebSocket from 'ws';
+import WebSocket__default from 'ws';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { AddressInfo } from 'node:net';
 
@@ -230,6 +231,9 @@ declare class MemorySessionQuotaExceededError extends DurableError {
 declare const TVIC_ERROR_CODES: Readonly<{
     readonly providerAuthFailed: "provider.auth_failed";
     readonly providerRateLimited: "provider.rate_limited";
+    readonly providerQuotaExceeded: "provider.quota_exceeded";
+    readonly providerTransportWriteFailed: "provider.transport_write_failed";
+    readonly providerTransportTimeout: "provider.transport_timeout";
     readonly providerModelUnsupported: "provider.model_unsupported";
     readonly providerVoiceUnsupported: "provider.voice_unsupported";
     readonly providerInputRejected: "provider.input_rejected";
@@ -251,7 +255,10 @@ declare const TVIC_ERROR_CODES: Readonly<{
 declare const TVIC_ERROR_CODE_ALIASES: Readonly<{
     readonly "stt.provider.auth_failed": "provider.auth_failed";
     readonly "stt.provider.rate_limited": "provider.rate_limited";
-    readonly "stt.provider.quota_exceeded": "provider.rate_limited";
+    readonly "stt.provider.quota_exceeded": "provider.quota_exceeded";
+    readonly "stt.transport.write_failed": "provider.transport_write_failed";
+    readonly "stt.send_timeout": "provider.transport_timeout";
+    readonly "stt.audio_write_timeout": "provider.transport_timeout";
     readonly "stt.provider.invalid_request": "provider.invalid_request";
     readonly "stt.provider.input_rejected": "provider.input_rejected";
     readonly "stt.provider.session_expired": "provider.session_expired";
@@ -278,9 +285,11 @@ declare const PROVIDER_NAMES: {
     readonly twilio: "twilio-media-streams";
     readonly deepgram: "deepgram";
     readonly cartesia: "cartesia";
+    readonly cartesiaStt: "cartesia-stt";
     readonly elevenlabs: "elevenlabs";
     readonly elevenlabsStt: "elevenlabs-stt-realtime";
     readonly sarvam: "sarvam";
+    readonly sarvamTts: "sarvam-tts";
     readonly assemblyaiStt: "assemblyai-stt";
     readonly sonioxStt: "soniox-stt";
     readonly groq: "groq-chat-completions";
@@ -294,6 +303,7 @@ declare const PROVIDER_ERROR_CODES: {
     readonly elevenlabsTts: "elevenlabs.tts.error";
     readonly elevenlabsStt: "elevenlabs.stt.error";
     readonly sarvamStt: "sarvam.stt.error";
+    readonly sarvamTts: "sarvam.tts.error";
     readonly assemblyaiStt: "assemblyai.stt.error";
     readonly sonioxStt: "soniox.stt.error";
     readonly groqChat: "groq.chat.error";
@@ -304,10 +314,12 @@ declare const PROVIDER_ERROR_CODES: {
     readonly openaiHttp: "openai.http_error";
     readonly openaiResponseFailed: "openai.response.failed";
     readonly webClientAudio: "web_client_audio.error";
+    readonly cartesiaStt: "cartesia.stt.error";
 };
 /** Stable runtime taxonomy consumed by reconnect and call-failure policy. */
 declare const STT_ERROR_CODES: {
-    readonly transportWriteFailed: "stt.transport.write_failed";
+    readonly transportWriteFailed: "provider.transport_write_failed";
+    readonly transportTimeout: "provider.transport_timeout";
     readonly unexpectedEof: "stt.transport.unexpected_eof";
     readonly connectFailed: "stt.transport.connect_failed";
     readonly connectTimeout: "stt.transport.connect_timeout";
@@ -315,13 +327,13 @@ declare const STT_ERROR_CODES: {
     readonly invalidRequest: "provider.invalid_request";
     readonly inputRejected: "provider.input_rejected";
     readonly rateLimited: "provider.rate_limited";
-    readonly quotaExceeded: "provider.rate_limited";
+    readonly quotaExceeded: "provider.quota_exceeded";
     readonly serviceUnavailable: "provider.upstream_failed";
     readonly providerInternal: "provider.upstream_failed";
     readonly protocolError: "provider.protocol_invalid";
     readonly sessionExpired: "provider.session_expired";
     readonly streamEnded: "stt.stream_ended";
-    readonly audioWriteTimeout: "stt.audio_write_timeout";
+    readonly audioWriteTimeout: "provider.transport_timeout";
     readonly closeTimeout: "stt.close_timeout";
     readonly bufferOverflow: "stt.reconnect.buffer_overflow";
     readonly sessionBufferOverflow: "stt.session_buffer_overflow";
@@ -912,6 +924,12 @@ interface ProviderStreamingCapabilities {
     /** Streaming is supported by the provider protocol, not emulated by chunked requests. */
     readonly native: boolean;
 }
+interface ProviderBatchCapabilities {
+    /** Accepts one complete input payload instead of requiring a live stream. */
+    readonly input: boolean;
+    /** Returns one complete output payload instead of incremental events. */
+    readonly output: boolean;
+}
 interface ProviderCancellationCapabilities {
     /** Active provider work can be stopped rather than merely ignored by TVIC. */
     readonly request: boolean;
@@ -946,11 +964,13 @@ interface ProviderPlayoutCapabilities {
  */
 interface ProviderCapabilities {
     readonly streaming: ProviderStreamingCapabilities;
+    readonly batch?: ProviderBatchCapabilities;
     readonly cancellation: ProviderCancellationCapabilities;
     readonly transports: readonly ProviderTransport[];
     readonly audio?: ProviderAudioCapabilities;
     readonly languages?: readonly string[];
     readonly models?: readonly string[];
+    readonly batchModels?: readonly string[];
     readonly voices?: readonly string[];
     readonly turnDetection?: readonly TurnDetectionMode[];
     readonly tools?: ProviderToolCapabilities;
@@ -979,12 +999,14 @@ type RequiredProviderCapabilities<T extends object> = {
 interface ProviderRequirements {
     readonly kind: ProviderKind;
     readonly streaming?: RequiredProviderCapabilities<ProviderStreamingCapabilities>;
+    readonly batch?: RequiredProviderCapabilities<ProviderBatchCapabilities>;
     readonly cancellation?: RequiredProviderCapabilities<ProviderCancellationCapabilities>;
     readonly transport?: ProviderTransport;
     readonly inputFormat?: AudioFormat;
     readonly outputFormat?: AudioFormat;
     readonly language?: string;
     readonly model?: string;
+    readonly batchModel?: string;
     readonly voice?: string;
     readonly turnDetection?: TurnDetectionMode;
     readonly functionCalling?: boolean;
@@ -994,7 +1016,7 @@ interface ProviderRequirements {
     readonly region?: string;
     readonly dataPolicy?: ProviderDataPolicy;
 }
-type ProviderCompatibilityIssueCode = "kind.unsupported" | "streaming.unsupported" | "cancellation.unsupported" | "transport.unsupported" | "audio.input_unsupported" | "audio.output_unsupported" | "language.unsupported" | "provider.model_unsupported" | "provider.voice_unsupported" | "turn_detection.unsupported" | "tools.unsupported" | "playout.unsupported" | "call_control.unsupported" | "region.unsupported" | "data_policy.unsupported";
+type ProviderCompatibilityIssueCode = "kind.unsupported" | "streaming.unsupported" | "batch.unsupported" | "cancellation.unsupported" | "transport.unsupported" | "audio.input_unsupported" | "audio.output_unsupported" | "language.unsupported" | "provider.model_unsupported" | "provider.voice_unsupported" | "turn_detection.unsupported" | "tools.unsupported" | "playout.unsupported" | "call_control.unsupported" | "region.unsupported" | "data_policy.unsupported";
 interface ProviderCompatibilityIssue {
     readonly code: ProviderCompatibilityIssueCode;
     readonly requirement: string;
@@ -1102,6 +1124,37 @@ interface SttOpenRequest {
     readonly metadata?: Readonly<Record<string, unknown>>;
     readonly signal?: AbortSignal;
 }
+type SttBatchTimestampGranularity = "word";
+/** A complete audio payload for a non-streaming transcription request. */
+interface SttBatchTranscriptionRequest {
+    /** Container bytes, or raw bytes when `format` is supplied. */
+    readonly audio: Uint8Array;
+    /** Optional filename used as the multipart upload filename and format hint. */
+    readonly fileName?: string;
+    /** Optional MIME type for the multipart file part. */
+    readonly mimeType?: string;
+    /** Raw PCM format. Omit this when `audio` contains a self-describing container. */
+    readonly format?: AudioFormat;
+    readonly language?: string;
+    readonly model?: string;
+    readonly timestampGranularities?: readonly SttBatchTimestampGranularity[];
+    readonly allowUnknownModel?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface SttBatchWord {
+    readonly word: string;
+    readonly startMs: number;
+    readonly endMs: number;
+}
+/** A complete transcript returned by a batch STT provider. */
+interface SttBatchTranscription {
+    readonly text: string;
+    readonly requestId?: string;
+    readonly language?: string;
+    readonly durationMs?: number;
+    readonly words?: readonly SttBatchWord[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
 type SttCommitMode = "provider" | "none";
 /**
  * Origin of audio offsets emitted by an STT stream. Reconnectable streams must
@@ -1121,6 +1174,8 @@ interface SttStream {
 interface SpeechToTextProvider extends Provider {
     readonly kind: "stt";
     open(request: SttOpenRequest): Promise<SttStream>;
+    /** Optional complete-file transcription capability. */
+    transcribe?(request: SttBatchTranscriptionRequest): Promise<SttBatchTranscription>;
 }
 
 interface TtsSessionOpenRequest {
@@ -1971,14 +2026,18 @@ declare function isTerminalTurn(turn: Turn): turn is TerminalTurn;
 
 interface ProviderClock {
     now(): Timestamp;
+    /** Optional for backward-compatible injected clocks; adapters fall back to performance.now(). */
+    monotonicNowMs?(): number;
 }
 
+declare const TWILIO_MAX_AUDIO_EVENT_BYTES = 65536;
+
 interface TwilioMediaStreamSocket {
     readonly readyState: number;
     readonly bufferedAmount?: number;
     send(data: string): void;
     close(code?: number, reason?: string): void;
-    on(event: "message", handler: (data: WebSocket.RawData) => void): this;
+    on(event: "message", handler: (data: WebSocket__default.RawData) => void): this;
     on(event: "close", handler: () => void): this;
     on(event: "error", handler: (error: Error) => void): this;
 }
@@ -2052,21 +2111,23 @@ declare class TwilioMediaStreamsProvider implements TelephonyProvider {
 declare function createTwilioMediaStreamsProvider(): TwilioMediaStreamsProvider;
 
 declare const WEB_CLIENT_AUDIO_CLOSE_CODES: {
-    readonly protocol: 4400;
-    readonly heartbeatTimeout: 4408;
-    readonly superseded: 4409;
-    readonly maxDuration: 4410;
-    readonly resourceLimit: 4413;
-    readonly operatorTerminated: 4500;
+    protocol: number;
+    heartbeatTimeout: number;
+    superseded: number;
+    maxDuration: number;
+    resourceLimit: number;
+    operatorTerminated: number;
 };
 declare const WEB_CLIENT_AUDIO_DEFAULTS: {
-    readonly heartbeatIntervalMs: 5000;
-    readonly heartbeatTimeoutMs: 10000;
-    readonly maxSessionDurationMs: number;
-    readonly maxPendingEvents: 512;
-    readonly maxInputFramesPerSecond: 200;
-    readonly maxPendingAcks: 128;
+    heartbeatIntervalMs: number;
+    heartbeatTimeoutMs: number;
+    maxSessionDurationMs: number;
+    maxPendingEvents: number;
+    maxInputFramesPerSecond: number;
+    maxPendingAcks: number;
 };
+declare const WEB_CLIENT_AUDIO_ACK_RETENTION_MS = 60000;
+
 interface WebClientAudioSocket {
     readonly readyState: number;
     readonly bufferedAmount?: number;
@@ -2113,11 +2174,9 @@ interface WebClientAudioCallHandleOptions {
     readonly onConnectionEvent?: (event: ConnectionObservabilityEvent) => void;
     readonly onClosed?: () => void;
 }
-declare class WebClientAudioCallHandle implements CallHandle {
-    #private;
+interface WebClientAudioCallHandle extends CallHandle {
     readonly callId: CallId;
     readonly events: AsyncIterable<InboundMediaEvent>;
-    constructor(options: WebClientAudioCallHandleOptions);
     send(event: OutputMediaEvent): Promise<boolean>;
     deliverText(turnId: TurnId, sequence: number, text: string): Promise<boolean>;
     clear(): Promise<void>;
@@ -2125,45 +2184,16 @@ declare class WebClientAudioCallHandle implements CallHandle {
     terminate(code: number, reason: string): void;
     confirmPlayout(markId: string, timeoutMs: number): Promise<boolean>;
 }
+declare const WebClientAudioCallHandle: {
+    new (options: WebClientAudioCallHandleOptions): WebClientAudioCallHandle;
+};
 interface WebClientAudioProviderOptions extends Omit<WebClientAudioCallHandleOptions, "socket" | "callId" | "sessionId" | "onClosed" | "expectedMode"> {
 }
-declare class WebClientAudioProvider implements TelephonyProvider {
-    #private;
+interface WebClientAudioProvider extends TelephonyProvider {
     readonly name: "web-client-audio";
-    readonly kind = "telephony";
-    readonly version = "0.1.0";
-    readonly capabilities: {
-        streaming: {
-            input: true;
-            output: true;
-            native: true;
-        };
-        cancellation: {
-            request: true;
-            output: true;
-            buffer: true;
-            truncation: false;
-        };
-        transports: "websocket"[];
-        audio: {
-            input: {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 16000;
-                readonly channels: 1;
-            }[];
-            output: {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 16000;
-                readonly channels: 1;
-            }[];
-        };
-        playout: {
-            clearBuffer: true;
-            acknowledgement: true;
-            position: false;
-        };
-    };
-    constructor(options?: WebClientAudioProviderOptions);
+    readonly kind: "telephony";
+    readonly version: "0.1.0";
+    readonly capabilities: ProviderCapabilities;
     dial(): Promise<CallHandle>;
     accept(ctx: Parameters<TelephonyProvider["accept"]>[0]): Promise<CallHandle>;
     attachWebSocket(socket: WebClientAudioSocket, callId: CallId, sessionId: SessionId): void;
@@ -2173,6 +2203,9 @@ declare class WebClientAudioProvider implements TelephonyProvider {
     hangup(callId: CallId): Promise<void>;
     supersede(callId: CallId): Promise<void>;
 }
+declare const WebClientAudioProvider: {
+    new (options?: WebClientAudioProviderOptions): WebClientAudioProvider;
+};
 declare function createWebClientAudioProvider(options?: WebClientAudioProviderOptions): WebClientAudioProvider;
 
 interface DeepgramSttProviderOptions {
@@ -2183,8 +2216,9 @@ interface DeepgramSttProviderOptions {
     readonly endpointingMs?: number;
     readonly vadEvents?: boolean;
     readonly punctuate?: boolean;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
+declare const MAX_PROVIDER_AUDIO_OFFSET_MS = 86400000;
 declare class DeepgramSttProvider implements SpeechToTextProvider {
     #private;
     readonly name: "deepgram";
@@ -2219,6 +2253,72 @@ declare class DeepgramSttProvider implements SpeechToTextProvider {
 }
 declare function createDeepgramSttProvider(options: DeepgramSttProviderOptions): DeepgramSttProvider;
 
+type CartesiaSttMode = "manual" | "auto";
+interface CartesiaSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly batchUrl?: string;
+    readonly modelId?: string;
+    readonly batchModelId?: string;
+    readonly allowUnknownModel?: boolean;
+    /** `manual` uses `/stt/websocket`; `auto` uses Ink's native turn detector. */
+    readonly mode?: CartesiaSttMode;
+    /** Used when a session request does not provide a language. Ink 2 can auto-detect. */
+    readonly language?: string;
+    readonly turnStartThreshold?: number;
+    readonly turnEagerEndThreshold?: number;
+    readonly turnEndThreshold?: number;
+    readonly turnEndTimeoutMs?: number;
+    readonly clock?: ProviderClock;
+    readonly fetchImpl?: typeof fetch;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+declare class CartesiaSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "cartesia-stt";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        batch: {
+            input: true;
+            output: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: ("http" | "websocket")[];
+        audio: {
+            input: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly ["ink-2", "ink-preview", "ink-whisper-2025-06-04"];
+        batchModels: readonly ["ink-whisper"];
+        turnDetection: ("manual" | "provider")[];
+        metadata: {
+            realtimeModels: string[];
+            autoTurnModels: string[];
+            batchModels: string[];
+            partialTranscripts: boolean;
+            manualFinalize: boolean;
+        };
+    };
+    constructor(options: CartesiaSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+    transcribe(request: SttBatchTranscriptionRequest): Promise<SttBatchTranscription>;
+}
+declare function createCartesiaSttProvider(options: CartesiaSttProviderOptions): CartesiaSttProvider;
+
 type SarvamOutputMode = "transcribe" | "translate" | "verbatim" | "translit" | "codemix";
 interface SarvamSttProviderOptions {
     readonly apiKey: string;
@@ -2230,7 +2330,7 @@ interface SarvamSttProviderOptions {
     readonly flushSignal?: boolean;
     readonly inputAudioCodec?: "pcm_s16le" | "pcm_l16" | "pcm_raw";
     readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
 declare class SarvamSttProvider implements SpeechToTextProvider {
     #private;
@@ -2263,7 +2363,7 @@ declare class SarvamSttProvider implements SpeechToTextProvider {
             })[];
         };
         models: readonly ["saaras:v3", "saaras:v4"];
-        turnDetection: ("vad" | "manual")[];
+        turnDetection: ("manual" | "vad")[];
         metadata: {
             interimResults: boolean;
             outputModes: string[];
@@ -2274,24 +2374,39 @@ declare class SarvamSttProvider implements SpeechToTextProvider {
 }
 declare function createSarvamSttProvider(options: SarvamSttProviderOptions): SarvamSttProvider;
 
-type ElevenLabsSttCommitStrategy = "manual" | "vad";
-interface ElevenLabsSttProviderOptions {
+interface SarvamTtsProviderOptions {
     readonly apiKey: string;
     readonly url?: string;
-    readonly allowUnknownModel?: boolean;
+    readonly voiceId?: string;
     readonly modelId?: string;
-    readonly commitStrategy?: ElevenLabsSttCommitStrategy;
-    readonly includeTimestamps?: boolean;
-    readonly includeLanguageDetection?: boolean;
-    readonly vadThreshold?: number;
-    readonly vadSilenceThresholdSecs?: number;
+    readonly language?: string;
+    /** Provider pace. Sarvam v3 accepts 0.5 through 2.0. */
+    readonly pace?: number;
+    /** Provider temperature. Sarvam's streaming schema accepts 0.01 through 1.0. */
+    readonly temperature?: number;
+    readonly minBufferSize?: number;
+    readonly maxChunkLength?: number;
+    readonly pronunciationDictionaryId?: string;
+    readonly keepAliveIntervalMs?: number;
     readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
-declare class ElevenLabsSttProvider implements SpeechToTextProvider {
+interface SarvamTtsStreamOptions {
+    readonly clock: ProviderClock;
+    readonly model: string;
+    readonly language: string;
+    readonly voice: string;
+    readonly pace: number;
+    readonly temperature: number;
+    readonly minBufferSize: number;
+    readonly maxChunkLength: number;
+    readonly pronunciationDictionaryId?: string;
+    readonly keepAliveIntervalMs: number;
+}
+declare class SarvamTtsProvider implements IncrementalTextToSpeechProvider {
     #private;
-    readonly name: "elevenlabs-stt-realtime";
-    readonly kind = "stt";
+    readonly name: "sarvam-tts";
+    readonly kind = "tts";
     readonly version = "0.1.0";
     readonly capabilities: {
         streaming: {
@@ -2307,67 +2422,62 @@ declare class ElevenLabsSttProvider implements SpeechToTextProvider {
         };
         transports: "websocket"[];
         audio: {
-            input: readonly [{
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 8000;
-                readonly channels: 1;
-            }, {
+            output: {
                 readonly encoding: "pcm_s16le";
                 readonly sampleRateHz: 16000;
                 readonly channels: 1;
-            }, {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 22050;
-                readonly channels: 1;
-            }, {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 24000;
-                readonly channels: 1;
-            }, {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 44100;
-                readonly channels: 1;
-            }, {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 48000;
-                readonly channels: 1;
-            }];
+            }[];
         };
-        models: readonly ["scribe_v2_realtime"];
-        turnDetection: ("vad" | "manual")[];
+        languages: readonly ["hi-IN", "bn-IN", "ta-IN", "te-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "pa-IN", "od-IN", "en-IN"];
+        models: readonly ["bulbul:v3"];
+        voices: readonly ["shubh", "aditya", "ritu", "priya", "neha", "rahul", "pooja", "rohan", "simran", "kavya", "amit", "dev", "ishita", "shreya", "ratan", "varun", "manan", "sumit", "roopa", "kabir", "aayan", "ashutosh", "advait", "anand", "tanya", "tarun", "sunny", "mani", "gokul", "vijay", "shruti", "suhani", "mohit", "kavitha", "rehan", "soham", "rupali"];
         metadata: {
-            realtimeModel: string;
-            partialTranscripts: boolean;
+            outputAudioCodec: string;
+            outputSampleRateHz: number;
+            completionEvent: string;
         };
     };
-    constructor(options: ElevenLabsSttProviderOptions);
-    open(request: SttOpenRequest): Promise<SttStream>;
+    constructor(options: SarvamTtsProviderOptions);
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+    openSession(request: TtsSessionOpenRequest): Promise<SarvamTtsStream>;
 }
-declare function createElevenLabsSttProvider(options: ElevenLabsSttProviderOptions): ElevenLabsSttProvider;
+declare class SarvamTtsStream implements TtsSession {
+    #private;
+    readonly events: AsyncIterable<TtsEvent>;
+    constructor(socket: WebSocket__default, request: TtsSessionOpenRequest, options: SarvamTtsStreamOptions);
+    sendText(text: string): Promise<void>;
+    flush(): Promise<TtsFlushResult>;
+    finish(): Promise<void>;
+    keepAlive(): Promise<void>;
+    cancel(): Promise<void>;
+}
+declare function createSarvamTtsProvider(options: SarvamTtsProviderOptions): SarvamTtsProvider;
 
-interface AssemblyAiSttProviderOptions {
+interface SarvamTtsHttpProviderOptions {
     readonly apiKey: string;
     readonly url?: string;
+    readonly voiceId?: string;
     readonly modelId?: string;
-    readonly allowUnknownModel?: boolean;
-    readonly formatTurns?: boolean;
-    readonly prompt?: string;
-    readonly languageDetection?: boolean;
-    readonly minTurnSilenceMs?: number;
-    readonly maxTurnSilenceMs?: number;
+    readonly language?: string;
+    /** Provider pace. Sarvam Bulbul v3 accepts 0.5 through 2.0. */
+    readonly pace?: number;
+    /** Provider temperature. Sarvam Bulbul v3 accepts 0.01 through 1.0. */
+    readonly temperature?: number;
+    readonly pronunciationDictionaryId?: string;
     readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    /** Injectable fetch makes protocol and failure tests hermetic. */
+    readonly fetchImpl?: typeof fetch;
 }
-declare class AssemblyAiSttProvider implements SpeechToTextProvider {
+declare class SarvamTtsRestProvider implements TextToSpeechProvider {
     #private;
-    readonly name: "assemblyai-stt";
-    readonly kind = "stt";
+    readonly name: "sarvam-tts";
+    readonly kind = "tts";
     readonly version = "0.1.0";
     readonly capabilities: {
         streaming: {
-            input: true;
-            output: true;
-            native: true;
+            input: false;
+            output: false;
+            native: false;
         };
         cancellation: {
             request: true;
@@ -2375,204 +2485,186 @@ declare class AssemblyAiSttProvider implements SpeechToTextProvider {
             buffer: false;
             truncation: false;
         };
-        transports: "websocket"[];
+        transports: "http"[];
         audio: {
-            input: {
+            output: {
                 readonly encoding: "pcm_s16le";
                 readonly sampleRateHz: 16000;
                 readonly channels: 1;
             }[];
         };
-        models: readonly ["u3-rt-pro"];
-        turnDetection: "stt_endpointing"[];
+        languages: readonly ["hi-IN", "bn-IN", "ta-IN", "te-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "pa-IN", "od-IN", "en-IN"];
+        models: readonly ["bulbul:v3"];
+        voices: readonly ["shubh", "aditya", "ritu", "priya", "neha", "rahul", "pooja", "rohan", "simran", "kavya", "amit", "dev", "ishita", "shreya", "ratan", "varun", "manan", "sumit", "roopa", "kabir", "aayan", "ashutosh", "advait", "anand", "tanya", "tarun", "sunny", "mani", "gokul", "vijay", "shruti", "suhani", "mohit", "kavitha", "rehan", "soham", "rupali"];
         metadata: {
-            realtimeModel: "u3-rt-pro";
-            partialTranscripts: boolean;
-            formattedTurns: boolean;
+            transport: string;
+            endpoint: string;
+            requestTextLimit: number;
+            wireOutputCodec: string;
+            normalizedOutput: string;
+            documentation: string;
         };
     };
-    constructor(options: AssemblyAiSttProviderOptions);
-    open(request: SttOpenRequest): Promise<SttStream>;
-}
-declare function createAssemblyAiSttProvider(options: AssemblyAiSttProviderOptions): AssemblyAiSttProvider;
-
-interface SonioxStructuredContext {
-    readonly general?: readonly Readonly<{
-        key: string;
-        value: string;
-    }>[];
-    readonly text?: string;
-    readonly terms?: readonly string[];
-}
-interface SonioxSttProviderOptions {
-    readonly apiKey: string;
-    readonly url?: string;
-    readonly modelId?: string;
-    readonly allowUnknownModel?: boolean;
-    readonly context?: SonioxStructuredContext;
-    readonly enableEndpointDetection?: boolean;
-    readonly maxEndpointDelayMs?: number;
-    readonly endpointSensitivity?: number;
-    readonly endpointLatencyAdjustmentLevel?: number;
-    readonly enableLanguageIdentification?: boolean;
-    readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    constructor(options: SarvamTtsHttpProviderOptions);
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
 }
-declare class SonioxSttProvider implements SpeechToTextProvider {
+declare class SarvamTtsHttpStreamProvider implements TextToSpeechProvider {
     #private;
-    readonly name: "soniox-stt";
-    readonly kind = "stt";
+    readonly name: "sarvam-tts";
+    readonly kind = "tts";
     readonly version = "0.1.0";
     readonly capabilities: {
         streaming: {
-            input: true;
+            input: false;
             output: true;
             native: true;
         };
         cancellation: {
             request: true;
-            output: false;
+            output: true;
             buffer: false;
             truncation: false;
         };
-        transports: "websocket"[];
+        transports: "http"[];
         audio: {
-            input: readonly [{
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 8000;
-                readonly channels: 1;
-            }, {
+            output: {
                 readonly encoding: "pcm_s16le";
                 readonly sampleRateHz: 16000;
                 readonly channels: 1;
-            }];
+            }[];
         };
-        models: readonly ["stt-rt-v5"];
-        turnDetection: ("stt_endpointing" | "manual")[];
+        languages: readonly ["hi-IN", "bn-IN", "ta-IN", "te-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "pa-IN", "od-IN", "en-IN"];
+        models: readonly ["bulbul:v3"];
+        voices: readonly ["shubh", "aditya", "ritu", "priya", "neha", "rahul", "pooja", "rohan", "simran", "kavya", "amit", "dev", "ishita", "shreya", "ratan", "varun", "manan", "sumit", "roopa", "kabir", "aayan", "ashutosh", "advait", "anand", "tanya", "tarun", "sunny", "mani", "gokul", "vijay", "shruti", "suhani", "mohit", "kavitha", "rehan", "soham", "rupali"];
         metadata: {
-            realtimeModel: "stt-rt-v5";
-            partialTranscripts: boolean;
-            tokenFinality: boolean;
+            transport: string;
+            endpoint: string;
+            requestTextLimit: number;
+            wireOutputCodec: string;
+            normalizedOutput: string;
+            documentation: string;
         };
     };
-    constructor(options: SonioxSttProviderOptions);
-    open(request: SttOpenRequest): Promise<SttStream>;
+    constructor(options: SarvamTtsHttpProviderOptions);
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
 }
-declare function createSonioxSttProvider(options: SonioxSttProviderOptions): SonioxSttProvider;
+declare function createSarvamTtsRestProvider(options: SarvamTtsHttpProviderOptions): SarvamTtsRestProvider;
+declare function createSarvamTtsHttpStreamProvider(options: SarvamTtsHttpProviderOptions): SarvamTtsHttpStreamProvider;
 
-interface OpenAiResponsesLlmProviderOptions {
+type ElevenLabsBatchTimestampGranularity = "none" | "word" | "character";
+type ElevenLabsEntityDetection = string | readonly string[];
+interface ElevenLabsBatchSttRequest {
+    readonly audio: Uint8Array;
+    readonly format: AudioFormat;
+    readonly model?: string;
+    readonly language?: string;
+    readonly keyterms?: readonly string[];
+    readonly tagAudioEvents?: boolean;
+    readonly diarize?: boolean;
+    readonly numSpeakers?: number;
+    readonly timestampsGranularity?: ElevenLabsBatchTimestampGranularity;
+    readonly diarizationThreshold?: number;
+    readonly entityDetection?: ElevenLabsEntityDetection;
+    readonly noVerbatim?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface ElevenLabsBatchSttResult {
+    readonly modelId: string;
+    readonly text: string;
+    readonly languageCode?: string;
+    readonly languageProbability?: number;
+    readonly words: readonly Readonly<Record<string, unknown>>[];
+    readonly entities?: readonly Readonly<Record<string, unknown>>[];
+}
+
+type ElevenLabsSttCommitStrategy = "manual" | "vad";
+
+interface ElevenLabsSttProviderOptions {
     readonly apiKey: string;
     readonly url?: string;
+    readonly batchUrl?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly modelId?: string;
+    readonly commitStrategy?: ElevenLabsSttCommitStrategy;
+    readonly includeTimestamps?: boolean;
+    readonly includeLanguageDetection?: boolean;
+    readonly vadThreshold?: number;
+    readonly vadSilenceThresholdSecs?: number;
+    readonly secondaryLanguages?: readonly string[];
+    readonly minSpeechDurationMs?: number;
+    readonly minSilenceDurationMs?: number;
+    readonly noVerbatim?: boolean;
+    /** Detect bounded entity records on committed realtime transcript segments. */
+    readonly entityDetection?: ElevenLabsEntityDetection;
+    readonly filterBackgroundAudio?: boolean;
+    readonly enableLogging?: boolean;
+    /** Context sent with the first audio frame; useful after reconnects. */
+    readonly previousText?: string;
     readonly clock?: ProviderClock;
+    readonly fetchImpl?: typeof fetch;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
-declare class OpenAiResponsesLlmProvider implements LLMProvider {
+declare class ElevenLabsSttProvider implements SpeechToTextProvider {
     #private;
-    readonly name: "openai-responses";
-    readonly kind = "llm";
+    readonly name: "elevenlabs-stt-realtime";
+    readonly kind = "stt";
     readonly version = "0.1.0";
     readonly capabilities: {
         streaming: {
-            input: false;
+            input: true;
             output: true;
             native: true;
         };
         cancellation: {
             request: true;
-            output: true;
+            output: false;
             buffer: false;
             truncation: false;
         };
-        transports: ("http" | "sse")[];
-        models: readonly ["gpt-5", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini"];
-        tools: {
-            functionCalling: true;
-            parallelCalls: true;
-        };
-    };
-    constructor(options: OpenAiResponsesLlmProviderOptions);
-    complete(request: LlmCompletionRequest): Promise<LlmCompletion>;
-}
-declare function createOpenAiResponsesLlmProvider(options: OpenAiResponsesLlmProviderOptions): OpenAiResponsesLlmProvider;
-
-interface GroqChatLlmProviderOptions {
-    readonly apiKey: string;
-    readonly url?: string;
-    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
-    readonly allowUnknownModel?: boolean;
-    readonly clock?: ProviderClock;
-}
-declare class GroqChatLlmProvider implements LLMProvider {
-    #private;
-    readonly name: "groq-chat-completions";
-    readonly kind = "llm";
-    readonly version = "0.1.0";
-    readonly capabilities: {
-        streaming: {
-            input: false;
-            output: true;
-            native: true;
-        };
-        cancellation: {
-            request: true;
-            output: true;
-            buffer: false;
-            truncation: false;
-        };
-        transports: ("http" | "sse")[];
-        models: readonly ["openai/gpt-oss-20b", "openai/gpt-oss-120b"];
-        tools: {
-            functionCalling: true;
-            parallelCalls: false;
-        };
-    };
-    constructor(options: GroqChatLlmProviderOptions);
-    complete(request: LlmCompletionRequest): Promise<LlmCompletion>;
-}
-declare function createGroqChatLlmProvider(options: GroqChatLlmProviderOptions): GroqChatLlmProvider;
-
-interface CartesiaTtsProviderOptions {
-    readonly apiKey: string;
-    readonly url?: string;
-    readonly voiceId: string;
-    readonly modelId?: string;
-    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
-    readonly allowUnknownModel?: boolean;
-    readonly language?: string;
-    readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
-}
-declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
-    #private;
-    readonly name: "cartesia";
-    readonly kind = "tts";
-    readonly version = "0.1.0";
-    readonly capabilities: {
-        streaming: {
-            input: true;
-            output: true;
-            native: true;
-        };
-        cancellation: {
-            request: true;
-            output: false;
-            buffer: false;
-            truncation: false;
-        };
-        transports: "websocket"[];
+        transports: ("http" | "websocket")[];
         audio: {
-            output: {
+            input: readonly [{
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 8000;
+                readonly channels: 1;
+            }, {
                 readonly encoding: "pcm_s16le";
                 readonly sampleRateHz: 16000;
                 readonly channels: 1;
-            }[];
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 22050;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 24000;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 44100;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 48000;
+                readonly channels: 1;
+            }];
+        };
+        models: readonly ["scribe_v2_realtime", "scribe_v2", "scribe_v2_medical"];
+        turnDetection: ("manual" | "vad")[];
+        metadata: {
+            realtimeModel: string;
+            realtimeModels: string[];
+            batchModels: string[];
+            batchTranscription: boolean;
+            partialTranscripts: boolean;
         };
-        models: readonly ["sonic-3", "sonic-2"];
     };
-    constructor(options: CartesiaTtsProviderOptions);
-    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
-    openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
+    constructor(options: ElevenLabsSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+    transcribe(request: ElevenLabsBatchSttRequest): Promise<ElevenLabsBatchSttResult>;
+    transcribe(request: SttBatchTranscriptionRequest): Promise<SttBatchTranscription>;
 }
-declare function createCartesiaTtsProvider(options: CartesiaTtsProviderOptions): CartesiaTtsProvider;
+declare function createElevenLabsSttProvider(options: ElevenLabsSttProviderOptions): ElevenLabsSttProvider;
 
 /**
  * Vendor facts that change on the provider's release schedule rather than ours:
@@ -2596,20 +2688,31 @@ interface ProviderCatalogEntry {
     readonly defaultModel: string;
     /** Models this adapter is known to work with, not the vendor's full catalog. */
     readonly models: readonly string[];
+    /** Optional transport-specific model groups when one adapter spans transports. */
+    readonly realtimeModels?: readonly string[];
+    readonly preRecordedModels?: readonly string[];
+    readonly syncModels?: readonly string[];
+    /** Models supported by a separate complete-input/batch contract, when present. */
+    readonly batchModels?: readonly string[];
+    /** Official documentation for the separate batch contract, when present. */
+    readonly batchSource?: string;
 }
 /**
- * TVIC maturity labels are our release claim, not a vendor guarantee.
- * `experimental` means the adapter has deterministic contract coverage but
- * still needs a credential-gated live-service check before it can be called
- * stable in release notes.
+ * TVIC maturity labels are our release claim, not a vendor guarantee. They are
+ * ordered from least to most supported as deferred, experimental, validated,
+ * and stable. `validated` means the exact adapter/model path has passed the
+ * small-scale live evidence profile; it is not an uptime or compatibility SLA.
  */
-type ProviderStability = "stable" | "experimental" | "deferred";
+declare const PROVIDER_STABILITY_LEVELS: readonly ["deferred", "experimental", "validated", "stable"];
+type ProviderStability = (typeof PROVIDER_STABILITY_LEVELS)[number];
 declare const PROVIDER_STABILITY: Readonly<{
     readonly deepgram: "experimental";
+    readonly cartesiaStt: "experimental";
     readonly sarvam: "experimental";
     readonly elevenlabsStt: "experimental";
     readonly assemblyai: "experimental";
     readonly soniox: "experimental";
+    readonly sarvamTts: "experimental";
     readonly groq: "experimental";
     readonly openaiResponses: "experimental";
     readonly cartesia: "experimental";
@@ -2624,35 +2727,52 @@ declare const PROVIDER_CATALOG: {
         readonly defaultModel: "nova-3";
         readonly models: readonly ["nova-3", "nova-2"];
     };
+    readonly cartesiaStt: {
+        readonly verifiedAt: "2026-09-27";
+        readonly source: "https://docs.cartesia.ai/build-with-cartesia/stt/latest";
+        readonly defaultModel: "ink-2";
+        readonly models: readonly ["ink-2", "ink-preview", "ink-whisper-2025-06-04"];
+        readonly batchModels: readonly ["ink-whisper"];
+        readonly batchSource: "https://docs.cartesia.ai/api-reference/stt/transcribe";
+    };
     readonly sarvam: {
         readonly verifiedAt: "2026-09-15";
         readonly source: "https://docs.sarvam.ai/api-reference/speech-to-text/transcribe/ws";
         readonly defaultModel: "saaras:v3";
         readonly models: readonly ["saaras:v3", "saaras:v4"];
     };
+    readonly sarvamTts: {
+        readonly verifiedAt: "2026-09-25";
+        readonly source: "https://docs.sarvam.ai/api-reference/text-to-speech/convert";
+        readonly defaultModel: "bulbul:v3";
+        readonly models: readonly ["bulbul:v3"];
+    };
     readonly cartesia: {
-        readonly verifiedAt: "2026-09-15";
-        readonly source: "https://docs.cartesia.ai/build-with-cartesia/tts-models/older-models";
-        readonly defaultModel: "sonic-3";
-        readonly models: readonly ["sonic-3", "sonic-2"];
+        readonly verifiedAt: "2026-09-25";
+        readonly source: "https://docs.cartesia.ai/build-with-cartesia/tts-models/latest";
+        readonly defaultModel: "sonic-3.6";
+        readonly models: readonly ["sonic-3.6", "sonic-3.6-2026-08-27", "sonic-preview", "sonic-3.5", "sonic-3.5-2026-05-04", "sonic-3", "sonic-3-2026-01-12"];
     };
     readonly elevenlabs: {
-        readonly verifiedAt: "2026-07-24";
-        readonly source: "https://elevenlabs.io/docs/models";
+        readonly verifiedAt: "2026-09-25";
+        readonly source: "https://elevenlabs.io/docs/overview/models";
         readonly defaultModel: "eleven_flash_v2_5";
-        readonly models: readonly ["eleven_flash_v2_5", "eleven_turbo_v2_5", "eleven_multilingual_v2"];
+        readonly models: readonly ["eleven_flash_v2_5", "eleven_flash_v2", "eleven_v3", "eleven_v3_conversational", "eleven_multilingual_v2", "eleven_turbo_v2_5", "eleven_turbo_v2"];
     };
     readonly elevenlabsStt: {
-        readonly verifiedAt: "2026-08-20";
-        readonly source: "https://elevenlabs.io/docs/api-reference/speech-to-text/v-1-speech-to-text-realtime";
+        readonly verifiedAt: "2026-09-24";
+        readonly source: "https://elevenlabs.io/docs/overview/models";
         readonly defaultModel: "scribe_v2_realtime";
-        readonly models: readonly ["scribe_v2_realtime"];
+        readonly models: readonly ["scribe_v2_realtime", "scribe_v2", "scribe_v2_medical"];
     };
     readonly assemblyai: {
-        readonly verifiedAt: "2026-08-20";
-        readonly source: "https://www.assemblyai.com/docs/streaming/message-sequence";
-        readonly defaultModel: "u3-rt-pro";
-        readonly models: readonly ["u3-rt-pro"];
+        readonly verifiedAt: "2026-09-27";
+        readonly source: "https://www.assemblyai.com/docs/streaming/select-the-speech-model";
+        readonly defaultModel: "universal-3-6-pro";
+        readonly models: readonly string[];
+        readonly realtimeModels: readonly ["universal-3-6-pro", "universal-3-5-pro", "universal-streaming-english", "universal-streaming-multilingual"];
+        readonly preRecordedModels: readonly ["universal-3-5-pro", "universal-2"];
+        readonly syncModels: readonly ["universal-3-5-pro"];
     };
     readonly soniox: {
         readonly verifiedAt: "2026-08-20";
@@ -2678,7 +2798,8 @@ declare const PROVIDER_CATALOG: {
  * protocol version changes adapter parsing, not just which model is selected.
  */
 declare const PROVIDER_API_VERSIONS: {
-    readonly cartesia: "2026-03-01";
+    readonly cartesia: "2026-08-14";
+    readonly cartesiaStt: "2026-08-14";
 };
 /**
  * TVIC's own adapter tuning. These are our decisions about how to drive a provider,
@@ -2697,21 +2818,468 @@ declare const ADAPTER_DEFAULTS: {
         readonly flushSignal: true;
         readonly inputAudioCodec: "pcm_s16le";
     };
+    readonly sarvamTts: {
+        readonly language: "en-IN";
+        readonly voice: "shubh";
+        readonly pace: 1;
+        readonly temperature: 0.6;
+        readonly minBufferSize: 50;
+        readonly maxChunkLength: 150;
+    };
     readonly cartesia: {
         readonly language: "en";
     };
+    readonly cartesiaStt: {
+        readonly mode: "manual";
+    };
 };
 
+interface AssemblyAiSpeakerOptions {
+    readonly minSpeakersExpected?: number;
+    readonly maxSpeakersExpected?: number;
+    readonly includeSpeakerConfidence?: boolean;
+}
+type AssemblyAiPiiSubstitution = "entity_name" | "hash";
+type AssemblyAiRedactedAudioQuality = "mp3" | "wav";
+interface AssemblyAiRedactPiiAudioOptions {
+    readonly overrideAudioRedactionMethod?: "beep" | "silence";
+    readonly returnRedactedNoSpeechAudio?: boolean;
+}
+interface AssemblyAiPreRecordedSttRequest {
+    /** A complete local file or encoded media payload. */
+    readonly audio?: Uint8Array;
+    /** A public URL or AssemblyAI upload URL. Exactly one audio source is required. */
+    readonly audioUrl?: string;
+    /** Content type used when `audio` is uploaded. */
+    readonly mimeType?: string;
+    /** Filename used as the multipart upload filename. */
+    readonly fileName?: string;
+    /** Convenience single-model selector. Cannot be combined with speechModels. */
+    readonly model?: string;
+    /** Ordered model candidates. AssemblyAI may fall back to the next model. */
+    readonly speechModels?: readonly string[];
+    readonly language?: string;
+    readonly languageDetection?: boolean;
+    readonly prompt?: string;
+    readonly vocabulary?: readonly string[];
+    readonly punctuate?: boolean;
+    readonly formatText?: boolean;
+    readonly disfluencies?: boolean;
+    readonly speakerLabels?: boolean;
+    readonly speakersExpected?: number;
+    readonly speakerOptions?: AssemblyAiSpeakerOptions;
+    /** Current AssemblyAI name for separate-channel transcription. */
+    readonly multichannel?: boolean;
+    /** @deprecated Use `multichannel`. Kept as a compatibility alias. */
+    readonly dualChannel?: boolean;
+    readonly redactPii?: boolean;
+    readonly redactPiiPolicies?: readonly string[];
+    readonly redactPiiSub?: AssemblyAiPiiSubstitution;
+    readonly redactPiiAudio?: boolean;
+    readonly redactPiiAudioQuality?: AssemblyAiRedactedAudioQuality;
+    readonly redactPiiAudioOptions?: AssemblyAiRedactPiiAudioOptions;
+    readonly redactPiiReturnUnredacted?: boolean;
+    readonly redactStaticEntities?: Readonly<Record<string, readonly string[]>>;
+    readonly speechThreshold?: number;
+    readonly webhookUrl?: string;
+    readonly webhookAuthHeaderName?: string;
+    readonly webhookAuthHeaderValue?: string;
+    readonly signal?: AbortSignal;
+    readonly pollIntervalMs?: number;
+    readonly pollTimeoutMs?: number;
+}
+interface AssemblyAiSyncSttRequest {
+    /** Raw PCM16LE bytes. The format is sent in the Sync config part. */
+    readonly audio: Uint8Array;
+    readonly format: AudioFormat;
+    readonly model?: string;
+    readonly languageCodes?: readonly string[];
+    readonly prompt?: string;
+    readonly vocabulary?: readonly string[];
+    readonly timestamps?: boolean;
+    readonly fileName?: string;
+    readonly signal?: AbortSignal;
+}
+interface AssemblyAiSyncLiveSttRequest {
+    /** Async PCM16LE chunks produced while the recording is in progress. */
+    readonly audio: AsyncIterable<Uint8Array>;
+    readonly format: AudioFormat;
+    readonly model?: string;
+    readonly languageCodes?: readonly string[];
+    readonly prompt?: string;
+    readonly vocabulary?: readonly string[];
+    readonly timestamps?: boolean;
+    readonly fileName?: string;
+    readonly signal?: AbortSignal;
+}
+interface AssemblyAiTranscriptWord {
+    readonly text: string;
+    readonly start?: number;
+    readonly end?: number;
+    readonly confidence?: number;
+    readonly speaker?: string;
+    readonly [key: string]: unknown;
+}
+interface AssemblyAiTranscriptUtterance {
+    readonly text: string;
+    readonly start?: number;
+    readonly end?: number;
+    readonly confidence?: number;
+    readonly speaker?: string;
+    readonly words?: readonly AssemblyAiTranscriptWord[];
+    readonly [key: string]: unknown;
+}
+interface AssemblyAiPreRecordedSttResult {
+    readonly id: string;
+    readonly status: "completed";
+    readonly modelId: string;
+    readonly text: string;
+    readonly languageCode?: string;
+    readonly audioDurationMs?: number;
+    readonly audioChannels?: number;
+    readonly confidence?: number;
+    readonly words: readonly AssemblyAiTranscriptWord[];
+    readonly utterances: readonly AssemblyAiTranscriptUtterance[];
+    /** Bounded provider response for fields not yet promoted into the TVIC shape. */
+    readonly providerResponse: Readonly<Record<string, unknown>>;
+}
+interface AssemblyAiSyncSttResult {
+    readonly sessionId: string;
+    readonly modelId: string;
+    readonly text: string;
+    readonly confidence?: number;
+    readonly audioDurationMs?: number;
+    readonly requestTimeMs?: number;
+    readonly words: readonly AssemblyAiTranscriptWord[];
+    readonly providerResponse: Readonly<Record<string, unknown>>;
+}
+
+interface AssemblyAiSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly modelId?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly formatTurns?: boolean;
+    readonly prompt?: string;
+    readonly languageDetection?: boolean;
+    readonly speakerLabels?: boolean;
+    readonly maxSpeakers?: number;
+    readonly speakerLabelsRevisionIntervalMs?: number;
+    readonly minTurnSilenceMs?: number;
+    readonly maxTurnSilenceMs?: number;
+    readonly clock?: ProviderClock;
+    readonly preRecordedUrl?: string;
+    readonly uploadUrl?: string;
+    readonly syncUrl?: string;
+    readonly fetchImpl?: typeof fetch;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+declare class AssemblyAiSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "assemblyai-stt";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: ("http" | "websocket")[];
+        audio: {
+            input: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly string[];
+        turnDetection: "stt_endpointing"[];
+        metadata: {
+            realtimeModel: "universal-3-6-pro";
+            realtimeModels: readonly ["universal-3-6-pro", "universal-3-5-pro", "universal-streaming-english", "universal-streaming-multilingual"];
+            preRecordedModels: readonly ["universal-3-5-pro", "universal-2"];
+            syncModels: readonly ["universal-3-5-pro"];
+            preRecordedTranscription: boolean;
+            syncTranscription: boolean;
+            syncLiveTranscription: boolean;
+            partialTranscripts: boolean;
+            formattedTurns: boolean;
+            speakerDiarization: boolean;
+            multichannelTranscription: boolean;
+            piiRedaction: boolean;
+        };
+    };
+    constructor(options: AssemblyAiSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+    transcribe(request: AssemblyAiPreRecordedSttRequest): Promise<AssemblyAiPreRecordedSttResult>;
+    transcribe(request: SttBatchTranscriptionRequest): Promise<SttBatchTranscription>;
+    transcribeSync(request: AssemblyAiSyncSttRequest): Promise<AssemblyAiSyncSttResult>;
+    transcribeSyncLive(request: AssemblyAiSyncLiveSttRequest): Promise<AssemblyAiSyncSttResult>;
+    warmSync(model?: string, signal?: AbortSignal): Promise<void>;
+}
+declare function createAssemblyAiSttProvider(options: AssemblyAiSttProviderOptions): AssemblyAiSttProvider;
+
+interface SonioxStructuredContext {
+    readonly general?: readonly Readonly<{
+        key: string;
+        value: string;
+    }>[];
+    readonly text?: string;
+    readonly terms?: readonly string[];
+}
+interface SonioxSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly modelId?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly context?: SonioxStructuredContext;
+    readonly enableEndpointDetection?: boolean;
+    readonly maxEndpointDelayMs?: number;
+    readonly endpointSensitivity?: number;
+    readonly endpointLatencyAdjustmentLevel?: number;
+    readonly enableLanguageIdentification?: boolean;
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+declare class SonioxSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "soniox-stt";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            input: readonly [{
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 8000;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }];
+        };
+        models: readonly ["stt-rt-v5"];
+        turnDetection: ("manual" | "stt_endpointing")[];
+        metadata: {
+            realtimeModel: "stt-rt-v5";
+            partialTranscripts: boolean;
+            tokenFinality: boolean;
+        };
+    };
+    constructor(options: SonioxSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+}
+declare function createSonioxSttProvider(options: SonioxSttProviderOptions): SonioxSttProvider;
+
+interface OpenAiResponsesLlmProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly clock?: ProviderClock;
+}
+declare class OpenAiResponsesLlmProvider implements LLMProvider {
+    #private;
+    readonly name: "openai-responses";
+    readonly kind = "llm";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: false;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: true;
+            buffer: false;
+            truncation: false;
+        };
+        transports: ("http" | "sse")[];
+        models: readonly ["gpt-5", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini"];
+        tools: {
+            functionCalling: true;
+            parallelCalls: true;
+        };
+    };
+    constructor(options: OpenAiResponsesLlmProviderOptions);
+    complete(request: LlmCompletionRequest): Promise<LlmCompletion>;
+}
+declare function createOpenAiResponsesLlmProvider(options: OpenAiResponsesLlmProviderOptions): OpenAiResponsesLlmProvider;
+
+interface GroqChatLlmProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
+    readonly allowUnknownModel?: boolean;
+    readonly clock?: ProviderClock;
+}
+declare class GroqChatLlmProvider implements LLMProvider {
+    #private;
+    readonly name: "groq-chat-completions";
+    readonly kind = "llm";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: false;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: true;
+            buffer: false;
+            truncation: false;
+        };
+        transports: ("http" | "sse")[];
+        models: readonly ["openai/gpt-oss-20b", "openai/gpt-oss-120b"];
+        tools: {
+            functionCalling: true;
+            parallelCalls: false;
+        };
+    };
+    constructor(options: GroqChatLlmProviderOptions);
+    complete(request: LlmCompletionRequest): Promise<LlmCompletion>;
+}
+declare function createGroqChatLlmProvider(options: GroqChatLlmProviderOptions): GroqChatLlmProvider;
+
+interface CartesiaGenerationConfig {
+    /** Relative output volume; Cartesia interprets the value for the selected model. */
+    readonly volume?: number;
+    /** Relative speaking speed; a request-level speed overrides this value. */
+    readonly speed?: number;
+    /** Optional Sonic emotion/style control. */
+    readonly emotion?: string;
+}
+
+declare const MAX_CARTESIA_INPUT_UTF16_CODE_UNITS = 1048576;
+declare const MAX_CARTESIA_INPUT_UTF8_BYTES = 4194304;
+interface CartesiaTtsProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly voiceId: string;
+    readonly modelId?: string;
+    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
+    readonly allowUnknownModel?: boolean;
+    readonly language?: string;
+    /** Cartesia locale is mutually exclusive with language. */
+    readonly locale?: string;
+    readonly accent?: string;
+    readonly normalization?: string;
+    readonly generationConfig?: CartesiaGenerationConfig;
+    readonly pronunciationDictId?: string;
+    /** Cartesia server-side continuation buffering; 0 keeps latency under TVIC control. */
+    readonly maxBufferDelayMs?: number;
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
+    #private;
+    readonly name: "cartesia";
+    readonly kind = "tts";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            output: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly ["sonic-3.6", "sonic-3.6-2026-08-27", "sonic-preview", "sonic-3.5", "sonic-3.5-2026-05-04", "sonic-3", "sonic-3-2026-01-12"];
+    };
+    constructor(options: CartesiaTtsProviderOptions);
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+    openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
+}
+declare function createCartesiaTtsProvider(options: CartesiaTtsProviderOptions): CartesiaTtsProvider;
+
+type ElevenLabsTtsProtocol = "tts" | "dialogue";
+type ElevenLabsTextNormalization = "auto" | "on" | "off";
+interface ElevenLabsPronunciationDictionaryLocator {
+    readonly id: string;
+    readonly versionId?: string;
+}
+interface ElevenLabsTtsSendTextOptions {
+    /** Regular TTS only. Requests generation before the normal chunk schedule. */
+    readonly tryTriggerGeneration?: boolean;
+}
+interface ElevenLabsDialogueTurnOptions {
+    readonly voiceId?: string;
+    /** Starts a new speaker/prosody turn without closing the socket. */
+    readonly newTurn?: boolean;
+}
 interface ElevenLabsTtsProviderOptions {
     readonly apiKey: string;
     readonly voiceId: string;
     readonly modelId?: string;
     readonly language?: string;
     readonly url?: string;
+    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
+    readonly allowUnknownModel?: boolean;
     readonly stability?: number;
     readonly similarityBoost?: number;
+    /** Regular TTS WebSocket speaker boost. */
+    readonly useSpeakerBoost?: boolean;
+    /** Regular TTS WebSocket auto mode; use only when sending complete sentences. */
+    readonly autoMode?: boolean;
+    /** Regular TTS WebSocket generation schedule, in provider character thresholds. */
+    readonly chunkLengthSchedule?: readonly number[];
+    readonly applyTextNormalization?: ElevenLabsTextNormalization;
+    readonly enableLogging?: boolean;
+    readonly enableSsmlParsing?: boolean;
+    readonly seed?: number;
+    readonly inactivityTimeoutSeconds?: number;
+    /** Up to three dictionaries, applied in order on the first provider message. */
+    readonly pronunciationDictionaryLocators?: readonly ElevenLabsPronunciationDictionaryLocator[];
+    /** Voices registered for an Eleven v3 dialogue session. */
+    readonly dialogueVoices?: readonly string[];
     readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+
+interface ElevenLabsStreamOptions {
+    readonly clock: ProviderClock;
+    readonly modelId?: string;
+    readonly protocol?: ElevenLabsTtsProtocol;
+    readonly voice?: string;
+    readonly voices?: readonly string[];
+    readonly maxCharacters?: number | undefined;
+    readonly stability: number;
+    readonly similarityBoost: number;
+    readonly useSpeakerBoost?: boolean | undefined;
+    readonly applyTextNormalization?: ElevenLabsTextNormalization | undefined;
+    readonly chunkLengthSchedule?: readonly number[] | undefined;
+    readonly pronunciationDictionaryLocators?: readonly ElevenLabsPronunciationDictionaryLocator[] | undefined;
 }
 declare class ElevenLabsTtsProvider implements IncrementalTextToSpeechProvider {
     #private;
@@ -2738,14 +3306,129 @@ declare class ElevenLabsTtsProvider implements IncrementalTextToSpeechProvider {
                 readonly channels: 1;
             }[];
         };
-        models: readonly ["eleven_flash_v2_5", "eleven_turbo_v2_5", "eleven_multilingual_v2"];
+        models: readonly ["eleven_flash_v2_5", "eleven_flash_v2", "eleven_v3", "eleven_v3_conversational", "eleven_multilingual_v2", "eleven_turbo_v2_5", "eleven_turbo_v2"];
     };
     constructor(options: ElevenLabsTtsProviderOptions);
     synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
-    openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
+    openSession(request: TtsSessionOpenRequest): Promise<ElevenLabsTtsStream>;
+}
+declare class ElevenLabsTtsStream implements TtsSession {
+    #private;
+    readonly events: AsyncIterable<TtsEvent>;
+    constructor(socket: WebSocket__default, request: TtsSessionOpenRequest, options: ElevenLabsStreamOptions);
+    sendText(text: string, options?: ElevenLabsTtsSendTextOptions): Promise<void>;
+    /** Sends one incremental line in a Text-to-Dialogue session. */
+    sendDialogueTurn(text: string, options?: ElevenLabsDialogueTurnOptions): Promise<void>;
+    /** Resets the provider receive timeout without causing a generation. */
+    keepAlive(): Promise<void>;
+    flush(): Promise<TtsFlushResult>;
+    finish(): Promise<void>;
+    cancel(): Promise<void>;
 }
 declare function createElevenLabsTtsProvider(options: ElevenLabsTtsProviderOptions): ElevenLabsTtsProvider;
 
+interface ElevenLabsHttpTtsProviderOptions extends Omit<ElevenLabsTtsProviderOptions, "url" | "webSocketFactory"> {
+    /** Overrides the regular text-to-speech endpoint. */
+    readonly url?: string;
+    /** Overrides the text-to-dialogue endpoint. */
+    readonly dialogueUrl?: string;
+    readonly optimizeStreamingLatency?: 0 | 1 | 2 | 3 | 4;
+    readonly applyLanguageTextNormalization?: boolean;
+    readonly fetchImpl?: typeof fetch;
+}
+interface ElevenLabsTtsHttpSynthesisRequest extends TtsSynthesisRequest {
+    readonly previousText?: string;
+    readonly nextText?: string;
+    readonly previousRequestIds?: readonly string[];
+    readonly nextRequestIds?: readonly string[];
+}
+interface ElevenLabsDialogueInput {
+    readonly text: string;
+    readonly voiceId: string;
+}
+interface ElevenLabsDialogueSynthesisRequest extends Omit<TtsSynthesisRequest, "text" | "voice"> {
+    readonly inputs: readonly ElevenLabsDialogueInput[];
+    readonly previousText?: string;
+    readonly futureText?: string;
+    readonly previousRequestIds?: readonly string[];
+    readonly nextRequestIds?: readonly string[];
+}
+interface ElevenLabsDialogueProvider extends TextToSpeechProvider {
+    synthesizeDialogue(request: ElevenLabsDialogueSynthesisRequest): Promise<TtsStream>;
+    /** Forces the regular single-voice TTS HTTP endpoint, including for v3 models. */
+    synthesizeSpeech(request: ElevenLabsTtsHttpSynthesisRequest): Promise<TtsStream>;
+}
+declare class ElevenLabsTtsRestProvider implements ElevenLabsDialogueProvider {
+    #private;
+    readonly name: "elevenlabs";
+    readonly kind = "tts";
+    readonly version = "0.1.0";
+    readonly capabilities: ProviderCapabilities;
+    constructor(options: ElevenLabsHttpTtsProviderOptions);
+    get _httpOptions(): ElevenLabsHttpTtsProviderOptions;
+    get _httpModelId(): string;
+    get _httpAllowUnknownModel(): boolean;
+    get _httpClock(): ProviderClock;
+    get _httpFetch(): typeof fetch;
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+    synthesizeSpeech(request: ElevenLabsTtsHttpSynthesisRequest): Promise<TtsStream>;
+    synthesizeDialogue(request: ElevenLabsDialogueSynthesisRequest): Promise<TtsStream>;
+}
+declare class ElevenLabsTtsHttpStreamProvider extends ElevenLabsTtsRestProvider {
+    readonly capabilities: ProviderCapabilities;
+    synthesizeSpeech(request: ElevenLabsTtsHttpSynthesisRequest): Promise<TtsStream>;
+    synthesizeDialogue(request: ElevenLabsDialogueSynthesisRequest): Promise<TtsStream>;
+    private synthesizeSpeechStream;
+    private synthesizeDialogueStream;
+    private executeStreamSpeech;
+    private executeStreamDialogue;
+    private executeViaProtectedPath;
+}
+/** The factory is the preferred entry point for complete HTTP responses. */
+declare function createElevenLabsTtsRestProvider(options: ElevenLabsHttpTtsProviderOptions): ElevenLabsTtsRestProvider;
+/** The factory is the preferred entry point for chunked HTTP responses. */
+declare function createElevenLabsTtsHttpStreamProvider(options: ElevenLabsHttpTtsProviderOptions): ElevenLabsTtsHttpStreamProvider;
+
+/** The point at which the primary TTS provider became unavailable. */
+type TtsFailoverPhase = "synthesize" | "stream";
+interface TtsFailoverContext {
+    readonly phase: TtsFailoverPhase;
+    readonly primary: TextToSpeechProvider;
+    readonly fallback: TextToSpeechProvider;
+    readonly request: TtsSynthesisRequest;
+    readonly fallbackRequest: TtsSynthesisRequest;
+    readonly error: NormalizedError;
+}
+interface TtsFailoverProviderOptions {
+    /** The provider used for the normal request path. */
+    readonly primary: TextToSpeechProvider;
+    /** The provider used only after the failover policy accepts the error. */
+    readonly fallback: TextToSpeechProvider;
+    /**
+     * Maps the primary request to the fallback provider's model and voice. The
+     * session, turn, signal, and output format must remain unchanged.
+     */
+    readonly mapFallbackRequest?: (request: TtsSynthesisRequest, error: NormalizedError) => TtsSynthesisRequest;
+    /**
+     * Defaults to operational provider/network/timeout failures. Validation,
+     * authentication, protocol, identity, and cancellation errors do not fail
+     * over because retrying them on another provider usually hides a bug.
+     */
+    readonly shouldFallback?: (error: NormalizedError, request: TtsSynthesisRequest) => boolean;
+    /** Best-effort observability hook; observer failures never block fallback. */
+    readonly onFallback?: (context: TtsFailoverContext) => void | PromiseLike<void>;
+    readonly name?: string;
+}
+/**
+ * Builds an explicit TTS failover provider for host-owned routing.
+ *
+ * Failover is attempted when the primary request fails before a stream is
+ * returned, or when its stream fails before any audio chunk is emitted. Once
+ * audio has been delivered, the original failure is propagated instead of
+ * replaying the whole response and risking duplicated speech.
+ */
+declare function createTtsFailoverProvider(options: TtsFailoverProviderOptions): TextToSpeechProvider;
+
 declare function bytesToBase64(bytes: Uint8Array): string;
 declare function base64ToBytes(value: string): Uint8Array;
 declare function mulawToPcm16le(mulaw: Uint8Array): Uint8Array;
@@ -2803,6 +3486,8 @@ interface AudioNormalizerOptions {
 interface AudioNormalizer {
     readonly inputFormat: AudioFormat;
     readonly outputFormat: AudioFormat;
+    /** Create an independent copy at the current sample-clock position. */
+    fork(): AudioNormalizer;
     push(bytes: Uint8Array): Uint8Array;
     finishSegment(): Uint8Array;
     finish(): Uint8Array;
@@ -2945,6 +3630,7 @@ type AudioFormatDirection = "input" | "output";
 declare function supportsAudioFormat(provider: Provider, format: AudioFormat, direction: AudioFormatDirection): boolean;
 declare function supportsLanguage(provider: Provider, language: string): boolean;
 declare function supportsModel(provider: Provider, model: string): boolean;
+declare function supportsBatchModel(provider: Provider, model: string): boolean;
 declare function requireProviderKind<K extends ProviderKind>(provider: RuntimeProvider, kind: K): ProviderForKind<K>;
 
 interface DefineToolInput<TInput, TOutput> {
@@ -3509,7 +4195,7 @@ type UpgradeAuthorization<TContext> = {
     readonly reason?: string;
 };
 interface NodeMediaPlaneConnection<TContext = unknown> {
-    readonly socket: WebSocket;
+    readonly socket: WebSocket__default;
     readonly request: IncomingMessage;
     readonly url: URL;
     readonly params: Readonly<Record<string, string>>;
@@ -3517,7 +4203,7 @@ interface NodeMediaPlaneConnection<TContext = unknown> {
 }
 type NodeMediaPlaneConnectionHandler<TContext = unknown> = (connection: NodeMediaPlaneConnection<TContext>) => Promise<void> | void;
 type NodeMediaPlaneRequestHandler = (request: IncomingMessage, response: ServerResponse) => boolean | Promise<boolean>;
-type NodeMediaPlaneConnectionErrorHandler = (error: unknown, socket: WebSocket) => void | Promise<void>;
+type NodeMediaPlaneConnectionErrorHandler = (error: unknown, socket: WebSocket__default) => void | Promise<void>;
 interface NodeMediaPlaneOptions<TContext = unknown> {
     readonly host?: string;
     readonly port: number;
@@ -3579,12 +4265,17 @@ type AssemblyAiProviderConfig = Omit<AssemblyAiSttProviderOptions, "apiKey" | "m
     readonly apiKey?: string;
     readonly model?: string;
 };
+type CartesiaSttProviderConfig = Omit<CartesiaSttProviderOptions, "apiKey" | "modelId"> & {
+    readonly provider: "cartesia";
+    readonly apiKey?: string;
+    readonly model?: string;
+};
 type SonioxProviderConfig = Omit<SonioxSttProviderOptions, "apiKey" | "modelId"> & {
     readonly provider: "soniox";
     readonly apiKey?: string;
     readonly model?: string;
 };
-type SttProviderConfig = DeepgramProviderConfig | SarvamProviderConfig | ElevenLabsSttProviderConfig | AssemblyAiProviderConfig | SonioxProviderConfig;
+type SttProviderConfig = DeepgramProviderConfig | SarvamProviderConfig | CartesiaSttProviderConfig | ElevenLabsSttProviderConfig | AssemblyAiProviderConfig | SonioxProviderConfig;
 type OpenAiProviderConfig = Omit<OpenAiResponsesLlmProviderOptions, "apiKey"> & {
     readonly provider: "openai" | "openai-responses";
     readonly apiKey?: string;
@@ -3605,13 +4296,33 @@ type CartesiaProviderConfig = Omit<CartesiaTtsProviderOptions, "apiKey" | "voice
     readonly model?: string;
     readonly voiceId?: string;
 };
-type ElevenLabsTtsProviderConfig = Omit<ElevenLabsTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
+type ElevenLabsTtsProviderConfig = (Omit<ElevenLabsTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
     readonly provider: "elevenlabs";
+    readonly transport?: "websocket";
     readonly apiKey?: string;
     readonly model?: string;
     readonly voiceId?: string;
-};
-type TtsProviderConfig = CartesiaProviderConfig | ElevenLabsTtsProviderConfig;
+}) | (Omit<ElevenLabsHttpTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
+    readonly provider: "elevenlabs";
+    readonly transport: "rest" | "http-stream";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+});
+type SarvamTtsProviderConfig = (Omit<SarvamTtsProviderOptions, "apiKey" | "modelId" | "voiceId"> & {
+    readonly provider: "sarvam";
+    readonly transport?: "websocket";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+}) | (Omit<SarvamTtsHttpProviderOptions, "apiKey" | "modelId" | "voiceId"> & {
+    readonly provider: "sarvam";
+    readonly transport: "rest" | "http-stream";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+});
+type TtsProviderConfig = CartesiaProviderConfig | ElevenLabsTtsProviderConfig | SarvamTtsProviderConfig;
 type TelephonyProviderConfig = {
     readonly provider: "web-client-audio";
     readonly options?: WebClientAudioProviderOptions;
@@ -4186,5 +4897,5 @@ declare class PostgresMemory implements Memory {
 }
 declare function createPostgresMemory(options: PostgresMemoryOptions): PostgresMemory;
 
-export { ADAPTER_DEFAULTS, AssemblyAiSttProvider, AsyncQueue, AsyncQueueConsumerError, BackendUnavailableError, CartesiaTtsProvider, ConversationPolicy, CorruptRecordError, DEFAULT_DURABLE_RUNTIME_POLICY, DTMF_DIGITS, DeepgramSttProvider, DurableError, EVENT_KIND_MAP, ElevenLabsSttProvider, ElevenLabsTtsProvider, InMemoryMemory, InMemorySessionLeaseStore, InMemorySessionStore, InMemoryToolCallStore, InMemoryToolIdempotencyStore, InMemoryTurnStore, InvalidArgumentError, LeaseLostError, LeaseUnavailableError, MemoryBackendUnavailableError, MemoryEntryTooLargeError, MemorySessionQuotaExceededError, NodeMediaPlane, PCM16_16K_MONO, PCM16_8K_MONO, PROVIDER_API_VERSIONS, PROVIDER_CATALOG, PROVIDER_ERROR_CODES, PROVIDER_NAMES, PROVIDER_STABILITY, PipelineVoiceLoop, PipelineVoiceLoopBuilder, RUNTIME_SAMPLE_RATE_HZ, RecordConflictError, RecordNotFoundError, STT_ERROR_CODES, STT_STREAM_ENDED_REASON, SarvamSttProvider, SessionReaper, SessionRecoveryCoordinator, SonioxSttProvider, TELEPHONY_SAMPLE_RATE_HZ, TVIC_ERROR_CODES, TVIC_ERROR_CODE_ALIASES, TVIC_ERROR_MARKER, TVIC_ERROR_NAMES, TvicThrowableError, TwilioMediaStreamCallHandle, TwilioMediaStreamsProvider, VoiceRuntimeFinalizationError, WEB_CLIENT_AUDIO_CLOSE_CODES, WEB_CLIENT_AUDIO_DEFAULTS, WebClientAudioCallHandle, WebClientAudioProvider, assertMemoryCapability, assertMemoryPolicySupported, assertPcm16leFormat, authError, base64ToBytes, bytesToBase64, cancelledError, canonicalizeTwilioData, computeTwilioSignature, connectionError, counterIdGenerator, createAssemblyAiSttProvider, createAudioNormalizer, createCartesiaTtsProvider, createDeepgramSttProvider, createDefaultIdGenerator, createElevenLabsSttProvider, createElevenLabsTtsProvider, createGroqChatLlmProvider, createInMemoryDurableRuntimeStore, createInMemoryMemory, createInMemorySessionStore, createInMemoryToolCallStore, createInMemoryTurnStore, createMediaEvent, createNodeMediaPlane, createOpenAiResponsesLlmProvider, createPostgresDurableRuntimeStore, createPostgresMemory, createPostgresRedisDurableRuntimeStore, createRedisDurableRuntimeStore, createRuntime, createSarvamSttProvider, createSonioxSttProvider, createSttSession, createSystemClock, createToolRegistry, createTwilioMediaStreamsProvider, createVoiceAgent, createWebClientAudioProvider, defineAgent, defineTool, deliverAssistantText, durationMsForPcm16le, evaluateProviderCompatibility, executeTool, formatMemoryContextAsSystemBlock, formatPreCallContextAsSystemBlock, frameCountForPcm16le, getSttRecoveryControl, idempotencyKeyFor, idempotencyRequestHashFor, internalError, interruptedError, isDtmfDigit, isIncrementalTextToSpeechProvider, isInputMediaEvent, isNormalizedError, isOutputMediaEvent, isProviderKind, isReconstructableAudioFormat, isSampleRateHz, isTerminalSession, isTerminalTurn, isTranscriptSegmentEvent, isTvicError, isTvicErrorName, kindForMediaEvent, matchPath, mediaError, monotonicOffsetMs, mulawToPcm16le, normalizeLegacyError, normalizeUnknownError, normalizedError, nowTimestamp, pcm16leToMulaw, providerError, rateLimitError, requireProviderKind, resamplePcm16le, resolvePreCallContext, resolvePreCallMemory, runPostgresMemoryMigrations, runPostgresMigrations, sameAudioFormat, shouldDeliverText, signVoiceSessionToken, signatureError, splitPcm16leFrames, stableStringify, supportsAudioFormat, supportsLanguage, supportsModel, terminalSessionFromRequest, terminalSourceForRequest, terminalTurnFromRequest, timeoutError, toTimestamp, toolError, toolInputError, tvicErrorFromJSON, unknownErrorMessage, validateJsonSchemaSubset, validationError, verifyTwilioSignature, verifyVoiceSessionToken, withSttReconnect };
-export type { ActiveSession, ActiveTurn, Agent, AgentAudioPolicy, AgentContextPolicy, AgentId, AgentMemoryPolicy, AgentProviders, AnyMediaEventInit, AssemblyAiProviderConfig, AssemblyAiSttProviderOptions, AssistantTextRecord, AudioFormat, AudioNormalizationMode, AudioNormalizer, AudioNormalizerOptions, AudioPayload, BackoffStrategy, Brand, Call, CallControlCapability, CallDirection, CallHandle, CallId, CallSnapshot, CallStatus, CancelledSession, CancelledTurn, CartesiaProviderConfig, CartesiaTtsProviderOptions, ChannelKind, ChannelLayout, CleanupErrorSummary, CleanupStage, Clock, CompletedSession, CompletedTurn, ConnectedCall, ConnectionObservabilityEvent, ConversationPolicyOptions, CounterIdGenerator, CreateVoiceAgentOptions, CreatedCall, CreatedSession, DeepgramProviderConfig, DeepgramSttProviderOptions, DefineAgentInput, DefineToolInput, DtmfDigit, DtmfReceivedEvent, DualProtocolResult, DurableErrorCode, DurableOutboxEvent, DurableRuntimeMetric, DurableRuntimePolicy, DurableRuntimeStore, DurableSessionTransaction, ElevenLabsSttCommitStrategy, ElevenLabsSttProviderConfig, ElevenLabsSttProviderOptions, ElevenLabsTtsProviderConfig, ElevenLabsTtsProviderOptions, EndSessionReason, EndSessionRequest, EndTurnRequest, EndedCall, ErrorCategory, ExecuteToolInput, FailedCall, FailedSession, FailedToolCall, FailedToolCallStatus, FailedTurn, GroqChatLlmProviderOptions, GroqProviderConfig, HealthCheckResult, HealthSnapshot, IdGenerator, IdempotencyPolicy, InMemoryDurableRuntimeStore, InMemoryDurableRuntimeStoreOptions, InMemoryMemoryOptions, InboundCallContext, InboundMediaEvent, IncrementalTextToSpeechProvider, InputAudioChunk, InputMediaEvent, InternalMediaEvent, InterruptRequestedEvent, InterruptionMode, InterruptionPolicy, JsonSchemaDocument, JsonValue, LLMProvider, LiveTerminalSource, LlmCompletion, LlmCompletionRequest, LlmInlineToolCall, LlmMessage, LlmMessageRole, LlmProviderConfig, LlmStreamEvent, LlmUsage, MediaAudioChunkEvent, MediaAudioCommittedEvent, MediaDirection, MediaErrorEvent, MediaEvent, MediaEventId, MediaEventKind, MediaEventType, MediaStreamEndedEvent, MediaStreamStartedEvent, MediaTransport, MediaTransportKind, Memory, MemoryCapabilities, MemoryEntry, MemoryEntryId, MemoryKind, MemoryPutOptions, MemoryQuery, MemoryRef, MemoryScope, NodeMediaPlaneConnection, NodeMediaPlaneConnectionErrorHandler, NodeMediaPlaneConnectionHandler, NodeMediaPlaneOptions, NodeMediaPlaneRequestHandler, NormalizedAudioEncoding, NormalizedError, OpenAiProviderConfig, OpenAiResponsesLlmProviderOptions, OrganizationId, OutboundCallRequest, OutputAudioChunk, OutputMediaEvent, PersonaConfig, PipelineVoiceLoopOptions, PipelineVoiceLoopResult, PostgresDurableStoreOptions, PostgresMemoryOptions, PostgresMigration, PostgresRedisDurableStoreOptions, PreCallContext, PreCallContextResolver, PreCallMemoryContext, PreCallMemoryResolver, Provider, ProviderAudioCapabilities, ProviderCancellationCapabilities, ProviderCapabilities, ProviderCatalogEntry, ProviderCompatibility, ProviderCompatibilityIssue, ProviderCompatibilityIssueCode, ProviderDataPolicy, ProviderEventId, ProviderForKind, ProviderKind, ProviderPlayoutCapabilities, ProviderRequirements, ProviderStability, ProviderStreamingCapabilities, ProviderToolCapabilities, ProviderTransport, QueuedToolCall, RecoveryPollResult, RedisClient, RedisMulti, RedisScanOptions, RedisSetResult, RedisStoreOptions, RequiredProviderCapabilities, RetryPolicy, RingingCall, RunningToolCall, Runtime, RuntimeOptions, RuntimeProvider, RuntimeServiceLifecycle, SampleRateHz, SarvamOutputMode, SarvamProviderConfig, SarvamSttProviderOptions, SchemaValidationResult, Session, SessionAttachment, SessionAttachmentHealth, SessionCancellationReason, SessionEndEvent, SessionEndMemorySnapshot, SessionId, SessionLease, SessionLeaseStore, SessionMemoryFinalization, SessionMetricsRecorder, SessionReaperOptions, SessionRecoveryCoordinatorOptions, SessionRuntimeMetadata, SessionSnapshot, SessionState, SessionStatus, SessionStore, SonioxProviderConfig, SonioxStructuredContext, SonioxSttProviderOptions, SpeechToTextProvider, SqlClient$1 as SqlClient, SqlPool$1 as SqlPool, SqlResult, StartAttachedSessionOptions, StartSessionOptions, StartTurnRequest, StartingSession, StoredSessionRecord, StoredToolCallRecord, StoredTurnRecord, StreamEndReason, SttCommitMode, SttOpenRequest, SttProviderConfig, SttReconnectOptions, SttRecoveryControl, SttRecoveryState, SttSession, SttSessionInputOptions, SttSessionOptions, SttStream, SttTimestampOrigin, SucceededToolCall, TelephonyProvider, TelephonyProviderConfig, TerminalSession, TerminalSessionDraft, TerminalSessionStatus, TerminalSource, TerminalToolCall, TerminalTurn, TextDeliveryMode, TextToSpeechProvider, TimeoutAction, TimeoutPolicy, Timestamp, ToolCall, ToolCallId, ToolCallRuntimeMetadata, ToolCallStatus, ToolCallStore, ToolDefinition, ToolExecutionContext, ToolExecutor, ToolId, ToolIdempotencyClaim, ToolIdempotencyClaimResult, ToolIdempotencyLease, ToolIdempotencyOutcome, ToolIdempotencyRecord, ToolIdempotencyStatus, ToolIdempotencyStore, ToolLogger, ToolName, ToolRegistry, ToolTenant, TranscriptEndpointEvent, TranscriptEndpointReason, TranscriptEvent, TranscriptEventType, TranscriptSegmentEvent, TranscriptSegmentEventType, TranscriptSpeechStartedEvent, TransportAudioEncoding, TransportAudioFormat, TtsAlignmentEvent, TtsAlignmentUnit, TtsEvent, TtsFlushAcknowledgement, TtsFlushCompletedEvent, TtsFlushId, TtsFlushResult, TtsProviderConfig, TtsSession, TtsSessionOpenRequest, TtsStream, TtsSynthesisRequest, Turn, TurnCancellationReason, TurnCommitRequestedEvent, TurnDetectionMode, TurnId, TurnInput, TurnLatency, TurnLatencyRecord, TurnOutput, TurnRuntimeMetadata, TurnStatus, TurnStore, TvicErrorName, TwilioFlatParams, TwilioMediaStreamCallHandleOptions, TwilioMediaStreamSocket, TwilioParamValue, TwilioParams, UpgradeAuthorization, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceEvent, VoiceRuntimeFailureMetadata, WebClientAudioCallHandleOptions, WebClientAudioConnectionEvent, WebClientAudioProviderOptions, WebClientAudioSocket, WorkflowId };
+export { ADAPTER_DEFAULTS, AssemblyAiSttProvider, AsyncQueue, AsyncQueueConsumerError, BackendUnavailableError, CartesiaSttProvider, CartesiaTtsProvider, ConversationPolicy, CorruptRecordError, DEFAULT_DURABLE_RUNTIME_POLICY, DTMF_DIGITS, DeepgramSttProvider, DurableError, EVENT_KIND_MAP, ElevenLabsSttProvider, ElevenLabsTtsHttpStreamProvider, ElevenLabsTtsProvider, ElevenLabsTtsRestProvider, InMemoryMemory, InMemorySessionLeaseStore, InMemorySessionStore, InMemoryToolCallStore, InMemoryToolIdempotencyStore, InMemoryTurnStore, InvalidArgumentError, LeaseLostError, LeaseUnavailableError, MAX_CARTESIA_INPUT_UTF16_CODE_UNITS, MAX_CARTESIA_INPUT_UTF8_BYTES, MAX_PROVIDER_AUDIO_OFFSET_MS, MemoryBackendUnavailableError, MemoryEntryTooLargeError, MemorySessionQuotaExceededError, NodeMediaPlane, PCM16_16K_MONO, PCM16_8K_MONO, PROVIDER_API_VERSIONS, PROVIDER_CATALOG, PROVIDER_ERROR_CODES, PROVIDER_NAMES, PROVIDER_STABILITY, PROVIDER_STABILITY_LEVELS, PipelineVoiceLoop, PipelineVoiceLoopBuilder, RUNTIME_SAMPLE_RATE_HZ, RecordConflictError, RecordNotFoundError, STT_ERROR_CODES, STT_STREAM_ENDED_REASON, SarvamSttProvider, SarvamTtsHttpStreamProvider, SarvamTtsProvider, SarvamTtsRestProvider, SessionReaper, SessionRecoveryCoordinator, SonioxSttProvider, TELEPHONY_SAMPLE_RATE_HZ, TVIC_ERROR_CODES, TVIC_ERROR_CODE_ALIASES, TVIC_ERROR_MARKER, TVIC_ERROR_NAMES, TWILIO_MAX_AUDIO_EVENT_BYTES, TvicThrowableError, TwilioMediaStreamCallHandle, TwilioMediaStreamsProvider, VoiceRuntimeFinalizationError, WEB_CLIENT_AUDIO_ACK_RETENTION_MS, WEB_CLIENT_AUDIO_CLOSE_CODES, WEB_CLIENT_AUDIO_DEFAULTS, WebClientAudioCallHandle, WebClientAudioProvider, assertMemoryCapability, assertMemoryPolicySupported, assertPcm16leFormat, authError, base64ToBytes, bytesToBase64, cancelledError, canonicalizeTwilioData, computeTwilioSignature, connectionError, counterIdGenerator, createAssemblyAiSttProvider, createAudioNormalizer, createCartesiaSttProvider, createCartesiaTtsProvider, createDeepgramSttProvider, createDefaultIdGenerator, createElevenLabsSttProvider, createElevenLabsTtsHttpStreamProvider, createElevenLabsTtsProvider, createElevenLabsTtsRestProvider, createGroqChatLlmProvider, createInMemoryDurableRuntimeStore, createInMemoryMemory, createInMemorySessionStore, createInMemoryToolCallStore, createInMemoryTurnStore, createMediaEvent, createNodeMediaPlane, createOpenAiResponsesLlmProvider, createPostgresDurableRuntimeStore, createPostgresMemory, createPostgresRedisDurableRuntimeStore, createRedisDurableRuntimeStore, createRuntime, createSarvamSttProvider, createSarvamTtsHttpStreamProvider, createSarvamTtsProvider, createSarvamTtsRestProvider, createSonioxSttProvider, createSttSession, createSystemClock, createToolRegistry, createTtsFailoverProvider, createTwilioMediaStreamsProvider, createVoiceAgent, createWebClientAudioProvider, defineAgent, defineTool, deliverAssistantText, durationMsForPcm16le, evaluateProviderCompatibility, executeTool, formatMemoryContextAsSystemBlock, formatPreCallContextAsSystemBlock, frameCountForPcm16le, getSttRecoveryControl, idempotencyKeyFor, idempotencyRequestHashFor, internalError, interruptedError, isDtmfDigit, isIncrementalTextToSpeechProvider, isInputMediaEvent, isNormalizedError, isOutputMediaEvent, isProviderKind, isReconstructableAudioFormat, isSampleRateHz, isTerminalSession, isTerminalTurn, isTranscriptSegmentEvent, isTvicError, isTvicErrorName, kindForMediaEvent, matchPath, mediaError, monotonicOffsetMs, mulawToPcm16le, normalizeLegacyError, normalizeUnknownError, normalizedError, nowTimestamp, pcm16leToMulaw, providerError, rateLimitError, requireProviderKind, resamplePcm16le, resolvePreCallContext, resolvePreCallMemory, runPostgresMemoryMigrations, runPostgresMigrations, sameAudioFormat, shouldDeliverText, signVoiceSessionToken, signatureError, splitPcm16leFrames, stableStringify, supportsAudioFormat, supportsBatchModel, supportsLanguage, supportsModel, terminalSessionFromRequest, terminalSourceForRequest, terminalTurnFromRequest, timeoutError, toTimestamp, toolError, toolInputError, tvicErrorFromJSON, unknownErrorMessage, validateJsonSchemaSubset, validationError, verifyTwilioSignature, verifyVoiceSessionToken, withSttReconnect };
+export type { ActiveSession, ActiveTurn, Agent, AgentAudioPolicy, AgentContextPolicy, AgentId, AgentMemoryPolicy, AgentProviders, AnyMediaEventInit, AssemblyAiProviderConfig, AssemblyAiSttProviderOptions, AssistantTextRecord, AudioFormat, AudioNormalizationMode, AudioNormalizer, AudioNormalizerOptions, AudioPayload, BackoffStrategy, Brand, Call, CallControlCapability, CallDirection, CallHandle, CallId, CallSnapshot, CallStatus, CancelledSession, CancelledTurn, CartesiaGenerationConfig, CartesiaProviderConfig, CartesiaSttMode, CartesiaSttProviderConfig, CartesiaSttProviderOptions, CartesiaTtsProviderOptions, ChannelKind, ChannelLayout, CleanupErrorSummary, CleanupStage, Clock, CompletedSession, CompletedTurn, ConnectedCall, ConnectionObservabilityEvent, ConversationPolicyOptions, CounterIdGenerator, CreateVoiceAgentOptions, CreatedCall, CreatedSession, DeepgramProviderConfig, DeepgramSttProviderOptions, DefineAgentInput, DefineToolInput, DtmfDigit, DtmfReceivedEvent, DualProtocolResult, DurableErrorCode, DurableOutboxEvent, DurableRuntimeMetric, DurableRuntimePolicy, DurableRuntimeStore, DurableSessionTransaction, ElevenLabsBatchSttRequest, ElevenLabsBatchSttResult, ElevenLabsBatchTimestampGranularity, ElevenLabsDialogueInput, ElevenLabsDialogueProvider, ElevenLabsDialogueSynthesisRequest, ElevenLabsDialogueTurnOptions, ElevenLabsEntityDetection, ElevenLabsHttpTtsProviderOptions, ElevenLabsPronunciationDictionaryLocator, ElevenLabsSttCommitStrategy, ElevenLabsSttProviderConfig, ElevenLabsSttProviderOptions, ElevenLabsTextNormalization, ElevenLabsTtsHttpSynthesisRequest, ElevenLabsTtsProviderConfig, ElevenLabsTtsProviderOptions, ElevenLabsTtsSendTextOptions, EndSessionReason, EndSessionRequest, EndTurnRequest, EndedCall, ErrorCategory, ExecuteToolInput, FailedCall, FailedSession, FailedToolCall, FailedToolCallStatus, FailedTurn, GroqChatLlmProviderOptions, GroqProviderConfig, HealthCheckResult, HealthSnapshot, IdGenerator, IdempotencyPolicy, InMemoryDurableRuntimeStore, InMemoryDurableRuntimeStoreOptions, InMemoryMemoryOptions, InboundCallContext, InboundMediaEvent, IncrementalTextToSpeechProvider, InputAudioChunk, InputMediaEvent, InternalMediaEvent, InterruptRequestedEvent, InterruptionMode, InterruptionPolicy, JsonSchemaDocument, JsonValue, LLMProvider, LiveTerminalSource, LlmCompletion, LlmCompletionRequest, LlmInlineToolCall, LlmMessage, LlmMessageRole, LlmProviderConfig, LlmStreamEvent, LlmUsage, MediaAudioChunkEvent, MediaAudioCommittedEvent, MediaDirection, MediaErrorEvent, MediaEvent, MediaEventId, MediaEventKind, MediaEventType, MediaStreamEndedEvent, MediaStreamStartedEvent, MediaTransport, MediaTransportKind, Memory, MemoryCapabilities, MemoryEntry, MemoryEntryId, MemoryKind, MemoryPutOptions, MemoryQuery, MemoryRef, MemoryScope, NodeMediaPlaneConnection, NodeMediaPlaneConnectionErrorHandler, NodeMediaPlaneConnectionHandler, NodeMediaPlaneOptions, NodeMediaPlaneRequestHandler, NormalizedAudioEncoding, NormalizedError, OpenAiProviderConfig, OpenAiResponsesLlmProviderOptions, OrganizationId, OutboundCallRequest, OutputAudioChunk, OutputMediaEvent, PersonaConfig, PipelineVoiceLoopOptions, PipelineVoiceLoopResult, PostgresDurableStoreOptions, PostgresMemoryOptions, PostgresMigration, PostgresRedisDurableStoreOptions, PreCallContext, PreCallContextResolver, PreCallMemoryContext, PreCallMemoryResolver, Provider, ProviderAudioCapabilities, ProviderBatchCapabilities, ProviderCancellationCapabilities, ProviderCapabilities, ProviderCatalogEntry, ProviderClock, ProviderCompatibility, ProviderCompatibilityIssue, ProviderCompatibilityIssueCode, ProviderDataPolicy, ProviderEventId, ProviderForKind, ProviderKind, ProviderPlayoutCapabilities, ProviderRequirements, ProviderStability, ProviderStreamingCapabilities, ProviderToolCapabilities, ProviderTransport, QueuedToolCall, RecoveryPollResult, RedisClient, RedisMulti, RedisScanOptions, RedisSetResult, RedisStoreOptions, RequiredProviderCapabilities, RetryPolicy, RingingCall, RunningToolCall, Runtime, RuntimeOptions, RuntimeProvider, RuntimeServiceLifecycle, SampleRateHz, SarvamOutputMode, SarvamProviderConfig, SarvamSttProviderOptions, SarvamTtsHttpProviderOptions, SarvamTtsProviderConfig, SarvamTtsProviderOptions, SchemaValidationResult, Session, SessionAttachment, SessionAttachmentHealth, SessionCancellationReason, SessionEndEvent, SessionEndMemorySnapshot, SessionId, SessionLease, SessionLeaseStore, SessionMemoryFinalization, SessionMetricsRecorder, SessionReaperOptions, SessionRecoveryCoordinatorOptions, SessionRuntimeMetadata, SessionSnapshot, SessionState, SessionStatus, SessionStore, SonioxProviderConfig, SonioxStructuredContext, SonioxSttProviderOptions, SpeechToTextProvider, SqlClient$1 as SqlClient, SqlPool$1 as SqlPool, SqlResult, StartAttachedSessionOptions, StartSessionOptions, StartTurnRequest, StartingSession, StoredSessionRecord, StoredToolCallRecord, StoredTurnRecord, StreamEndReason, SttBatchTimestampGranularity, SttBatchTranscription, SttBatchTranscriptionRequest, SttBatchWord, SttCommitMode, SttOpenRequest, SttProviderConfig, SttReconnectOptions, SttRecoveryControl, SttRecoveryState, SttSession, SttSessionInputOptions, SttSessionOptions, SttStream, SttTimestampOrigin, SucceededToolCall, TelephonyProvider, TelephonyProviderConfig, TerminalSession, TerminalSessionDraft, TerminalSessionStatus, TerminalSource, TerminalToolCall, TerminalTurn, TextDeliveryMode, TextToSpeechProvider, TimeoutAction, TimeoutPolicy, Timestamp, ToolCall, ToolCallId, ToolCallRuntimeMetadata, ToolCallStatus, ToolCallStore, ToolDefinition, ToolExecutionContext, ToolExecutor, ToolId, ToolIdempotencyClaim, ToolIdempotencyClaimResult, ToolIdempotencyLease, ToolIdempotencyOutcome, ToolIdempotencyRecord, ToolIdempotencyStatus, ToolIdempotencyStore, ToolLogger, ToolName, ToolRegistry, ToolTenant, TranscriptEndpointEvent, TranscriptEndpointReason, TranscriptEvent, TranscriptEventType, TranscriptSegmentEvent, TranscriptSegmentEventType, TranscriptSpeechStartedEvent, TransportAudioEncoding, TransportAudioFormat, TtsAlignmentEvent, TtsAlignmentUnit, TtsEvent, TtsFailoverContext, TtsFailoverPhase, TtsFailoverProviderOptions, TtsFlushAcknowledgement, TtsFlushCompletedEvent, TtsFlushId, TtsFlushResult, TtsProviderConfig, TtsSession, TtsSessionOpenRequest, TtsStream, TtsSynthesisRequest, Turn, TurnCancellationReason, TurnCommitRequestedEvent, TurnDetectionMode, TurnId, TurnInput, TurnLatency, TurnLatencyRecord, TurnOutput, TurnRuntimeMetadata, TurnStatus, TurnStore, TvicErrorName, TwilioFlatParams, TwilioMediaStreamCallHandleOptions, TwilioMediaStreamSocket, TwilioParamValue, TwilioParams, UpgradeAuthorization, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceEvent, VoiceRuntimeFailureMetadata, WebClientAudioCallHandleOptions, WebClientAudioConnectionEvent, WebClientAudioProviderOptions, WebClientAudioSocket, WorkflowId };