voice-runtime 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -226,6 +226,42 @@ 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 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.rate_limited";
+    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: {
@@ -247,6 +283,7 @@ declare const PROVIDER_NAMES: {
     readonly sarvam: "sarvam";
     readonly assemblyaiStt: "assemblyai-stt";
     readonly sonioxStt: "soniox-stt";
+    readonly groq: "groq-chat-completions";
     readonly openaiResponses: "openai-responses";
     readonly webClientAudio: "web-client-audio";
 };
@@ -259,6 +296,10 @@ declare const PROVIDER_ERROR_CODES: {
     readonly sarvamStt: "sarvam.stt.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";
@@ -270,17 +311,20 @@ declare const STT_ERROR_CODES: {
     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.rate_limited";
+    readonly serviceUnavailable: "provider.upstream_failed";
+    readonly providerInternal: "provider.upstream_failed";
+    readonly protocolError: "provider.protocol_invalid";
+    readonly sessionExpired: "provider.session_expired";
     readonly streamEnded: "stt.stream_ended";
+    readonly audioWriteTimeout: "stt.audio_write_timeout";
+    readonly 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 +818,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";
@@ -995,7 +994,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" | "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;
@@ -1193,18 +1192,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 +1503,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 +1718,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 +1763,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 +1837,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 +1847,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 +1896,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,6 +1964,7 @@ 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;
@@ -1899,6 +1975,7 @@ interface ProviderClock {
 
 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;
@@ -1911,7 +1988,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 +2005,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,8 +2046,8 @@ 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;
 
@@ -1986,6 +2069,7 @@ declare const WEB_CLIENT_AUDIO_DEFAULTS: {
 };
 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;
@@ -2410,11 +2494,49 @@ declare class OpenAiResponsesLlmProvider implements LLMProvider {
 }
 declare function createOpenAiResponsesLlmProvider(options: OpenAiResponsesLlmProviderOptions): OpenAiResponsesLlmProvider;
 
+interface GroqChatLlmProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
+    readonly allowUnknownModel?: boolean;
+    readonly clock?: ProviderClock;
+}
+declare class GroqChatLlmProvider implements LLMProvider {
+    #private;
+    readonly name: "groq-chat-completions";
+    readonly kind = "llm";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: false;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: true;
+            buffer: false;
+            truncation: false;
+        };
+        transports: ("http" | "sse")[];
+        models: readonly ["openai/gpt-oss-20b", "openai/gpt-oss-120b"];
+        tools: {
+            functionCalling: true;
+            parallelCalls: false;
+        };
+    };
+    constructor(options: GroqChatLlmProviderOptions);
+    complete(request: LlmCompletionRequest): Promise<LlmCompletion>;
+}
+declare function createGroqChatLlmProvider(options: GroqChatLlmProviderOptions): GroqChatLlmProvider;
+
 interface CartesiaTtsProviderOptions {
     readonly apiKey: string;
     readonly url?: string;
     readonly voiceId: string;
     readonly modelId?: string;
+    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
+    readonly allowUnknownModel?: boolean;
     readonly language?: string;
     readonly clock?: ProviderClock;
     readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
@@ -2488,6 +2610,7 @@ declare const PROVIDER_STABILITY: Readonly<{
     readonly elevenlabsStt: "experimental";
     readonly assemblyai: "experimental";
     readonly soniox: "experimental";
+    readonly groq: "experimental";
     readonly openaiResponses: "experimental";
     readonly cartesia: "experimental";
     readonly elevenlabs: "experimental";
@@ -2496,20 +2619,20 @@ 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 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 cartesia: {
-        readonly verifiedAt: "2026-07-24";
-        readonly source: "https://docs.cartesia.ai/api-reference/tts/tts";
+        readonly verifiedAt: "2026-09-15";
+        readonly source: "https://docs.cartesia.ai/build-with-cartesia/tts-models/older-models";
         readonly defaultModel: "sonic-3";
         readonly models: readonly ["sonic-3", "sonic-2"];
     };
@@ -2537,6 +2660,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";
@@ -2617,6 +2746,82 @@ declare class ElevenLabsTtsProvider implements IncrementalTextToSpeechProvider {
 }
 declare function createElevenLabsTtsProvider(options: ElevenLabsTtsProviderOptions): ElevenLabsTtsProvider;
 
+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;
+    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 +2855,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 +2912,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
@@ -2866,7 +3062,7 @@ declare class SessionRecoveryCoordinator {
     #private;
     constructor(options: SessionRecoveryCoordinatorOptions);
     start(): void;
-    stop(): void;
+    stop(): Promise<void>;
     pollOnce(): Promise<RecoveryPollResult>;
 }
 interface SessionReaperOptions {
@@ -2887,7 +3083,7 @@ declare class SessionReaper {
     #private;
     constructor(options: SessionReaperOptions);
     start(): void;
-    stop(): void;
+    stop(): Promise<void>;
     reapOnce(): Promise<number>;
 }
 
@@ -2932,7 +3128,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 +3167,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 +3206,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 +3260,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 +3299,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 +3326,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 +3372,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 +3383,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 +3427,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 +3472,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;
@@ -3272,6 +3522,8 @@ 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
@@ -3340,7 +3592,13 @@ 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;
@@ -3403,6 +3661,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 +3673,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 +3704,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 +3869,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 +4040,7 @@ interface RedisStoreOptions {
     readonly nowMs?: () => number;
     readonly maxTransactionRetries?: number;
     readonly closeClient?: boolean;
+    readonly onCompatibilityDiagnostic?: (diagnostic: PersistedErrorCompatibilityDiagnostic) => void;
 }
 
 declare class RedisSessionStore implements SessionStore {
@@ -3931,13 +4145,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 +4186,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, CartesiaTtsProvider, ConversationPolicy, CorruptRecordError, DEFAULT_DURABLE_RUNTIME_POLICY, DTMF_DIGITS, DeepgramSttProvider, DurableError, EVENT_KIND_MAP, ElevenLabsSttProvider, ElevenLabsTtsProvider, InMemoryMemory, InMemorySessionLeaseStore, InMemorySessionStore, InMemoryToolCallStore, InMemoryToolIdempotencyStore, InMemoryTurnStore, InvalidArgumentError, LeaseLostError, LeaseUnavailableError, MemoryBackendUnavailableError, MemoryEntryTooLargeError, MemorySessionQuotaExceededError, NodeMediaPlane, PCM16_16K_MONO, PCM16_8K_MONO, PROVIDER_API_VERSIONS, PROVIDER_CATALOG, PROVIDER_ERROR_CODES, PROVIDER_NAMES, PROVIDER_STABILITY, PipelineVoiceLoop, PipelineVoiceLoopBuilder, RUNTIME_SAMPLE_RATE_HZ, RecordConflictError, RecordNotFoundError, STT_ERROR_CODES, STT_STREAM_ENDED_REASON, SarvamSttProvider, SessionReaper, SessionRecoveryCoordinator, SonioxSttProvider, TELEPHONY_SAMPLE_RATE_HZ, TVIC_ERROR_CODES, TVIC_ERROR_CODE_ALIASES, TVIC_ERROR_MARKER, TVIC_ERROR_NAMES, TvicThrowableError, TwilioMediaStreamCallHandle, TwilioMediaStreamsProvider, VoiceRuntimeFinalizationError, WEB_CLIENT_AUDIO_CLOSE_CODES, WEB_CLIENT_AUDIO_DEFAULTS, WebClientAudioCallHandle, WebClientAudioProvider, assertMemoryCapability, assertMemoryPolicySupported, assertPcm16leFormat, authError, base64ToBytes, bytesToBase64, cancelledError, canonicalizeTwilioData, computeTwilioSignature, connectionError, counterIdGenerator, createAssemblyAiSttProvider, createAudioNormalizer, createCartesiaTtsProvider, createDeepgramSttProvider, createDefaultIdGenerator, createElevenLabsSttProvider, createElevenLabsTtsProvider, createGroqChatLlmProvider, createInMemoryDurableRuntimeStore, createInMemoryMemory, createInMemorySessionStore, createInMemoryToolCallStore, createInMemoryTurnStore, createMediaEvent, createNodeMediaPlane, createOpenAiResponsesLlmProvider, createPostgresDurableRuntimeStore, createPostgresMemory, createPostgresRedisDurableRuntimeStore, createRedisDurableRuntimeStore, createRuntime, createSarvamSttProvider, createSonioxSttProvider, createSttSession, createSystemClock, createToolRegistry, createTwilioMediaStreamsProvider, createVoiceAgent, createWebClientAudioProvider, defineAgent, defineTool, deliverAssistantText, durationMsForPcm16le, evaluateProviderCompatibility, executeTool, formatMemoryContextAsSystemBlock, formatPreCallContextAsSystemBlock, frameCountForPcm16le, getSttRecoveryControl, idempotencyKeyFor, idempotencyRequestHashFor, internalError, interruptedError, isDtmfDigit, isIncrementalTextToSpeechProvider, isInputMediaEvent, isNormalizedError, isOutputMediaEvent, isProviderKind, isReconstructableAudioFormat, isSampleRateHz, isTerminalSession, isTerminalTurn, isTranscriptSegmentEvent, isTvicError, isTvicErrorName, kindForMediaEvent, matchPath, mediaError, monotonicOffsetMs, mulawToPcm16le, normalizeLegacyError, normalizeUnknownError, normalizedError, nowTimestamp, pcm16leToMulaw, providerError, rateLimitError, requireProviderKind, resamplePcm16le, resolvePreCallContext, resolvePreCallMemory, runPostgresMemoryMigrations, runPostgresMigrations, sameAudioFormat, shouldDeliverText, signVoiceSessionToken, signatureError, splitPcm16leFrames, stableStringify, supportsAudioFormat, supportsLanguage, supportsModel, terminalSessionFromRequest, terminalSourceForRequest, terminalTurnFromRequest, timeoutError, toTimestamp, toolError, toolInputError, tvicErrorFromJSON, unknownErrorMessage, validateJsonSchemaSubset, validationError, verifyTwilioSignature, verifyVoiceSessionToken, withSttReconnect };
+export type { ActiveSession, ActiveTurn, Agent, AgentAudioPolicy, AgentContextPolicy, AgentId, AgentMemoryPolicy, AgentProviders, AnyMediaEventInit, AssemblyAiProviderConfig, AssemblyAiSttProviderOptions, AssistantTextRecord, AudioFormat, AudioNormalizationMode, AudioNormalizer, AudioNormalizerOptions, AudioPayload, BackoffStrategy, Brand, Call, CallControlCapability, CallDirection, CallHandle, CallId, CallSnapshot, CallStatus, CancelledSession, CancelledTurn, CartesiaProviderConfig, CartesiaTtsProviderOptions, ChannelKind, ChannelLayout, CleanupErrorSummary, CleanupStage, Clock, CompletedSession, CompletedTurn, ConnectedCall, ConnectionObservabilityEvent, ConversationPolicyOptions, CounterIdGenerator, CreateVoiceAgentOptions, CreatedCall, CreatedSession, DeepgramProviderConfig, DeepgramSttProviderOptions, DefineAgentInput, DefineToolInput, DtmfDigit, DtmfReceivedEvent, DualProtocolResult, DurableErrorCode, DurableOutboxEvent, DurableRuntimeMetric, DurableRuntimePolicy, DurableRuntimeStore, DurableSessionTransaction, ElevenLabsSttCommitStrategy, ElevenLabsSttProviderConfig, ElevenLabsSttProviderOptions, ElevenLabsTtsProviderConfig, ElevenLabsTtsProviderOptions, EndSessionReason, EndSessionRequest, EndTurnRequest, EndedCall, ErrorCategory, ExecuteToolInput, FailedCall, FailedSession, FailedToolCall, FailedToolCallStatus, FailedTurn, GroqChatLlmProviderOptions, GroqProviderConfig, HealthCheckResult, HealthSnapshot, IdGenerator, IdempotencyPolicy, InMemoryDurableRuntimeStore, InMemoryDurableRuntimeStoreOptions, InMemoryMemoryOptions, InboundCallContext, InboundMediaEvent, IncrementalTextToSpeechProvider, InputAudioChunk, InputMediaEvent, InternalMediaEvent, InterruptRequestedEvent, InterruptionMode, InterruptionPolicy, JsonSchemaDocument, JsonValue, LLMProvider, LiveTerminalSource, LlmCompletion, LlmCompletionRequest, LlmInlineToolCall, LlmMessage, LlmMessageRole, LlmProviderConfig, LlmStreamEvent, LlmUsage, MediaAudioChunkEvent, MediaAudioCommittedEvent, MediaDirection, MediaErrorEvent, MediaEvent, MediaEventId, MediaEventKind, MediaEventType, MediaStreamEndedEvent, MediaStreamStartedEvent, MediaTransport, MediaTransportKind, Memory, MemoryCapabilities, MemoryEntry, MemoryEntryId, MemoryKind, MemoryPutOptions, MemoryQuery, MemoryRef, MemoryScope, NodeMediaPlaneConnection, NodeMediaPlaneConnectionErrorHandler, NodeMediaPlaneConnectionHandler, NodeMediaPlaneOptions, NodeMediaPlaneRequestHandler, NormalizedAudioEncoding, NormalizedError, OpenAiProviderConfig, OpenAiResponsesLlmProviderOptions, OrganizationId, OutboundCallRequest, OutputAudioChunk, OutputMediaEvent, PersonaConfig, PipelineVoiceLoopOptions, PipelineVoiceLoopResult, PostgresDurableStoreOptions, PostgresMemoryOptions, PostgresMigration, PostgresRedisDurableStoreOptions, PreCallContext, PreCallContextResolver, PreCallMemoryContext, PreCallMemoryResolver, Provider, ProviderAudioCapabilities, ProviderCancellationCapabilities, ProviderCapabilities, ProviderCatalogEntry, ProviderCompatibility, ProviderCompatibilityIssue, ProviderCompatibilityIssueCode, ProviderDataPolicy, ProviderEventId, ProviderForKind, ProviderKind, ProviderPlayoutCapabilities, ProviderRequirements, ProviderStability, ProviderStreamingCapabilities, ProviderToolCapabilities, ProviderTransport, QueuedToolCall, RecoveryPollResult, RedisClient, RedisMulti, RedisScanOptions, RedisSetResult, RedisStoreOptions, RequiredProviderCapabilities, RetryPolicy, RingingCall, RunningToolCall, Runtime, RuntimeOptions, RuntimeProvider, RuntimeServiceLifecycle, SampleRateHz, SarvamOutputMode, SarvamProviderConfig, SarvamSttProviderOptions, SchemaValidationResult, Session, SessionAttachment, SessionAttachmentHealth, SessionCancellationReason, SessionEndEvent, SessionEndMemorySnapshot, SessionId, SessionLease, SessionLeaseStore, SessionMemoryFinalization, SessionMetricsRecorder, SessionReaperOptions, SessionRecoveryCoordinatorOptions, SessionRuntimeMetadata, SessionSnapshot, SessionState, SessionStatus, SessionStore, SonioxProviderConfig, SonioxStructuredContext, SonioxSttProviderOptions, SpeechToTextProvider, SqlClient$1 as SqlClient, SqlPool$1 as SqlPool, SqlResult, StartAttachedSessionOptions, StartSessionOptions, StartTurnRequest, StartingSession, StoredSessionRecord, StoredToolCallRecord, StoredTurnRecord, StreamEndReason, SttCommitMode, SttOpenRequest, SttProviderConfig, SttReconnectOptions, SttRecoveryControl, SttRecoveryState, SttSession, SttSessionInputOptions, SttSessionOptions, SttStream, SttTimestampOrigin, SucceededToolCall, TelephonyProvider, TelephonyProviderConfig, TerminalSession, TerminalSessionDraft, TerminalSessionStatus, TerminalSource, TerminalToolCall, TerminalTurn, TextDeliveryMode, TextToSpeechProvider, TimeoutAction, TimeoutPolicy, Timestamp, ToolCall, ToolCallId, ToolCallRuntimeMetadata, ToolCallStatus, ToolCallStore, ToolDefinition, ToolExecutionContext, ToolExecutor, ToolId, ToolIdempotencyClaim, ToolIdempotencyClaimResult, ToolIdempotencyLease, ToolIdempotencyOutcome, ToolIdempotencyRecord, ToolIdempotencyStatus, ToolIdempotencyStore, ToolLogger, ToolName, ToolRegistry, ToolTenant, TranscriptEndpointEvent, TranscriptEndpointReason, TranscriptEvent, TranscriptEventType, TranscriptSegmentEvent, TranscriptSegmentEventType, TranscriptSpeechStartedEvent, TransportAudioEncoding, TransportAudioFormat, TtsAlignmentEvent, TtsAlignmentUnit, TtsEvent, TtsFlushAcknowledgement, TtsFlushCompletedEvent, TtsFlushId, TtsFlushResult, TtsProviderConfig, TtsSession, TtsSessionOpenRequest, TtsStream, TtsSynthesisRequest, Turn, TurnCancellationReason, TurnCommitRequestedEvent, TurnDetectionMode, TurnId, TurnInput, TurnLatency, TurnLatencyRecord, TurnOutput, TurnRuntimeMetadata, TurnStatus, TurnStore, TvicErrorName, TwilioFlatParams, TwilioMediaStreamCallHandleOptions, TwilioMediaStreamSocket, TwilioParamValue, TwilioParams, UpgradeAuthorization, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceEvent, VoiceRuntimeFailureMetadata, WebClientAudioCallHandleOptions, WebClientAudioConnectionEvent, WebClientAudioProviderOptions, WebClientAudioSocket, WorkflowId };