voice-runtime 1.0.1 → 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';
 
@@ -226,6 +227,48 @@ declare class MemorySessionQuotaExceededError extends DurableError {
     constructor(sessionId: string, usedBytes: number, requestedBytes: number, maxBytes: number);
 }
 
+/** Canonical cross-provider error codes shared by runtime and adapters. */
+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";
+    readonly providerInvalidRequest: "provider.invalid_request";
+    readonly providerSessionExpired: "provider.session_expired";
+    readonly providerProtocolInvalid: "provider.protocol_invalid";
+    readonly providerSequenceInvalid: "provider.sequence_invalid";
+    readonly providerUpstreamFailed: "provider.upstream_failed";
+    readonly providerIdentityMismatch: "provider.identity_mismatch";
+    readonly providerStreamBufferOverflow: "provider.stream_buffer_overflow";
+    readonly sttSessionBufferOverflow: "stt.session_buffer_overflow";
+    readonly sttCommitInFlight: "stt.commit_in_flight";
+    readonly llmProviderFailed: "llm.provider.failed";
+    readonly sttTransportUnexpectedEof: "stt.transport.unexpected_eof";
+    readonly ttsTransportUnexpectedEof: "tts.transport.unexpected_eof";
+    readonly llmProviderUnexpectedEof: "llm.provider.unexpected_eof";
+}>;
+/** One-release aliases accepted at provider and persisted-data boundaries. */
+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.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";
+    readonly "stt.provider.protocol_error": "provider.protocol_invalid";
+    readonly "stt.provider.service_unavailable": "provider.upstream_failed";
+    readonly "stt.provider.internal": "provider.upstream_failed";
+    readonly "model.unsupported": "provider.model_unsupported";
+    readonly "voice.unsupported": "provider.voice_unsupported";
+    readonly "stt.model_unsupported": "provider.model_unsupported";
+}>;
 declare const TELEPHONY_SAMPLE_RATE_HZ = 8000;
 declare const RUNTIME_SAMPLE_RATE_HZ = 16000;
 declare const PCM16_16K_MONO: {
@@ -242,11 +285,14 @@ 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";
     readonly openaiResponses: "openai-responses";
     readonly webClientAudio: "web-client-audio";
 };
@@ -257,30 +303,40 @@ 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";
+    readonly groqHttp: "groq.http_error";
+    readonly groqResponseFailed: "groq.response.failed";
+    readonly groqProtocol: "groq.protocol.error";
     readonly openaiResponses: "openai.responses.error";
     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";
-    readonly authFailed: "stt.provider.auth_failed";
-    readonly invalidRequest: "stt.provider.invalid_request";
-    readonly inputRejected: "stt.provider.input_rejected";
-    readonly rateLimited: "stt.provider.rate_limited";
-    readonly quotaExceeded: "stt.provider.quota_exceeded";
-    readonly serviceUnavailable: "stt.provider.service_unavailable";
-    readonly providerInternal: "stt.provider.internal";
-    readonly protocolError: "stt.provider.protocol_error";
-    readonly sessionExpired: "stt.provider.session_expired";
+    readonly authFailed: "provider.auth_failed";
+    readonly invalidRequest: "provider.invalid_request";
+    readonly inputRejected: "provider.input_rejected";
+    readonly rateLimited: "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: "provider.transport_timeout";
+    readonly closeTimeout: "stt.close_timeout";
     readonly bufferOverflow: "stt.reconnect.buffer_overflow";
+    readonly sessionBufferOverflow: "stt.session_buffer_overflow";
     readonly recoveryExhausted: "stt.reconnect.recovery_exhausted";
     readonly closed: "stt.reconnect.closed";
 };
@@ -774,58 +830,13 @@ interface FailedCall extends CallBase {
     readonly startedAt?: Timestamp;
 }
 type Call = CreatedCall | RingingCall | ConnectedCall | EndedCall | FailedCall;
-
-type SessionCancellationReason = "caller_hangup" | "transport_lost" | "recovery_expired" | "operator_requested" | "shutdown";
-type SessionStatus = "created" | "starting" | "active" | "interrupted" | "waiting_for_tool" | "ending" | "completed" | "failed" | "cancelled";
-interface SessionState {
-    readonly variables: Readonly<Record<string, unknown>>;
-    readonly currentTurnId?: TurnId;
-    readonly pendingToolCallIds: readonly ToolCallId[];
-    readonly turnSequence: number;
-}
-interface SessionBase {
-    readonly id: SessionId;
-    readonly agentId: AgentId;
-    readonly channel: ChannelKind;
-    readonly callId?: CallId;
-    /**
-     * Reserved for a future durable reference index. The runtime currently
-     * leaves this empty; memory adapters and session-end snapshots are the
-     * authoritative memory surfaces.
-     */
-    readonly memoryRefs: readonly MemoryEntryId[];
-    readonly metadata?: Readonly<Record<string, unknown>>;
-    readonly createdAt: Timestamp;
-    readonly state: SessionState;
-}
-interface CreatedSession extends SessionBase {
-    readonly status: "created";
-}
-interface StartingSession extends SessionBase {
-    readonly status: "starting";
-}
-interface ActiveSession extends SessionBase {
-    readonly status: "active" | "interrupted" | "waiting_for_tool" | "ending";
-    readonly startedAt: Timestamp;
-}
-type TerminalSessionStatus = "completed" | "failed" | "cancelled";
-interface TerminalSessionBase extends SessionBase {
-    readonly startedAt: Timestamp;
-    readonly endedAt: Timestamp;
-}
-interface CompletedSession extends TerminalSessionBase {
-    readonly status: "completed";
-}
-interface FailedSession extends TerminalSessionBase {
-    readonly status: "failed";
-    readonly error: NormalizedError;
-}
-interface CancelledSession extends TerminalSessionBase {
-    readonly status: "cancelled";
-    readonly cancelReason: SessionCancellationReason;
-}
-type TerminalSession = CompletedSession | FailedSession | CancelledSession;
-type Session = CreatedSession | StartingSession | ActiveSession | TerminalSession;
+/**
+ * The immutable value a managed runtime passes across its call boundary.
+ * Runtime validation supplies the deep-freeze guarantee; this alias keeps
+ * that boundary visible to TypeScript consumers without creating a second
+ * call union.
+ */
+type CallSnapshot = Readonly<Call>;
 
 type TurnCancellationReason = "barge_in" | "dtmf" | "explicit" | "timeout" | "not_heard" | "transport_lost" | "lease_lost" | "runtime_restarted";
 type TurnStatus = "started" | "listening" | "thinking" | "calling_tool" | "speaking" | "interrupted" | "completed" | "cancelled" | "failed";
@@ -913,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;
@@ -947,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;
@@ -980,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;
@@ -995,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" | "model.unsupported" | "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;
@@ -1103,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
@@ -1122,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 {
@@ -1193,18 +1247,24 @@ interface IncrementalTextToSpeechProvider extends TextToSpeechProvider {
 declare function isIncrementalTextToSpeechProvider(provider: TextToSpeechProvider): provider is IncrementalTextToSpeechProvider;
 
 type LlmMessageRole = "system" | "user" | "assistant" | "tool";
+interface LlmInlineToolCall {
+    readonly callRef: string;
+    readonly toolName: ToolName;
+    readonly input: unknown;
+}
 interface LlmMessage {
     readonly role: LlmMessageRole;
     readonly content: string;
     readonly toolCallRef?: string;
     readonly toolName?: ToolName;
+    /**
+     * Tool calls emitted by an assistant message. Providers that use native
+     * function-calling protocols need this envelope before the corresponding
+     * `tool` result messages.
+     */
+    readonly toolCalls?: readonly LlmInlineToolCall[];
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
-interface LlmInlineToolCall {
-    readonly callRef: string;
-    readonly toolName: ToolName;
-    readonly input: unknown;
-}
 interface LlmCompletionRequest {
     readonly sessionId: SessionId;
     readonly turnId: TurnId;
@@ -1498,6 +1558,8 @@ interface RuntimeOptions {
     readonly clock?: Clock;
     readonly idGenerator?: IdGenerator;
     readonly durableStore?: DurableRuntimeStore;
+    /** Whether the runtime may close an injected durable store during stop. */
+    readonly durableStoreOwnership?: "runtime" | "caller";
     /** Overrides for the explicit defaults; omitted values use the safe defaults. */
     readonly durablePolicy?: Partial<DurableRuntimePolicy>;
     readonly toolIdempotencyStore?: ToolIdempotencyStore;
@@ -1711,6 +1773,8 @@ interface HealthCheckResult {
     readonly ok: boolean;
     readonly latencyMs?: number;
     readonly message?: string;
+    /** Sanitized diagnostic details supplied by the owning subsystem. */
+    readonly details?: Readonly<Record<string, unknown>>;
 }
 interface DurableRuntimeMetric {
     readonly name: string;
@@ -1754,17 +1818,22 @@ interface StartSessionOptions {
     readonly workflowId?: WorkflowId;
 }
 type EndSessionReason = "completed" | "cancelled" | "failed" | "timeout";
+type TerminalSource = "operator_stop" | "caller_abort" | "run_timeout" | "remote_transport" | "provider_runtime" | "normal_completion" | "runtime_recovery" | "runtime_shutdown" | "legacy_unknown";
 type EndSessionRequest = {
     readonly reason: "completed";
+    readonly terminalSource?: "normal_completion" | "legacy_unknown";
 } | {
     readonly reason: "cancelled";
     readonly cancelReason: SessionCancellationReason;
+    readonly terminalSource?: "operator_stop" | "caller_abort" | "remote_transport" | "runtime_recovery" | "runtime_shutdown" | "legacy_unknown";
 } | {
     readonly reason: "failed";
     readonly error: NormalizedError;
+    readonly terminalSource?: "provider_runtime" | "legacy_unknown";
 } | {
     readonly reason: "timeout";
     readonly error: NormalizedError;
+    readonly terminalSource?: "run_timeout" | "legacy_unknown";
 };
 interface StartTurnRequest {
     readonly sessionId: SessionId;
@@ -1823,7 +1892,7 @@ interface SessionAttachment {
 }
 interface RuntimeServiceLifecycle {
     /** Starts the runtime. A runtime can be started once; create a new runtime after stop. */
-    start(): Promise<void>;
+    start(signal?: AbortSignal): Promise<void>;
     /**
      * Stops the runtime and closes its owned resources. The operation is
      * idempotent and concurrent callers await the same teardown. A stopped
@@ -1833,6 +1902,13 @@ interface RuntimeServiceLifecycle {
     readonly isRunning: boolean;
 }
 interface Runtime extends RuntimeServiceLifecycle {
+    /**
+     * Optional execution seam for low-level pipeline users. Registered runs are
+     * cancelled and drained by `stop()` before the runtime closes its durable
+     * stores. Managed voice agents already provide their own higher-level
+     * lifecycle, but direct `PipelineVoiceLoop` callers need this ownership too.
+     */
+    registerPipelineRun?(run: Promise<unknown>, cancel: () => void): () => void;
     startSession(agent: Agent, options: StartSessionOptions): Promise<ActiveSession>;
     startAttachedSession(agent: Agent, options: StartAttachedSessionOptions): Promise<SessionAttachment>;
     attachSession(agent: Agent, sessionId: SessionId, options?: {
@@ -1875,6 +1951,60 @@ interface Runtime extends RuntimeServiceLifecycle {
     readonly memory?: Memory;
 }
 
+type SessionCancellationReason = "caller_hangup" | "transport_lost" | "recovery_expired" | "operator_requested" | "shutdown";
+type SessionStatus = "created" | "starting" | "active" | "interrupted" | "waiting_for_tool" | "ending" | "completed" | "failed" | "cancelled";
+interface SessionState {
+    readonly variables: Readonly<Record<string, unknown>>;
+    readonly currentTurnId?: TurnId;
+    readonly pendingToolCallIds: readonly ToolCallId[];
+    readonly turnSequence: number;
+}
+interface SessionBase {
+    readonly id: SessionId;
+    readonly agentId: AgentId;
+    readonly channel: ChannelKind;
+    readonly callId?: CallId;
+    /**
+     * Reserved for a future durable reference index. The runtime currently
+     * leaves this empty; memory adapters and session-end snapshots are the
+     * authoritative memory surfaces.
+     */
+    readonly memoryRefs: readonly MemoryEntryId[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly createdAt: Timestamp;
+    readonly state: SessionState;
+}
+interface CreatedSession extends SessionBase {
+    readonly status: "created";
+}
+interface StartingSession extends SessionBase {
+    readonly status: "starting";
+}
+interface ActiveSession extends SessionBase {
+    readonly status: "active" | "interrupted" | "waiting_for_tool" | "ending";
+    readonly startedAt: Timestamp;
+}
+type TerminalSessionStatus = "completed" | "failed" | "cancelled";
+interface TerminalSessionBase extends SessionBase {
+    readonly startedAt: Timestamp;
+    readonly endedAt: Timestamp;
+    /** Terminal provenance is optional only for legacy in-memory values. */
+    readonly terminalSource?: TerminalSource;
+}
+interface CompletedSession extends TerminalSessionBase {
+    readonly status: "completed";
+}
+interface FailedSession extends TerminalSessionBase {
+    readonly status: "failed";
+    readonly error: NormalizedError;
+}
+interface CancelledSession extends TerminalSessionBase {
+    readonly status: "cancelled";
+    readonly cancelReason: SessionCancellationReason;
+}
+type TerminalSession = CompletedSession | FailedSession | CancelledSession;
+type Session = CreatedSession | StartingSession | ActiveSession | TerminalSession;
+
 interface TerminalSessionDraft {
     readonly id: SessionId;
     readonly agentId: AgentId;
@@ -1889,19 +2019,25 @@ interface TerminalSessionDraft {
     readonly endedAt: Timestamp;
 }
 declare function terminalSessionFromRequest(draft: TerminalSessionDraft, request: EndSessionRequest): TerminalSession;
+declare function terminalSourceForRequest(request: EndSessionRequest): TerminalSource;
 declare function terminalTurnFromRequest(turn: ActiveTurn, request: EndTurnRequest, endedAt: Timestamp, durationMs: number): TerminalTurn;
 declare function isTerminalSession(session: Session): session is TerminalSession;
 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;
 }
@@ -1911,7 +2047,11 @@ interface TwilioMediaStreamCallHandleOptions {
     readonly sessionId: SessionId;
     readonly inputFormat?: AudioFormat;
     readonly outputFormat?: AudioFormat;
+    /** Values authenticated by the host and expected in Twilio's start frame. */
+    readonly expectedTwilioCallSid?: string;
+    readonly expectedAccountSid?: string;
     readonly clock?: ProviderClock;
+    readonly onClosed?: () => void;
 }
 declare class TwilioMediaStreamCallHandle implements CallHandle {
     #private;
@@ -1924,6 +2064,8 @@ declare class TwilioMediaStreamCallHandle implements CallHandle {
     close(reason: StreamEndReason): Promise<void>;
     confirmPlayout(markId: string, timeoutMs: number): Promise<boolean>;
 }
+
+/** Accept-only bridge for a host-authenticated Twilio Media Streams socket. */
 declare class TwilioMediaStreamsProvider implements TelephonyProvider {
     #private;
     readonly name: "twilio-media-streams";
@@ -1963,29 +2105,32 @@ declare class TwilioMediaStreamsProvider implements TelephonyProvider {
     dial(): Promise<CallHandle>;
     accept(ctx: Parameters<TelephonyProvider["accept"]>[0]): Promise<CallHandle>;
     attachWebSocket(socket: TwilioMediaStreamSocket, callId: CallId, sessionId: SessionId): void;
-    acceptWebSocket(socket: TwilioMediaStreamSocket, callId: CallId, sessionId: SessionId): Promise<TwilioMediaStreamCallHandle>;
-    hangup(_callId: CallId): Promise<void>;
+    acceptWebSocket(socket: TwilioMediaStreamSocket, callId: CallId, sessionId: SessionId, options?: Pick<TwilioMediaStreamCallHandleOptions, "expectedTwilioCallSid" | "expectedAccountSid">): Promise<TwilioMediaStreamCallHandle>;
+    hangup(callId: CallId): Promise<void>;
 }
 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;
     send(data: string | Buffer): void;
     close(code?: number, reason?: string): void;
     on(event: "message", handler: (data: WebSocket.RawData, isBinary: boolean) => void): this;
@@ -2029,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>;
@@ -2041,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;
@@ -2089,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 {
@@ -2099,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";
@@ -2135,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;
@@ -2146,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;
@@ -2179,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[];
@@ -2190,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: {
@@ -2223,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;
@@ -2291,138 +2485,129 @@ 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 {
-    readonly apiKey: string;
-    readonly url?: string;
-    readonly clock?: ProviderClock;
+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;
 }
-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>;
+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>>[];
 }
-declare function createOpenAiResponsesLlmProvider(options: OpenAiResponsesLlmProviderOptions): OpenAiResponsesLlmProvider;
 
-interface CartesiaTtsProviderOptions {
+type ElevenLabsSttCommitStrategy = "manual" | "vad";
+
+interface ElevenLabsSttProviderOptions {
     readonly apiKey: string;
     readonly url?: string;
-    readonly voiceId: string;
+    readonly batchUrl?: string;
+    readonly allowUnknownModel?: boolean;
     readonly modelId?: string;
-    readonly language?: 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 webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly fetchImpl?: typeof fetch;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
-declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
+declare class ElevenLabsSttProvider implements SpeechToTextProvider {
     #private;
-    readonly name: "cartesia";
-    readonly kind = "tts";
+    readonly name: "elevenlabs-stt-realtime";
+    readonly kind = "stt";
     readonly version = "0.1.0";
     readonly capabilities: {
         streaming: {
@@ -2436,21 +2621,50 @@ declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
             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:
@@ -2474,20 +2688,32 @@ 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";
     readonly elevenlabs: "experimental";
@@ -2496,40 +2722,57 @@ declare const PROVIDER_STABILITY: Readonly<{
 }>;
 declare const PROVIDER_CATALOG: {
     readonly deepgram: {
-        readonly verifiedAt: "2026-07-24";
+        readonly verifiedAt: "2026-09-15";
         readonly source: "https://developers.deepgram.com/docs/models-languages-overview";
         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-08-20";
-        readonly source: "https://docs.sarvam.ai/api-reference/legacy/speech-to-text/transcribe/ws";
+        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-07-24";
-        readonly source: "https://docs.cartesia.ai/api-reference/tts/tts";
-        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";
@@ -2537,6 +2780,12 @@ declare const PROVIDER_CATALOG: {
         readonly defaultModel: "stt-rt-v5";
         readonly models: readonly ["stt-rt-v5"];
     };
+    readonly groq: {
+        readonly verifiedAt: "2026-09-15";
+        readonly source: "https://console.groq.com/docs/models";
+        readonly defaultModel: "openai/gpt-oss-20b";
+        readonly models: readonly ["openai/gpt-oss-20b", "openai/gpt-oss-120b"];
+    };
     readonly openaiResponses: {
         readonly verifiedAt: "2026-07-24";
         readonly source: "https://platform.openai.com/docs/models";
@@ -2549,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,
@@ -2568,21 +2818,468 @@ declare const ADAPTER_DEFAULTS: {
         readonly flushSignal: true;
         readonly inputAudioCodec: "pcm_s16le";
     };
-    readonly cartesia: {
-        readonly language: "en";
+    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;
@@ -2609,14 +3306,207 @@ 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;
+declare function pcm16leToMulaw(pcm: Uint8Array): Uint8Array;
+/**
+ * v0.1 normalized audio is frozen to **pcm_s16le, mono**. The frame/duration/
+ * resample helpers below compute on interleaved-sample assumptions that only hold
+ * for a single channel, so a stereo format would silently corrupt timing. We
+ * reject it at the boundary rather than miscompute.
+ */
+declare function assertPcm16leFormat(format: AudioFormat): void;
+declare function resamplePcm16le(pcm: Uint8Array, fromSampleRateHz: number, toSampleRateHz: number): Uint8Array;
+declare function frameCountForPcm16le(bytes: Uint8Array): number;
+declare function durationMsForPcm16le(bytes: Uint8Array, sampleRateHz: number): number;
+declare function splitPcm16leFrames(bytes: Uint8Array, format: AudioFormat, frameDurationMs: number): readonly Uint8Array[];
+
+/**
+ * Thrown synchronously when a second live iterator claims the queue. The
+ * stable `code` is the cross-realm detection contract.
+ */
+declare class AsyncQueueConsumerError extends Error {
+    readonly name = "AsyncQueueConsumerError";
+    readonly code: "async_queue.consumer_already_claimed";
+    constructor();
+}
+interface AsyncQueueOptions {
+    readonly maxBuffered?: number;
+    /**
+     * Supplies the terminal error to deliver when a bounded queue is full. When
+     * omitted, `push()` keeps its non-throwing boolean-only contract and the
+     * caller remains responsible for handling `false`.
+     */
+    readonly onOverflow?: () => unknown;
+}
+/**
+ * Bounded, single-live-consumer async queue. Producer close drains buffered
+ * values; consumer return discards them; fail rejects pending and future
+ * reads. A second live consumer is rejected synchronously.
+ */
+declare class AsyncQueue<T> implements AsyncIterable<T> {
+    #private;
+    constructor(options?: AsyncQueueOptions);
+    get isClosed(): boolean;
+    push(value: T): boolean;
+    fail(error: unknown): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+interface AudioNormalizerOptions {
+    readonly inputFormat: AudioFormat;
+    readonly outputFormat?: AudioFormat;
+    readonly channelPolicy?: "average" | "left";
+}
+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;
+}
+/**
+ * Converts supported PCM source frames into PCM16LE mono while preserving
+ * sample-clock phase across arbitrary realtime chunk boundaries.
+ *
+ * The FIR is intentionally small and deterministic. It is causal with a
+ * bounded look-ahead: ordinary pushes emit only samples whose filter support is
+ * present, while an explicit segment/stream finish uses the final source sample
+ * as the endpoint. This prevents packet boundaries from becoming resampling
+ * boundaries.
+ */
+declare function createAudioNormalizer(options: AudioNormalizerOptions): AudioNormalizer;
+
+declare function isInputMediaEvent(event: MediaEvent): event is InputMediaEvent;
+declare function isOutputMediaEvent(event: MediaEvent): event is OutputMediaEvent;
+
 /**
  * A single param value or an array of repeated param values. Twilio sends
  * each value as a separate URL-encoded occurrence in the POST body, so a
@@ -2650,11 +3540,6 @@ interface VerifyTwilioOptions {
      *             verifyTwilioSignature({...authTokenB});
      */
     readonly authToken: string;
-    /**
-     * When true, return true unconditionally. Use this ONLY in tests, never
-     * in production. Defaults to false.
-     */
-    readonly skipVerification?: boolean;
 }
 declare function canonicalizeTwilioData(url: string, params: TwilioFlatParams | TwilioParams): Buffer;
 /**
@@ -2712,10 +3597,6 @@ interface VerifyVoiceSessionTokenOptions {
      * Use this if server and client clocks are skewed.
      */
     readonly toleranceMs?: number;
-    /**
-     * When true, return true unconditionally. Use ONLY in tests.
-     */
-    readonly skipVerification?: boolean;
 }
 /**
  * Compute the expected voice-session token for a given session ref
@@ -2749,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> {
@@ -2866,7 +3748,7 @@ declare class SessionRecoveryCoordinator {
     #private;
     constructor(options: SessionRecoveryCoordinatorOptions);
     start(): void;
-    stop(): void;
+    stop(): Promise<void>;
     pollOnce(): Promise<RecoveryPollResult>;
 }
 interface SessionReaperOptions {
@@ -2887,7 +3769,7 @@ declare class SessionReaper {
     #private;
     constructor(options: SessionReaperOptions);
     start(): void;
-    stop(): void;
+    stop(): Promise<void>;
     reapOnce(): Promise<number>;
 }
 
@@ -2932,7 +3814,7 @@ declare class ConversationPolicy {
     /** Commits buffered final segments for an endpoint, timeout, or stream shutdown. */
     flushBufferedTranscript(): string | null;
     messagesForTranscript(transcript: string): readonly LlmMessage[];
-    messagesForToolContinuation(messages: readonly LlmMessage[], assistantText: string, toolMessages: readonly LlmMessage[]): readonly LlmMessage[];
+    messagesForToolContinuation(messages: readonly LlmMessage[], assistantText: string, toolMessages: readonly LlmMessage[], assistantToolCalls?: readonly LlmInlineToolCall[]): readonly LlmMessage[];
     recordTurn(transcript: string, assistantText: string): void;
     recordInterruptedTurn(transcript: string, assistantText: string): void;
     findTool(call: LlmInlineToolCall): ToolDefinition | null;
@@ -2971,7 +3853,11 @@ interface SttReconnectOptions {
     readonly uncertainWindowMs?: number;
     readonly maxBufferedBytes?: number;
     readonly maxBufferedCommands?: number;
+    /** Bounds provider acceptance of one audio command in each generation. */
+    readonly sendTimeoutMs?: number;
     readonly commitTimeoutMs?: number;
+    readonly audioWriteTimeoutMs?: number;
+    readonly closeTimeoutMs?: number;
 }
 /**
  * Wraps one STT provider with bounded, best-effort reconnect and replay policy.
@@ -3006,6 +3892,8 @@ declare function deliverAssistantText(options: {
     readonly mode?: TextDeliveryMode;
     readonly audioDelivered: boolean;
     readonly cancelledByBargeIn: boolean;
+    /** Internal seam for deterministic tests and slow text transports. */
+    readonly timeoutMs?: number;
 }): Promise<boolean | undefined>;
 
 /**
@@ -3058,7 +3946,8 @@ type VoiceEvent = {
 };
 /**
  * The result of starting a `PipelineVoiceLoop`. Dual-protocol: awaits
- * to a final `PipelineVoiceLoopResult` AND iterates the per-event
+ * to a final `PipelineVoiceLoopResult` with an explicit terminal reason and
+ * source, AND iterates the per-event
  * stream.
  *
  * Implementation note: the class implements both `PromiseLike<PipelineVoiceLoopResult>`
@@ -3096,7 +3985,7 @@ type PipelineVoiceLoopResultLike = PipelineVoiceLoopResult;
  * supervisor controller.
  *
  * The double-set guard rejects a second `abortSignal` call. To compose
- * multiple signals, use `AbortSignal.any([a, b])` (Node 20+) before
+ * multiple signals, use `AbortSignal.any([a, b])` (Node 22+) before
  * passing them in.
  */
 declare class PipelineVoiceLoopBuilder {
@@ -3123,9 +4012,15 @@ declare class PipelineVoiceLoopBuilder {
 interface PipelineVoiceLoopLike {
     _startInternal(options: {
         readonly overrideSignal?: AbortSignal;
+        readonly consumer?: "internal" | "public";
+        /** Internal lifecycle hook; does not observe or assimilate the thenable. */
+        readonly onRunPromise?: (promise: Promise<PipelineVoiceLoopResult>) => void;
     }): DualProtocolResult;
 }
 
+/** The six sources that may win a live pipeline terminal race. */
+type LiveTerminalSource = Extract<TerminalSource, "operator_stop" | "caller_abort" | "run_timeout" | "remote_transport" | "provider_runtime" | "normal_completion">;
+
 interface TurnLatencyRecord {
     readonly sessionId: SessionId;
     readonly turnId: TurnId;
@@ -3163,6 +4058,8 @@ interface PipelineVoiceLoopOptions {
     readonly turnEndpointTimeoutMs?: number;
     /** Absolute cap from the first immutable final segment in one utterance. */
     readonly turnMaxDurationMs?: number;
+    /** Optional managed-owner source for an external cancellation signal. */
+    readonly terminalSourceForCancellation?: () => LiveTerminalSource | undefined;
     /**
      * Receives one record per terminal turn. This is an observation seam, not part of
      * execution: it is invoked after the turn is already terminal, its return value is
@@ -3172,12 +4069,23 @@ interface PipelineVoiceLoopOptions {
     readonly onAssistantText?: (record: AssistantTextRecord) => void;
     readonly sessionMetricsRecorder?: SessionMetricsRecorder;
 }
+type PipelineVoiceLoopTerminalReason = "completed" | "cancelled" | "failed" | "remote_hangup";
 interface PipelineVoiceLoopResult {
     readonly session: ActiveSession;
     readonly turnsHandled: number;
     readonly interruptions: number;
     readonly turnsFailed: number;
     readonly firstTurnError: NormalizedError | null;
+    /**
+     * Terminal reason for RESOLVED runs (additive; existing readers ignore it).
+     * Precedence: cancelled (explicit cancel/abort won) > failed (one or more
+     * failed turns, or a timeout/error stream end) > remote_hangup >
+     * completed. Rejected runs carry their terminal in the rejection instead;
+     * unified cancel/remote arbitration with scheduler batches is joint T1
+     * work — this field reports the resolved outcome only.
+     */
+    readonly terminalReason: PipelineVoiceLoopTerminalReason;
+    readonly terminalSource: LiveTerminalSource;
 }
 /**
  * Runs a pipeline voice session: media -> STT -> LLM/tools -> TTS -> media.
@@ -3205,9 +4113,31 @@ declare class PipelineVoiceLoop {
      */
     _startInternal(options: {
         readonly overrideSignal?: AbortSignal;
+        readonly consumer?: "internal" | "public";
+        /** Internal lifecycle hook used by managed wrappers without thenable assimilation. */
+        readonly onRunPromise?: (promise: Promise<PipelineVoiceLoopResult>) => void;
     }): DualProtocolResult;
 }
 
+type CleanupStage = "call.close" | "runtime.endSession" | "runtime.stop" | "late.call.close" | "late.runtime.endSession" | "late.runtime.stop";
+interface CleanupErrorSummary {
+    readonly stage: CleanupStage;
+    readonly code: string;
+    readonly message: string;
+}
+interface VoiceRuntimeFailureMetadata {
+    readonly degraded: boolean;
+    readonly callClosed: boolean;
+    readonly sessionEnded: boolean;
+    readonly timedOut: boolean;
+    readonly lateCleanupPending: boolean;
+    readonly primaryCode: string;
+    readonly cleanupErrors: readonly CleanupErrorSummary[];
+}
+declare class VoiceRuntimeFinalizationError extends TvicThrowableError {
+    constructor(raw: NormalizedError | null, cleanupErrors: readonly CleanupErrorSummary[], metadata: VoiceRuntimeFailureMetadata);
+}
+
 type AudioNormalizationMode = "auto" | "never";
 interface SttSessionInputOptions {
     readonly format: AudioFormat;
@@ -3228,6 +4158,12 @@ interface SttSessionOptions {
     readonly vocabulary?: readonly string[];
     readonly metadata?: Readonly<Record<string, unknown>>;
     readonly openTimeoutMs?: number;
+    /** Bounds provider acceptance of one audio command. */
+    readonly sendTimeoutMs?: number;
+    /** Bounds provider acceptance of one commit barrier. */
+    readonly commitTimeoutMs?: number;
+    /** Bounds an ordered close before the session switches to forced teardown. */
+    readonly closeTimeoutMs?: number;
     readonly signal?: AbortSignal;
     readonly clock?: Clock;
     readonly idGenerator?: IdGenerator;
@@ -3259,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>>;
@@ -3267,11 +4203,13 @@ 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;
     readonly path: string;
+    /** Maximum inbound WebSocket frame accepted before the connection is closed. */
+    readonly maxInboundFrameBytes?: number;
     readonly healthPath?: string;
     /**
      * Optional health check. Called when the plane's `healthPath` endpoint
@@ -3327,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;
@@ -3340,20 +4283,46 @@ type OpenAiProviderConfig = Omit<OpenAiResponsesLlmProviderOptions, "apiKey"> &
     /** Allows a custom OpenAI-compatible endpoint to use a model outside TVIC's dated catalog. */
     readonly allowUnknownModel?: boolean;
 };
-type LlmProviderConfig = OpenAiProviderConfig;
+type GroqProviderConfig = Omit<GroqChatLlmProviderOptions, "apiKey"> & {
+    readonly provider: "groq";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly allowUnknownModel?: boolean;
+};
+type LlmProviderConfig = OpenAiProviderConfig | GroqProviderConfig;
 type CartesiaProviderConfig = Omit<CartesiaTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
     readonly provider: "cartesia";
     readonly apiKey?: string;
     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;
@@ -3403,6 +4372,8 @@ interface VoiceAgentRunOptions {
     readonly organizationId?: OrganizationId;
     readonly workflowId?: WorkflowId;
     readonly signal?: AbortSignal;
+    /** Maximum time allowed to start the runtime, attach the call, and create the run. */
+    readonly startupTimeoutMs?: number;
     readonly safetyIdentifier?: string;
     readonly sttReconnect?: boolean | SttReconnectOptions;
     readonly sttLanguage?: string;
@@ -3413,8 +4384,11 @@ interface VoiceAgentRunOptions {
 }
 interface VoiceAgentCallHandleContext {
     readonly sessionId: SessionId;
-    readonly call: Call;
+    /** A deeply frozen copy of the validated call supplied to start(). */
+    readonly call: CallSnapshot;
     readonly channel: ChannelKind;
+    /** Aborts when the caller, startup deadline, or global agent shutdown wins. */
+    readonly signal: AbortSignal;
 }
 type VoiceAgentCallHandleFactory = (context: VoiceAgentCallHandleContext) => CallHandle | PromiseLike<CallHandle>;
 interface VoiceAgentRun extends DualProtocolResult {
@@ -3441,68 +4415,6 @@ interface VoiceAgent {
 }
 declare function createVoiceAgent(options: CreateVoiceAgentOptions): VoiceAgent;
 
-declare function bytesToBase64(bytes: Uint8Array): string;
-declare function base64ToBytes(value: string): Uint8Array;
-declare function mulawToPcm16le(mulaw: Uint8Array): Uint8Array;
-declare function pcm16leToMulaw(pcm: Uint8Array): Uint8Array;
-/**
- * v0.1 normalized audio is frozen to **pcm_s16le, mono**. The frame/duration/
- * resample helpers below compute on interleaved-sample assumptions that only hold
- * for a single channel, so a stereo format would silently corrupt timing. We
- * reject it at the boundary rather than miscompute.
- */
-declare function assertPcm16leFormat(format: AudioFormat): void;
-declare function resamplePcm16le(pcm: Uint8Array, fromSampleRateHz: number, toSampleRateHz: number): Uint8Array;
-declare function frameCountForPcm16le(bytes: Uint8Array): number;
-declare function durationMsForPcm16le(bytes: Uint8Array, sampleRateHz: number): number;
-declare function splitPcm16leFrames(bytes: Uint8Array, format: AudioFormat, frameDurationMs: number): readonly Uint8Array[];
-
-/**
- * A deliberately unbounded, single-consumer async queue: exactly one iterator
- * may drain it, and pushed values resolve waiters in FIFO order. Lives in
- * `@tvic/media` because it is the one package both `@tvic/providers` and
- * `@tvic/runtime` are allowed to depend on (see `scripts/check-architecture.mjs`),
- * so provider adapters and the runtime's own session/stream wrappers share this
- * one implementation instead of each keeping a private copy.
- */
-declare class AsyncQueue<T> implements AsyncIterable<T> {
-    #private;
-    constructor(options?: {
-        readonly maxBuffered?: number;
-    });
-    push(value: T): boolean;
-    fail(error: unknown): void;
-    close(): void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
-
-interface AudioNormalizerOptions {
-    readonly inputFormat: AudioFormat;
-    readonly outputFormat?: AudioFormat;
-    readonly channelPolicy?: "average" | "left";
-}
-interface AudioNormalizer {
-    readonly inputFormat: AudioFormat;
-    readonly outputFormat: AudioFormat;
-    push(bytes: Uint8Array): Uint8Array;
-    finishSegment(): Uint8Array;
-    finish(): Uint8Array;
-}
-/**
- * Converts supported PCM source frames into PCM16LE mono while preserving
- * sample-clock phase across arbitrary realtime chunk boundaries.
- *
- * The FIR is intentionally small and deterministic. It is causal with a
- * bounded look-ahead: ordinary pushes emit only samples whose filter support is
- * present, while an explicit segment/stream finish uses the final source sample
- * as the endpoint. This prevents packet boundaries from becoming resampling
- * boundaries.
- */
-declare function createAudioNormalizer(options: AudioNormalizerOptions): AudioNormalizer;
-
-declare function isInputMediaEvent(event: MediaEvent): event is InputMediaEvent;
-declare function isOutputMediaEvent(event: MediaEvent): event is OutputMediaEvent;
-
 declare class InMemorySessionStore implements SessionStore {
     #private;
     get(id: SessionId): Promise<StoredSessionRecord | null>;
@@ -3668,9 +4580,21 @@ declare function idempotencyKeyFor<TInput, TOutput>(input: ExecuteToolInput<TInp
 declare function idempotencyRequestHashFor<TInput, TOutput>(input: ExecuteToolInput<TInput, TOutput>): string;
 declare function executeTool<TInput = unknown, TOutput = unknown>(input: ExecuteToolInput<TInput, TOutput>): Promise<ToolCall>;
 
+interface PersistedErrorCompatibilityDiagnostic {
+    readonly adapter: "postgres" | "redis";
+    readonly operation: "idempotency_alias_rewrite";
+    readonly key: string;
+    readonly legacyCode: string;
+    readonly canonicalCode: string;
+    readonly outcome: "rewrite_failed";
+}
+
 declare class PostgresToolIdempotencyStore implements ToolIdempotencyStore {
+    #private;
     readonly client: SqlClient$1;
-    constructor(client: SqlClient$1);
+    constructor(client: SqlClient$1, options?: {
+        readonly onCompatibilityDiagnostic?: (diagnostic: PersistedErrorCompatibilityDiagnostic) => void;
+    });
     lookup(key: string, requestHash: string): Promise<ToolIdempotencyRecord | null>;
     claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
     complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
@@ -3827,6 +4751,7 @@ interface RedisStoreOptions {
     readonly nowMs?: () => number;
     readonly maxTransactionRetries?: number;
     readonly closeClient?: boolean;
+    readonly onCompatibilityDiagnostic?: (diagnostic: PersistedErrorCompatibilityDiagnostic) => void;
 }
 
 declare class RedisSessionStore implements SessionStore {
@@ -3931,13 +4856,13 @@ declare function createPostgresRedisDurableRuntimeStore(options: PostgresRedisDu
 interface SqlClient {
     query<TRow extends Record<string, unknown> = Record<string, unknown>>(text: string, params?: readonly unknown[]): Promise<{
         rows: readonly TRow[];
-        rowCount: number;
+        rowCount?: number | null;
     }>;
 }
 interface SqlPool {
     query<TRow extends Record<string, unknown> = Record<string, unknown>>(text: string, params?: readonly unknown[]): Promise<{
         rows: readonly TRow[];
-        rowCount: number;
+        rowCount?: number | null;
     }>;
     connect(): Promise<SqlClient & {
         readonly release: () => void;
@@ -3972,5 +4897,5 @@ declare class PostgresMemory implements Memory {
 }
 declare function createPostgresMemory(options: PostgresMemoryOptions): PostgresMemory;
 
-export { ADAPTER_DEFAULTS, AssemblyAiSttProvider, AsyncQueue, 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_MARKER, TVIC_ERROR_NAMES, TvicThrowableError, TwilioMediaStreamCallHandle, TwilioMediaStreamsProvider, 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, 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, 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, CallStatus, CancelledSession, CancelledTurn, CartesiaProviderConfig, CartesiaTtsProviderOptions, ChannelKind, ChannelLayout, 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, HealthCheckResult, HealthSnapshot, IdGenerator, IdempotencyPolicy, InMemoryDurableRuntimeStore, InMemoryDurableRuntimeStoreOptions, InMemoryMemoryOptions, InboundCallContext, InboundMediaEvent, IncrementalTextToSpeechProvider, InputAudioChunk, InputMediaEvent, InternalMediaEvent, InterruptRequestedEvent, InterruptionMode, InterruptionPolicy, JsonSchemaDocument, JsonValue, LLMProvider, 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, 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, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceEvent, 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 };