voice-runtime 1.1.0 → 2.0.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';
 
@@ -49,14 +50,8 @@ declare function counterIdGenerator<TId extends string = string>(prefix: string)
 declare function createDefaultIdGenerator(): IdGenerator;
 
 type ErrorCategory = "validation" | "auth" | "provider" | "network" | "timeout" | "rate_limit" | "cancelled" | "interrupted" | "tool" | "media" | "internal";
-/**
- * Canonical error names used on `NormalizedError.name` and by `tvicErrorFromJSON`
- * to identify errors after JSON round-trips (the `Symbol.for('tvic.error')`
- * marker on `TvicThrowableError` is lost in JSON).
- *
- * Frozen at module load so third parties cannot mutate the registry at
- * runtime.
- */
+declare const MAX_ERROR_CODE_UTF8_BYTES = 128;
+declare function isValidErrorCode(code: unknown): code is string;
 declare const TVIC_ERROR_NAMES: Readonly<{
     readonly AuthError: "AuthError";
     readonly RateLimitError: "RateLimitError";
@@ -75,11 +70,6 @@ declare const TVIC_ERROR_NAMES: Readonly<{
 }>;
 type TvicErrorName = (typeof TVIC_ERROR_NAMES)[keyof typeof TVIC_ERROR_NAMES];
 declare function isTvicErrorName(value: unknown): value is TvicErrorName;
-/**
- * The cross-realm marker for TVIC errors. Lives on the `TvicThrowableError`
- * class instance, not on `NormalizedError`, because `JSON.stringify` strips
- * symbol-keyed properties. Use `tvicErrorFromJSON()` to re-hydrate.
- */
 declare const TVIC_ERROR_MARKER: unique symbol;
 interface NormalizedError {
     readonly name: TvicErrorName;
@@ -100,20 +90,14 @@ interface ErrorFactoryOptions {
 }
 declare function isNormalizedError(value: unknown): value is NormalizedError;
 declare function unknownErrorMessage(error: unknown): string;
-/**
- * Recognizes the pre-v2 normalized shape that did not carry `name`, then
- * upgrades it to the canonical name for its category. This is deliberately
- * separate from `isNormalizedError`: new callers must still be able to tell
- * whether a value is already current, while compatibility boundaries can
- * preserve old provider/runtime errors instead of reclassifying them.
- */
-declare function normalizeLegacyError(value: unknown): NormalizedError | null;
-declare function normalizeUnknownError(error: unknown, options: {
+type NormalizeUnknownErrorOptions = {
     readonly code: string;
     readonly category?: ErrorCategory;
     readonly provider?: string;
     readonly retriable?: boolean;
-}): NormalizedError;
+};
+declare function normalizeLegacyError(value: unknown): NormalizedError | null;
+declare function normalizeUnknownError(error: unknown, options: NormalizeUnknownErrorOptions): NormalizedError;
 declare function normalizedError(code: string, message: string, options?: ErrorFactoryOptions): NormalizedError;
 declare function providerError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category">): NormalizedError;
 declare function mediaError(code: string, message?: string, options?: Omit<ErrorFactoryOptions, "category">): NormalizedError;
@@ -127,17 +111,6 @@ declare function signatureError(code: string, message: string, options?: Omit<Er
 declare function cancelledError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category" | "retriable">): NormalizedError;
 declare function interruptedError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category" | "retriable">): NormalizedError;
 declare function toolError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category">): NormalizedError;
-/**
- * A throwable Error that carries a `NormalizedError` and the cross-realm
- * `Symbol.for('tvic.error')` marker. Use `TvicThrowableError.from(value)`
- * to construct — it normalizes unknown values, preserves the original cause,
- * and reuses already-thrown `TvicThrowableError` instances.
- *
- * Note: the marker is lost in `JSON.stringify` because symbol-keyed
- * properties are dropped. Use `tvicErrorFromJSON()` to re-hydrate.
- * Error-like values from another realm in the same JavaScript agent are
- * recognized by their intrinsic Error tag, not only by `instanceof`.
- */
 declare class TvicThrowableError extends Error {
     readonly [TVIC_ERROR_MARKER]: true;
     readonly error: NormalizedError;
@@ -152,32 +125,9 @@ declare class TvicThrowableError extends Error {
     static from(value: unknown): TvicThrowableError;
     toJSON(): NormalizedError;
 }
-/**
- * Type guard that detects a `TvicThrowableError` instance *or* any object
- * that carries the cross-realm `Symbol.for('tvic.error')` marker. Works
- * across Web Workers, iframes, and `vm` contexts because `Symbol.for` is
- * the only symbol-sharing primitive within the same JavaScript agent. Separate
- * workers require JSON serialization or another explicit transport.
- *
- * The marker is an *identity tag*, not a security boundary: a hostile party
- * who can write into your realm can also fake the marker. The structural
- * companion to this guard is `isNormalizedError`, which checks the actual
- * `NormalizedError` field shape.
- *
- * Does NOT work across `JSON.parse` boundaries — use `tvicErrorFromJSON()`.
- */
+declare function jsonSerializableNormalizedError(error: NormalizedError, transformString?: (value: string) => string): NormalizedError;
 declare function isTvicError(value: unknown): value is NormalizedError | TvicThrowableError;
-/**
- * Re-hydrate a `NormalizedError` after a `JSON.parse` round-trip. The
- * `Symbol.for('tvic.error')` marker is lost in JSON, so `isTvicError()`
- * returns `false` for parsed values. This factory validates the parsed
- * structural payload, including its canonical name/category pairing and
- * required field types.
- *
- * Returns `null` if the value cannot be re-hydrated to a valid
- * `NormalizedError` (unknown name, empty message, wrong field types).
- * Callers should always null-check the return value.
- */
+declare function normalizedErrorFromTvicError(value: unknown): NormalizedError | null;
 declare function tvicErrorFromJSON(value: unknown): NormalizedError | null;
 
 type DurableErrorCode = "RECORD_NOT_FOUND" | "RECORD_CONFLICT" | "LEASE_UNAVAILABLE" | "LEASE_LOST" | "BACKEND_UNAVAILABLE" | "CORRUPT_RECORD" | "INVALID_ARGUMENT" | "MEMORY_BACKEND_UNAVAILABLE" | "MEMORY_ENTRY_TOO_LARGE" | "MEMORY_SESSION_QUOTA_EXCEEDED";
@@ -230,6 +180,9 @@ declare class MemorySessionQuotaExceededError extends DurableError {
 declare const TVIC_ERROR_CODES: Readonly<{
     readonly providerAuthFailed: "provider.auth_failed";
     readonly providerRateLimited: "provider.rate_limited";
+    readonly providerQuotaExceeded: "provider.quota_exceeded";
+    readonly providerTransportWriteFailed: "provider.transport_write_failed";
+    readonly providerTransportTimeout: "provider.transport_timeout";
     readonly providerModelUnsupported: "provider.model_unsupported";
     readonly providerVoiceUnsupported: "provider.voice_unsupported";
     readonly providerInputRejected: "provider.input_rejected";
@@ -247,11 +200,14 @@ declare const TVIC_ERROR_CODES: Readonly<{
     readonly ttsTransportUnexpectedEof: "tts.transport.unexpected_eof";
     readonly llmProviderUnexpectedEof: "llm.provider.unexpected_eof";
 }>;
-/** One-release aliases accepted at provider and persisted-data boundaries. */
+/** Legacy 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.quota_exceeded": "provider.quota_exceeded";
+    readonly "stt.transport.write_failed": "provider.transport_write_failed";
+    readonly "stt.send_timeout": "provider.transport_timeout";
+    readonly "stt.audio_write_timeout": "provider.transport_timeout";
     readonly "stt.provider.invalid_request": "provider.invalid_request";
     readonly "stt.provider.input_rejected": "provider.input_rejected";
     readonly "stt.provider.session_expired": "provider.session_expired";
@@ -278,9 +234,11 @@ declare const PROVIDER_NAMES: {
     readonly twilio: "twilio-media-streams";
     readonly deepgram: "deepgram";
     readonly cartesia: "cartesia";
+    readonly cartesiaStt: "cartesia-stt";
     readonly elevenlabs: "elevenlabs";
     readonly elevenlabsStt: "elevenlabs-stt-realtime";
     readonly sarvam: "sarvam";
+    readonly sarvamTts: "sarvam-tts";
     readonly assemblyaiStt: "assemblyai-stt";
     readonly sonioxStt: "soniox-stt";
     readonly groq: "groq-chat-completions";
@@ -294,6 +252,7 @@ declare const PROVIDER_ERROR_CODES: {
     readonly elevenlabsTts: "elevenlabs.tts.error";
     readonly elevenlabsStt: "elevenlabs.stt.error";
     readonly sarvamStt: "sarvam.stt.error";
+    readonly sarvamTts: "sarvam.tts.error";
     readonly assemblyaiStt: "assemblyai.stt.error";
     readonly sonioxStt: "soniox.stt.error";
     readonly groqChat: "groq.chat.error";
@@ -304,10 +263,12 @@ declare const PROVIDER_ERROR_CODES: {
     readonly openaiHttp: "openai.http_error";
     readonly openaiResponseFailed: "openai.response.failed";
     readonly webClientAudio: "web_client_audio.error";
+    readonly cartesiaStt: "cartesia.stt.error";
 };
 /** Stable runtime taxonomy consumed by reconnect and call-failure policy. */
 declare const STT_ERROR_CODES: {
-    readonly transportWriteFailed: "stt.transport.write_failed";
+    readonly transportWriteFailed: "provider.transport_write_failed";
+    readonly transportTimeout: "provider.transport_timeout";
     readonly unexpectedEof: "stt.transport.unexpected_eof";
     readonly connectFailed: "stt.transport.connect_failed";
     readonly connectTimeout: "stt.transport.connect_timeout";
@@ -315,13 +276,13 @@ declare const STT_ERROR_CODES: {
     readonly invalidRequest: "provider.invalid_request";
     readonly inputRejected: "provider.input_rejected";
     readonly rateLimited: "provider.rate_limited";
-    readonly quotaExceeded: "provider.rate_limited";
+    readonly quotaExceeded: "provider.quota_exceeded";
     readonly serviceUnavailable: "provider.upstream_failed";
     readonly providerInternal: "provider.upstream_failed";
     readonly protocolError: "provider.protocol_invalid";
     readonly sessionExpired: "provider.session_expired";
     readonly streamEnded: "stt.stream_ended";
-    readonly audioWriteTimeout: "stt.audio_write_timeout";
+    readonly audioWriteTimeout: "provider.transport_timeout";
     readonly closeTimeout: "stt.close_timeout";
     readonly bufferOverflow: "stt.reconnect.buffer_overflow";
     readonly sessionBufferOverflow: "stt.session_buffer_overflow";
@@ -331,11 +292,6 @@ declare const STT_ERROR_CODES: {
 
 type MediaDirection = "input" | "output" | "internal";
 type CallDirection = "inbound" | "outbound";
-/**
- * Channels TVIC 1.0 can actually execute. `sip` and `whatsapp` are intentionally
- * absent until a working transport exists — the union never claims a capability
- * the runtime cannot run.
- */
 type ChannelKind = "phone" | "web_audio" | "simulated";
 
 /**
@@ -398,6 +354,7 @@ interface IdempotencyPolicy {
     readonly enabled: boolean;
     readonly keyTemplate?: string;
     readonly ttlMs?: number;
+    readonly legacyKeyCompatibility?: boolean;
 }
 
 type MediaEventType = "media.stream.started" | "media.stream.ended" | "media.audio.chunk" | "media.audio.committed" | "media.turn.commit_requested" | "media.interrupt.requested" | "dtmf.received" | "media.error";
@@ -496,11 +453,6 @@ type MediaEvent = InputMediaEvent | OutputMediaEvent | InternalMediaEvent;
  */
 type WithoutMediaEventKind<T> = T extends MediaEvent ? Omit<T, "kind"> : never;
 type AnyMediaEventInit = WithoutMediaEventKind<MediaEvent>;
-/**
- * Adds the required coarse-grained category to a media event. The overload
- * keeps the correlated event type available to callers; the implementation
- * itself returns the complete `MediaEvent` union and contains no assertion.
- */
 declare function createMediaEvent<T extends AnyMediaEventInit>(init: T): Extract<MediaEvent, {
     readonly type: T["type"];
     readonly direction: T["direction"];
@@ -509,24 +461,17 @@ type InputAudioChunk = MediaAudioChunkEvent<"input">;
 type OutputAudioChunk = MediaAudioChunkEvent<"output">;
 
 type JsonSchemaDocument = Readonly<Record<string, unknown>>;
-/**
- * Optional tenant identity propagated into every tool execution. The runtime
- * populates this from the session attachment's `memoryUserId` /
- * `organizationId` / `workflowId`. The tool author reads `tenant.userId`
- * inside `execute` to enforce their own auth — TVIC ships no RBAC layer
- * (that is a tenant concern: the customer has an IdP).
- */
 interface ToolTenant {
     readonly userId?: UserId;
     readonly organizationId?: OrganizationId;
     readonly workflowId?: WorkflowId;
-    /** Tenant-supplied scopes (e.g., "crm.read", "billing.write"). */
     readonly scopes?: readonly string[];
 }
 interface ToolExecutionContext {
     readonly sessionId: SessionId;
     readonly turnId: TurnId;
     readonly toolCallId: ToolCallId;
+    readonly idempotencyKey?: string;
     readonly attempt: number;
     readonly signal: AbortSignal;
     readonly logger: ToolLogger;
@@ -550,11 +495,8 @@ interface ToolDefinition<TInput = unknown, TOutput = unknown> {
     readonly retry: RetryPolicy;
     readonly idempotency: IdempotencyPolicy;
     /**
-     * @deprecated Use `ctx.tenant` (the `ToolTenant` field on
-     * `ToolExecutionContext`). The `authScope` field is kept as a no-op
-     * typedef for one release; the runtime never enforced it. Migration:
-     * read `ctx.tenant?.scopes` inside `execute` and enforce your own
-     * auth.
+     * @deprecated This field is a no-op. Enforce authorization in `execute`
+     * using `ctx.tenant?.scopes`.
      */
     readonly authScope?: readonly string[];
     readonly tags?: readonly string[];
@@ -572,18 +514,20 @@ interface ToolIdempotencyRecord {
     readonly status: ToolIdempotencyStatus;
     readonly owner?: string;
     readonly claimedFence?: number;
+    readonly claimedGenerationId?: string;
     readonly expiresAtMs: number;
     readonly output?: unknown;
     readonly error?: NormalizedError;
 }
-/** Ownership context used to fence durable idempotency claims to a session. */
 interface ToolIdempotencyLease {
     readonly sessionId: SessionId;
     readonly holder: string;
     readonly fence: number;
+    readonly generationId: string;
 }
 interface ToolIdempotencyClaim {
     readonly key: string;
+    readonly sessionId?: SessionId;
     readonly lease?: ToolIdempotencyLease;
     readonly toolId?: ToolId;
     readonly toolVersion?: string;
@@ -597,25 +541,71 @@ type ToolIdempotencyClaimResult = {
 } | {
     readonly status: "succeeded";
     readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "terminal";
+    readonly record: ToolIdempotencyRecord;
 } | {
     readonly status: "in_progress";
     readonly record: ToolIdempotencyRecord;
 } | {
     readonly status: "conflict";
+};
+type ToolIdempotencyLookupResult = {
+    readonly status: "found";
     readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "conflict";
+} | {
+    readonly status: "missing";
 };
 interface ToolIdempotencyOutcome {
     readonly status: Exclude<ToolIdempotencyStatus, "claimed">;
     readonly ttlMs: number;
     readonly owner: string;
+    readonly sessionId?: SessionId;
     readonly lease?: ToolIdempotencyLease;
     readonly output?: unknown;
     readonly error?: NormalizedError;
 }
+interface ToolIdempotencyRelease {
+    readonly key: string;
+    readonly requestHash: string;
+    readonly owner: string;
+    readonly sessionId?: SessionId;
+    readonly lease?: ToolIdempotencyLease;
+}
+interface ToolIdempotencyQuarantine {
+    readonly key: string;
+    readonly sessionId: SessionId;
+    readonly lease: ToolIdempotencyLease;
+    readonly toolId: ToolId;
+    readonly toolVersion: string;
+    readonly requestHash: string;
+    readonly owner: string;
+    readonly ttlMs: number;
+    readonly error: NormalizedError;
+}
+type ToolIdempotencyQuarantineResult = {
+    readonly status: "quarantined";
+    readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "succeeded";
+    readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "terminal";
+    readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "in_progress";
+    readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "conflict";
+};
 interface ToolIdempotencyStore {
-    lookup(key: string, requestHash: string): Promise<ToolIdempotencyRecord | null>;
+    lookup(key: string, requestHash: string, sessionId?: SessionId, lease?: ToolIdempotencyLease): Promise<ToolIdempotencyLookupResult>;
     claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
+    releaseClaim(input: ToolIdempotencyRelease): Promise<boolean>;
     complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
+    quarantine(input: ToolIdempotencyQuarantine): Promise<ToolIdempotencyQuarantineResult>;
 }
 interface ToolCallBase {
     readonly toolCallId: ToolCallId;
@@ -725,8 +715,8 @@ interface MemoryQuery {
     readonly tags?: readonly string[];
     readonly limit?: number;
     /**
-     * v0.1 continuation token. Adapters must interpret this as a non-negative
-     * decimal offset; opaque provider-specific cursors are not portable yet.
+     * Opaque continuation token. Built-in adapters use a non-negative decimal
+     * offset; callers must treat this value as opaque.
      */
     readonly cursor?: string;
 }
@@ -764,15 +754,7 @@ interface Memory {
     put<T = unknown>(ref: MemoryRef, key: string, kind: MemoryKind, value: T, options?: MemoryPutOptions): Promise<MemoryEntry<T>>;
     list<T = unknown>(ref: MemoryRef, query?: MemoryQuery): Promise<readonly MemoryEntry<T>[]>;
     delete(ref: MemoryRef, key: string, kind?: MemoryKind): Promise<boolean>;
-    /** Delete every entry under the given `MemoryRef`. Returns the count deleted. */
     deleteAll(ref: MemoryRef): Promise<number>;
-    /**
-     * Delete user-owned data only: the user's `user` scope and session entries
-     * explicitly attributed to that user by a trusted runtime write. Shared
-     * organization/workflow scopes are never part of this cascade. This is a
-     * destructive, privileged erasure primitive; the adapter does not authorize
-     * the caller or prove that the supplied user id belongs to the requester.
-     */
     deleteForUser(userId: UserId): Promise<number>;
 }
 
@@ -837,34 +819,22 @@ interface TurnOutput {
     readonly text?: string;
     readonly mediaEventIds: readonly MediaEventId[];
     readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly delivery?: TurnOutputDelivery;
+}
+type AudioOutputDeliveryStatus = "not_attempted" | "not_accepted" | "partially_accepted" | "transport_accepted" | "playout_confirmed" | "playout_unconfirmed";
+type TextOutputDeliveryStatus = "not_attempted" | "not_accepted" | "transport_accepted";
+interface TurnOutputDelivery {
+    readonly audio: AudioOutputDeliveryStatus;
+    readonly text: TextOutputDeliveryStatus;
 }
-/**
- * Turn timing on the session's monotonic clock.
- *
- * Every stage measurement is anchored at the endpoint commit, the moment the runtime
- * decided the participant had finished speaking, rather than at internal turn setup.
- * That anchor is what a caller actually experiences as the start of waiting.
- *
- * `endpointMs` is measured before that anchor and is therefore additive: perceived
- * caller-to-audio delay is `endpointMs + firstAudioMs`. It is usually the largest
- * single contributor, so a report that omits it understates the wait.
- */
 interface TurnLatency {
-    /** Participant speech start to endpoint commit. Requires a speech-start signal. */
     readonly listenedMs?: number;
-    /** Last immutable final segment to endpoint commit, the endpoint wait itself. */
     readonly endpointMs?: number;
-    /** Endpoint commit to the first model token. */
     readonly firstTokenMs?: number;
-    /** Endpoint commit to the first audio frame accepted by the transport. */
     readonly firstAudioMs?: number;
-    /** Total time spent in tool execution during the turn. */
     readonly toolMs?: number;
-    /** Interruption decision to queued output being stopped. */
     readonly interruptionTailMs?: number;
-    /** Endpoint commit to terminal turn state. */
     readonly totalMs?: number;
-    /** Time without an owner during runtime reattachment; excluded from stage timings. */
     readonly recoveryGapMs?: number;
 }
 interface TurnBase {
@@ -912,6 +882,12 @@ interface ProviderStreamingCapabilities {
     /** Streaming is supported by the provider protocol, not emulated by chunked requests. */
     readonly native: boolean;
 }
+interface ProviderBatchCapabilities {
+    /** Accepts one complete input payload instead of requiring a live stream. */
+    readonly input: boolean;
+    /** Returns one complete output payload instead of incremental events. */
+    readonly output: boolean;
+}
 interface ProviderCancellationCapabilities {
     /** Active provider work can be stopped rather than merely ignored by TVIC. */
     readonly request: boolean;
@@ -946,12 +922,16 @@ 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[];
+    /** Whether an incremental TTS adapter can honor timestamp/alignment requests. */
+    readonly timestamps?: boolean;
     readonly turnDetection?: readonly TurnDetectionMode[];
     readonly tools?: ProviderToolCapabilities;
     readonly playout?: ProviderPlayoutCapabilities;
@@ -965,6 +945,14 @@ interface Provider {
     readonly kind: ProviderKind;
     readonly version: string;
     readonly capabilities: ProviderCapabilities;
+    readonly configuredModel?: string;
+    /** Skip local model-catalog validation; this does not imply vendor support. */
+    readonly allowUnknownModel?: boolean;
+    readonly configuredVoice?: string | undefined;
+    readonly configuredLanguage?: string | undefined;
+    readonly languageWasExplicitlyConfigured?: boolean;
+    readonly supportsLanguage?: (language: string, model?: string) => boolean;
+    readonly supportsVoice?: (voice: string, model?: string) => boolean;
     readonly region?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
@@ -979,12 +967,14 @@ type RequiredProviderCapabilities<T extends object> = {
 interface ProviderRequirements {
     readonly kind: ProviderKind;
     readonly streaming?: RequiredProviderCapabilities<ProviderStreamingCapabilities>;
+    readonly batch?: RequiredProviderCapabilities<ProviderBatchCapabilities>;
     readonly cancellation?: RequiredProviderCapabilities<ProviderCancellationCapabilities>;
     readonly transport?: ProviderTransport;
     readonly inputFormat?: AudioFormat;
     readonly outputFormat?: AudioFormat;
     readonly language?: string;
     readonly model?: string;
+    readonly batchModel?: string;
     readonly voice?: string;
     readonly turnDetection?: TurnDetectionMode;
     readonly functionCalling?: boolean;
@@ -994,7 +984,7 @@ interface ProviderRequirements {
     readonly region?: string;
     readonly dataPolicy?: ProviderDataPolicy;
 }
-type ProviderCompatibilityIssueCode = "kind.unsupported" | "streaming.unsupported" | "cancellation.unsupported" | "transport.unsupported" | "audio.input_unsupported" | "audio.output_unsupported" | "language.unsupported" | "provider.model_unsupported" | "provider.voice_unsupported" | "turn_detection.unsupported" | "tools.unsupported" | "playout.unsupported" | "call_control.unsupported" | "region.unsupported" | "data_policy.unsupported";
+type ProviderCompatibilityIssueCode = "kind.unsupported" | "streaming.unsupported" | "batch.unsupported" | "cancellation.unsupported" | "transport.unsupported" | "audio.input_unsupported" | "audio.output_unsupported" | "language.unsupported" | "provider.model_unsupported" | "provider.voice_unsupported" | "turn_detection.unsupported" | "tools.unsupported" | "playout.unsupported" | "call_control.unsupported" | "region.unsupported" | "data_policy.unsupported";
 interface ProviderCompatibilityIssue {
     readonly code: ProviderCompatibilityIssueCode;
     readonly requirement: string;
@@ -1024,22 +1014,12 @@ type InboundMediaEvent = InputMediaEvent | InternalMediaEvent;
 interface CallHandle {
     readonly callId: CallId;
     readonly events: AsyncIterable<InboundMediaEvent>;
-    /**
-     * Sends an outbound frame. Returns `true` if it reached the transport, `false`
-     * if the socket was closed/closing and the frame was dropped, so the caller can
-     * tell "delivered" from "silently swallowed" instead of assuming success.
-     */
+    readonly remoteHangup?: Promise<void>;
     send(event: OutputMediaEvent): Promise<boolean>;
-    /** Delivers whole-turn assistant text to transports with a text channel. */
     deliverText?(turnId: TurnId, sequence: number, text: string): Promise<boolean>;
     clear(): Promise<void>;
+    endInput?(reason: StreamEndReason): Promise<void>;
     close(reason: StreamEndReason): Promise<void>;
-    /**
-     * Resolves once the transport confirms the marked output was actually played out
-     * to the caller (e.g. a Twilio mark ack): `true` if heard, `false` if the call
-     * dropped before playout. Optional: providers that can't observe playout omit it,
-     * and callers then fall back to "reached transport" as their delivery signal.
-     */
     confirmPlayout?(markId: string, timeoutMs: number): Promise<boolean>;
 }
 interface TelephonyProvider extends Provider {
@@ -1102,6 +1082,37 @@ interface SttOpenRequest {
     readonly metadata?: Readonly<Record<string, unknown>>;
     readonly signal?: AbortSignal;
 }
+type SttBatchTimestampGranularity = "word";
+/** A complete audio payload for a non-streaming transcription request. */
+interface SttBatchTranscriptionRequest {
+    /** Container bytes, or raw bytes when `format` is supplied. */
+    readonly audio: Uint8Array;
+    /** Optional filename used as the multipart upload filename and format hint. */
+    readonly fileName?: string;
+    /** Optional MIME type for the multipart file part. */
+    readonly mimeType?: string;
+    /** Raw PCM format. Omit this when `audio` contains a self-describing container. */
+    readonly format?: AudioFormat;
+    readonly language?: string;
+    readonly model?: string;
+    readonly timestampGranularities?: readonly SttBatchTimestampGranularity[];
+    readonly allowUnknownModel?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface SttBatchWord {
+    readonly word: string;
+    readonly startMs: number;
+    readonly endMs: number;
+}
+/** A complete transcript returned by a batch STT provider. */
+interface SttBatchTranscription {
+    readonly text: string;
+    readonly requestId?: string;
+    readonly language?: string;
+    readonly durationMs?: number;
+    readonly words?: readonly SttBatchWord[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
 type SttCommitMode = "provider" | "none";
 /**
  * Origin of audio offsets emitted by an STT stream. Reconnectable streams must
@@ -1121,6 +1132,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 {
@@ -1177,9 +1190,7 @@ interface TtsStream {
 /** A single prosody-preserving synthesis context receiving incremental text. */
 interface TtsSession extends TtsStream {
     sendText(text: string): Promise<void>;
-    /** Resolves once the provider or transport accepts a synthesis boundary. */
     flush(): Promise<TtsFlushResult>;
-    /** Ends input; events continue until the provider emits its completion event. */
     finish(): Promise<void>;
 }
 interface TextToSpeechProvider extends Provider {
@@ -1272,14 +1283,8 @@ interface AgentMemoryPolicy {
     readonly maxBytesPerSession?: number;
     readonly readOnly?: boolean;
     /**
-     * If true (default), session-scoped memory is purged on session end. This
-     * is Vapi's Zero Data Retention posture: the call's ephemeral transcripts
-     * do not outlive the call. User-scoped, organization-scoped, and
-     * workflow-scoped memory are *not* affected — they persist across sessions.
-     *
-     * Pre-1.0, this field was named `deleteOnEnd`. That name was misleading:
-     * it sounded like it deleted *all* memory, but the implementation only
-     * purges the `session` scope. The rename is the contract-clarity fix.
+     * If true (default), only session-scoped memory is purged on session end.
+     * User, organization, and workflow memory remain available across sessions.
      */
     readonly deleteSessionScopeOnEnd?: boolean;
     /**
@@ -1369,27 +1374,42 @@ interface Agent {
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
 
+declare const MAX_RECOVERY_PAGE_SIZE = 1000;
+declare const MAX_SAFE_LEASE_TIMESTAMP: number;
+declare function assertLeaseTtlMs(ttlMs: number): void;
+declare function assertLeaseFence(fence: number): void;
+declare function assertLeaseTimestampMs(timestampMs: number): void;
+declare function safeLeaseExpiryAt(nowMs: number, ttlMs: number): number;
+declare function assertRecoveryPageSize(limit: number): void;
 interface SessionLease {
     readonly sessionId: SessionId;
     readonly holder: string;
     readonly fence: number;
+    readonly generationId: string;
     readonly acquiredAtMs: number;
     readonly renewedAtMs: number;
     readonly expiresAtMs: number;
 }
+interface SessionRecoveryCandidate {
+    readonly sessionId: SessionId;
+    readonly fence: number;
+    readonly generationId: string;
+}
 interface SessionLeaseStore {
     acquire(sessionId: SessionId, holder: string, ttlMs: number): Promise<SessionLease | null>;
-    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number): Promise<SessionLease | null>;
-    release(sessionId: SessionId, holder: string, fence: number): Promise<void>;
+    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number, generationId: string): Promise<SessionLease | null>;
+    release(sessionId: SessionId, holder: string, fence: number, generationId: string): Promise<void>;
     get(sessionId: SessionId): Promise<SessionLease | null>;
     listRecoveryCandidates(options: {
         readonly nowMs: number;
         readonly limit: number;
         readonly cursor?: string;
     }): Promise<{
-        readonly sessionIds: readonly SessionId[];
+        readonly candidates: readonly SessionRecoveryCandidate[];
+        readonly corruptLeaseSessionIds?: readonly SessionId[];
         readonly nextCursor?: string;
     }>;
+    acknowledgeRecoveryCandidate(candidate: SessionRecoveryCandidate): Promise<void>;
     close(): Promise<void>;
 }
 interface DurableOutboxEvent {
@@ -1397,6 +1417,7 @@ interface DurableOutboxEvent {
     readonly aggregateType: "session" | "turn" | "tool_call";
     readonly aggregateId: string;
     readonly sessionId: SessionId;
+    readonly sessionIncarnation?: number;
     readonly version: number;
     readonly fence: number;
     readonly envelope: Readonly<Record<string, unknown>>;
@@ -1417,7 +1438,6 @@ interface ToolCallRuntimeMetadata {
 interface StoredSessionRecord {
     readonly session: Session;
     readonly runtime: SessionRuntimeMetadata;
-    /** Persistence-local aggregate version used for outbox ordering/fencing. */
     readonly version?: number;
 }
 interface StoredTurnRecord {
@@ -1471,28 +1491,9 @@ interface DurableRuntimeStore {
     readonly toolCalls: ToolCallStore;
     readonly leases: SessionLeaseStore;
     readonly toolIdempotencyStore?: ToolIdempotencyStore;
-    /**
-     * Closes adapter-owned resources and background workers. When present,
-     * Runtime.stop() delegates the complete durable-store shutdown to this
-     * method instead of closing the aggregate stores independently. Adapters
-     * that do not own background resources may omit it and retain the legacy
-     * component-close behavior.
-     */
     close?(): Promise<void>;
-    /**
-     * Atomically creates a session and acquires its first owner lease when the
-     * backend supports that transaction boundary. Runtimes use the fallback
-     * start-then-attach path only for adapters that do not implement it.
-     */
     createSessionWithLease?(record: StoredSessionRecord, holder: string, ttlMs: number, initialEvent?: (lease: SessionLease) => DurableOutboxEvent): Promise<SessionLease | null>;
-    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
-    /**
-     * Serialized compatibility boundary for callers that intentionally operate
-     * without a live attachment. A store may provide rollback internally, but
-     * the legacy CRUD interfaces cannot guarantee atomic rollback for arbitrary
-     * custom stores. There is no ownership or fencing guarantee; realtime
-     * attached paths must use runSessionTransaction.
-     */
+    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence" | "generationId">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
     runUnfencedSessionTransaction?<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
 }
 
@@ -1503,140 +1504,41 @@ 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;
     readonly holderId?: string;
     readonly onDurableMetric?: (metric: DurableRuntimeMetric) => void;
-    /**
-     * Memory adapter used for cross-call memory. Defaults to `InMemoryMemory`
-     * (process-local) when omitted. For cross-call recall, wire a durable
-     * adapter (e.g., `@tvic/dal-postgres-memory`) or a third-party adapter
-     * (Mem0, Supermemory, etc.).
-     */
     readonly memory?: Memory;
-    /**
-     * Maximum time the runtime waits for already-admitted memory writes and the
-     * session-scope purge during terminalization. Timing out releases the
-     * caller while preserving write-before-purge ordering. The default is 1
-     * second; the adapter operation is not cancelled.
-     */
     readonly sessionMemoryFinalizeTimeoutMs?: number;
-    /**
-     * Maximum time the runtime waits for the best-effort `onSessionEnd` observer
-     * after the terminal event has been assembled. The default is 5 seconds;
-     * the observer is not cancelled when this budget expires.
-     */
     readonly sessionEndHookTimeoutMs?: number;
-    /**
-     * Pre-call context resolver. When a session is created or attached, the
-     * runtime calls this hook when a session is attached to populate the agent's
-     * context with memory entries for the relevant scopes AND with non-memory
-     * context (CRM, feature flags, tenant config). If omitted, the runtime uses a default
-     * resolver that reads from `options.memory` for the active `user` /
-     * `organization` / `workflow` scopes and returns an empty `static` map.
-     *
-     * Pre-1.0, this was named `preCallMemoryResolver` and returned a
-     * `PreCallMemoryContext`. The rename to `PreCallContextResolver` and
-     * the addition of the `static: ReadonlyMap<string, string>` sub-map
-     * fixes a real type lie: the customer previously had to stuff CRM
-     * data and feature flags into the `Memory` map as `kind: "fact"`
-     * entries. The `static` map is the typed input for non-memory context.
-     */
     readonly preCallContextResolver?: PreCallContextResolver;
-    /** Optional org/workflow ids carried on every session created by this runtime. */
     readonly defaultOrganizationId?: OrganizationId;
     readonly defaultWorkflowId?: WorkflowId;
-    /**
-     * Optional callback fired after a session is terminalized and after the
-     * runtime has made its best-effort memory-finalization attempt. The event
-     * reports whether session-scope deletion was skipped, completed, failed, or
-     * timed out. Best-effort: a throw or timeout from the hook does not affect
-     * the terminal session. The runtime does not retry; if you need durability,
-     * call an external system from inside the hook and have that system retry.
-     *
-     * The hook is the canonical place for: post-call LLM summarization,
-     * CRM sync, callback scheduling, escalation, transcript delivery to a
-     * CRM. The runtime does not own any of these — the user picks the LLM,
-     * the prompt, the schema.
-     */
     readonly onSessionEnd?: (event: SessionEndEvent) => void | Promise<void>;
-    /**
-     * Optional metrics recorder. The runtime emits one `record` call per
-     * observable event (session start, turn end, session end) and one
-     * `onTurn` call per terminal turn. The user provides the implementation
-     * (Earshot-shaped, console.log-shaped, OTel-shaped).
-     */
     readonly sessionMetricsRecorder?: SessionMetricsRecorder;
-    /**
-     * Optional health check consumed by `NodeMediaPlane.healthPath`. The
-     * user implements the readiness check (DB ping, recovery-coordinator
-     * liveness); the runtime reflects it on the HTTP endpoint. Returns
-     * `ok: true` when all checks pass; the runtime responds with HTTP 200.
-     */
     readonly healthCheck?: () => Promise<HealthSnapshot>;
-    /**
-     * Optional callback fired at the start of `runtime.stop()` so the
-     * user's deployment wiring (SIGTERM handler, kubernetes preStop hook)
-     * can drain the load balancer before the runtime detaches sessions
-     * and closes stores. Best-effort; the runtime proceeds after the
-     * promise settles or 5s, whichever comes first.
-     */
     readonly onShutdownStart?: (state: {
         readonly activeSessions: readonly SessionId[];
     }) => void | Promise<void>;
-    /**
-     * Optional async provider of the pre-call static context (CRM records,
-     * feature flags, tenant config). Called by the runtime when a session is
-     * attached; the result is merged into the pre-call context's `static`
-     * map. Best-effort: a throw or timeout produces a degraded `static`
-     * context (degraded flag set). This is a separate seam from
-     * `preCallContextResolver` so a custom resolver can choose to either
-     * (a) inline the static fetch into its own resolver, or (b) leave the
-     * fetch to the runtime and just augment the result.
-     */
     readonly preCallStaticProvider?: () => Promise<ReadonlyMap<string, string>>;
 }
-/**
- * Resolves the pre-call context for a session. The runtime calls this on
- * `startAttachedSession` and `attachSession` after lease acquisition.
- *
- * Pre-1.0, this was named `PreCallMemoryResolver` and returned a
- * `PreCallMemoryContext`. The rename to `PreCallContextResolver` and
- * the addition of the `static` sub-map fixes the type lie.
- */
 type PreCallContextResolver = (input: {
     readonly userId?: UserId;
     readonly organizationId?: OrganizationId;
     readonly workflowId?: WorkflowId;
     readonly sessionId: SessionId;
     readonly memory: Memory;
-    /** Wall-clock source supplied by the runtime for deterministic resolution. */
     readonly clock?: () => number;
-    /** Scopes permitted by the agent's memory policy for this call. */
     readonly scopes?: readonly MemoryScope[];
-    /** Optional kind filter from `memoryPolicy.preCallLoad`. */
     readonly kind?: MemoryKind;
-    /** Maximum memory entries the runtime should load from any one scope. */
     readonly maxEntries?: number;
-    /** Maximum rendered pre-call context bytes. */
     readonly maxBytes?: number;
 }) => Promise<PreCallContext>;
 interface PreCallContext {
-    /** Map of `${scope}:${scopeId}:${kind}:${key}` to entry. Empty on resolver error. */
     readonly memory: ReadonlyMap<string, MemoryEntry>;
-    /**
-     * Non-memory context: CRM records, feature flags, tenant config, anything
-     * the LLM should see in the system prompt that is *not* a memory entry.
-     * Rendered into a separate `<context>...</context>` block above the
-     * `<memory>...</memory>` block.
-     */
     readonly static: ReadonlyMap<string, string>;
-    /** When the resolver ran, wall-clock ms. */
     readonly resolvedAtMs: number;
-    /** Per-bucket degradation flag. */
     readonly degraded: {
         readonly memory: boolean;
         readonly static: boolean;
@@ -1658,26 +1560,11 @@ interface PreCallMemoryContext {
     readonly resolvedAtMs: number;
     readonly degraded: boolean;
 }
-/**
- * Carries the terminal session, the persisted snapshot, and a snapshot
- * of the memory adapter's state at the moment of endSession. The
- * memory snapshot is the source of truth for "what did we learn about
- * this caller" — the runtime does not try to track per-write
- * `MemoryChangeRecord`s, because most writes are within the session
- * scope and are about to be deleted by `deleteSessionScopeOnEnd`. The
- * snapshot the user actually wants is what survives into `user` /
- * `organization` / `workflow` scopes.
- */
 interface SessionEndEvent {
     readonly session: TerminalSession;
     readonly snapshot: SessionSnapshot;
-    /**
-     * Memory state at end-of-session, scoped to the user/org/workflow ids
-     * the runtime resolved for this session. Empty for sessions that wrote
-     * only to `session` scope (which is about to be deleted).
-     */
+    readonly snapshotStatus?: "available" | "timed_out" | "unavailable";
     readonly finalMemorySnapshot: SessionEndMemorySnapshot;
-    /** Result of the ordered session-memory drain and optional purge. */
     readonly memoryFinalization: SessionMemoryFinalization;
     readonly wallClockMs: number;
 }
@@ -1699,17 +1586,73 @@ interface SessionEndMemorySnapshot {
     readonly organization?: ReadonlyMap<string, MemoryEntry>;
     readonly workflow?: ReadonlyMap<string, MemoryEntry>;
 }
-/**
- * Contract for an external observability consumer. The runtime emits
- * one `record` per observable event and one `onTurn` per terminal
- * turn. Implementations: Earshot-shaped (project into an `earshot.*`
- * event), OTel-shaped (project into a span event), console.log-shaped.
- */
 interface SessionMetricsRecorder {
     record(name: string, attributes?: Readonly<Record<string, string | number | boolean>>): void;
     onTurn(turn: TerminalTurn, sessionId: SessionId): void;
+    onSessionTrace?(trace: RuntimeSessionTrace): void;
     onSessionEnd?(event: SessionEndEvent): void;
 }
+interface RuntimeTraceError {
+    readonly code: string;
+    readonly category: ErrorCategory;
+    readonly retriable: boolean;
+}
+interface RuntimeSessionTrace {
+    readonly schemaVersion: 1;
+    readonly privacy: {
+        readonly classification: "metadata_only";
+        readonly excludes: readonly [
+            "transcripts",
+            "audio",
+            "tool_names",
+            "tool_arguments",
+            "tool_results",
+            "provider_error_messages",
+            "session_metadata",
+            "variables",
+            "memory"
+        ];
+    };
+    readonly session: {
+        readonly id: SessionId;
+        readonly callId?: CallId;
+        readonly agentId: AgentId;
+        readonly channel: ChannelKind;
+        readonly status: TerminalSessionStatus;
+        readonly terminalSource?: TerminalSource;
+        readonly createdAt: Timestamp;
+        readonly startedAt: Timestamp;
+        readonly endedAt: Timestamp;
+        readonly error?: RuntimeTraceError;
+    };
+    readonly snapshot: {
+        readonly status: "available" | "timed_out" | "unavailable";
+        readonly turnCount: number;
+        readonly omittedTurnCount: number;
+        readonly toolCallCount: number;
+        readonly omittedToolCallCount: number;
+    };
+    readonly turns: readonly {
+        readonly id: TurnId;
+        readonly sequence: number;
+        readonly status: TurnStatus;
+        readonly startedAt: Timestamp;
+        readonly endedAt?: Timestamp;
+        readonly latency: TurnLatency;
+        readonly delivery?: TurnOutputDelivery;
+        readonly error?: RuntimeTraceError;
+    }[];
+    readonly toolCalls: readonly {
+        readonly id: ToolCallId;
+        readonly turnId: TurnId;
+        readonly status: ToolCallStatus;
+        readonly attempts: number;
+        readonly queuedAt: Timestamp;
+        readonly startedAt?: Timestamp;
+        readonly endedAt?: Timestamp;
+        readonly error?: RuntimeTraceError;
+    }[];
+}
 interface HealthSnapshot {
     readonly ok: boolean;
     readonly checks?: Readonly<Record<string, HealthCheckResult>>;
@@ -1718,7 +1661,6 @@ 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 {
@@ -1755,11 +1697,8 @@ interface StartSessionOptions {
     readonly call?: Call;
     readonly variables?: Readonly<Record<string, unknown>>;
     readonly metadata?: Readonly<Record<string, unknown>>;
-    /** User scope identity for cross-call memory recall. */
     readonly memoryUserId?: UserId;
-    /** Organization scope for cross-call memory recall. */
     readonly organizationId?: OrganizationId;
-    /** Workflow scope for cross-call memory recall. */
     readonly workflowId?: WorkflowId;
 }
 type EndSessionReason = "completed" | "cancelled" | "failed" | "timeout";
@@ -1818,41 +1757,19 @@ interface SessionAttachment {
     readonly signal: AbortSignal;
     readonly health: SessionAttachmentHealth;
     readonly detach: () => Promise<void>;
-    /**
-     * Pre-call context loaded from the runtime's pre-call context resolver
-     * before the call starts. Contains both memory entries (rendered as
-     * `<memory>...</memory>`) and non-memory static context (rendered as
-     * `<context>...</context>`). Pre-1.0, this was `preCallMemory` and
-     * carried only the memory entries. The rename is the contract-clarity
-     * fix; legacy callers reading `preCallMemory.entries` should switch
-     * to `preCallContext.memory`.
-     */
     readonly preCallContext?: PreCallContext;
     /**
-     * @deprecated Use `preCallContext`. The legacy `preCallMemory` field
-     * is kept as a typedef for one release and resolved to a shim that
-     * projects `preCallContext.memory`.
+     * @deprecated Use `preCallContext`. This compatibility field projects
+     * `preCallContext.memory`.
      */
     readonly preCallMemory?: PreCallMemoryContext;
 }
 interface RuntimeServiceLifecycle {
-    /** Starts the runtime. A runtime can be started once; create a new runtime after stop. */
     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
-     * runtime cannot be restarted because durable adapters are closed.
-     */
     stop(): Promise<void>;
     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>;
@@ -1867,28 +1784,14 @@ interface Runtime extends RuntimeServiceLifecycle {
     startTurn(request: StartTurnRequest): Promise<Turn>;
     endTurn(sessionId: SessionId, turnId: TurnId, request: EndTurnRequest): Promise<TerminalTurn>;
     updateTurnStatus(sessionId: SessionId, turnId: TurnId, status: TurnStatus): Promise<Turn>;
-    /** Marks durable persistence health for the live attachment without changing lease ownership. */
     setPersistenceHealth(sessionId: SessionId, degraded: boolean): void;
-    /**
-     * Serializes memory writes and session-end purge for one session. Built-in
-     * runtimes provide this; custom runtimes may omit it for compatibility.
-     */
     runSessionMemoryOperation?<T>(sessionId: SessionId, operation: () => Promise<T>): Promise<T>;
     startToolCall(toolCall: QueuedToolCall): Promise<RunningToolCall>;
     finishToolCall(toolCall: TerminalToolCall): Promise<TerminalToolCall>;
     recoverToolCalls(sessionId: SessionId): Promise<readonly ToolCall[]>;
     checkpointTurnInterruption(sessionId: SessionId, turnId: TurnId, reason: TurnCancellationReason): Promise<Turn>;
-    /** Session-relative monotonic offset used for turn and media timing. */
     sessionClockMs(id: SessionId): number;
-    /** Persists a completed tool call as part of runtime session state. */
     recordToolCall(toolCall: ToolCall): Promise<void>;
-    /**
-     * Optional health check. The runtime exposes this so the
-     * `NodeMediaPlane` (or any other host) can surface readiness via
-     * `/healthz`. Returns `ok: true` when the underlying store + leases
-     * are healthy; the host responds with HTTP 200 vs 503. Best-effort:
-     * a throw produces `ok: false`.
-     */
     healthCheck(): Promise<HealthSnapshot>;
     inspectSession(id: SessionId): Promise<SessionSnapshot>;
     readonly durablePolicy?: DurableRuntimePolicy;
@@ -1971,14 +1874,18 @@ declare function isTerminalTurn(turn: Turn): turn is TerminalTurn;
 
 interface ProviderClock {
     now(): Timestamp;
+    /** Optional for backward-compatible injected clocks; adapters fall back to performance.now(). */
+    monotonicNowMs?(): number;
 }
 
+declare const TWILIO_MAX_AUDIO_EVENT_BYTES = 65536;
+
 interface TwilioMediaStreamSocket {
     readonly readyState: number;
     readonly bufferedAmount?: number;
     send(data: string): void;
     close(code?: number, reason?: string): void;
-    on(event: "message", handler: (data: WebSocket.RawData) => void): this;
+    on(event: "message", handler: (data: WebSocket__default.RawData) => void): this;
     on(event: "close", handler: () => void): this;
     on(event: "error", handler: (error: Error) => void): this;
 }
@@ -1988,7 +1895,6 @@ 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;
@@ -1998,11 +1904,13 @@ declare class TwilioMediaStreamCallHandle implements CallHandle {
     #private;
     readonly options: TwilioMediaStreamCallHandleOptions;
     readonly events: AsyncIterable<InboundMediaEvent>;
+    readonly remoteHangup: Promise<void>;
     constructor(options: TwilioMediaStreamCallHandleOptions);
     readonly callId: CallId;
     send(event: OutputMediaEvent): Promise<boolean>;
     clear(): Promise<void>;
     close(reason: StreamEndReason): Promise<void>;
+    endInput(reason: StreamEndReason): Promise<void>;
     confirmPlayout(markId: string, timeoutMs: number): Promise<boolean>;
 }
 
@@ -2051,27 +1959,33 @@ declare class TwilioMediaStreamsProvider implements TelephonyProvider {
 }
 declare function createTwilioMediaStreamsProvider(): TwilioMediaStreamsProvider;
 
-declare const WEB_CLIENT_AUDIO_CLOSE_CODES: {
-    readonly protocol: 4400;
-    readonly heartbeatTimeout: 4408;
-    readonly superseded: 4409;
-    readonly maxDuration: 4410;
-    readonly resourceLimit: 4413;
-    readonly operatorTerminated: 4500;
-};
 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;
+    maxBinaryFrameBytes: number;
+    maxInputBytesPerSecond: number;
+    maxPendingEvents: number;
+    maxInputFramesPerSecond: number;
+    maxPendingAcks: number;
 };
+
+declare const WEB_CLIENT_AUDIO_CLOSE_CODES: {
+    protocol: number;
+    heartbeatTimeout: number;
+    superseded: number;
+    maxDuration: number;
+    resourceLimit: number;
+    operatorTerminated: 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;
+    terminate?(): void;
     on(event: "message", handler: (data: WebSocket.RawData, isBinary: boolean) => void): this;
     on(event: "close", handler: (code: number, reason: Buffer) => void): this;
     on(event: "error", handler: (error: Error) => void): this;
@@ -2113,57 +2027,27 @@ 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>;
+    endInput(reason: StreamEndReason): Promise<void>;
     close(reason: StreamEndReason): Promise<void>;
     terminate(code: number, reason: string): void;
     confirmPlayout(markId: string, timeoutMs: number): Promise<boolean>;
 }
+declare const WebClientAudioCallHandle: {
+    new (options: WebClientAudioCallHandleOptions): WebClientAudioCallHandle;
+};
 interface WebClientAudioProviderOptions extends Omit<WebClientAudioCallHandleOptions, "socket" | "callId" | "sessionId" | "onClosed" | "expectedMode"> {
 }
-declare class WebClientAudioProvider implements TelephonyProvider {
-    #private;
+interface WebClientAudioProvider extends TelephonyProvider {
     readonly name: "web-client-audio";
-    readonly kind = "telephony";
-    readonly version = "0.1.0";
-    readonly capabilities: {
-        streaming: {
-            input: true;
-            output: true;
-            native: true;
-        };
-        cancellation: {
-            request: true;
-            output: true;
-            buffer: true;
-            truncation: false;
-        };
-        transports: "websocket"[];
-        audio: {
-            input: {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 16000;
-                readonly channels: 1;
-            }[];
-            output: {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 16000;
-                readonly channels: 1;
-            }[];
-        };
-        playout: {
-            clearBuffer: true;
-            acknowledgement: true;
-            position: false;
-        };
-    };
-    constructor(options?: WebClientAudioProviderOptions);
+    readonly kind: "telephony";
+    readonly version: "0.1.0";
+    readonly capabilities: ProviderCapabilities;
     dial(): Promise<CallHandle>;
     accept(ctx: Parameters<TelephonyProvider["accept"]>[0]): Promise<CallHandle>;
     attachWebSocket(socket: WebClientAudioSocket, callId: CallId, sessionId: SessionId): void;
@@ -2173,6 +2057,9 @@ declare class WebClientAudioProvider implements TelephonyProvider {
     hangup(callId: CallId): Promise<void>;
     supersede(callId: CallId): Promise<void>;
 }
+declare const WebClientAudioProvider: {
+    new (options?: WebClientAudioProviderOptions): WebClientAudioProvider;
+};
 declare function createWebClientAudioProvider(options?: WebClientAudioProviderOptions): WebClientAudioProvider;
 
 interface DeepgramSttProviderOptions {
@@ -2183,8 +2070,9 @@ interface DeepgramSttProviderOptions {
     readonly endpointingMs?: number;
     readonly vadEvents?: boolean;
     readonly punctuate?: boolean;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
+declare const MAX_PROVIDER_AUDIO_OFFSET_MS = 86400000;
 declare class DeepgramSttProvider implements SpeechToTextProvider {
     #private;
     readonly name: "deepgram";
@@ -2219,6 +2107,72 @@ declare class DeepgramSttProvider implements SpeechToTextProvider {
 }
 declare function createDeepgramSttProvider(options: DeepgramSttProviderOptions): DeepgramSttProvider;
 
+type CartesiaSttMode = "manual" | "auto";
+interface CartesiaSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly batchUrl?: string;
+    readonly modelId?: string;
+    readonly batchModelId?: string;
+    readonly allowUnknownModel?: boolean;
+    /** `manual` uses `/stt/websocket`; `auto` uses Ink's native turn detector. */
+    readonly mode?: CartesiaSttMode;
+    /** Used when a session request does not provide a language. Ink 2 can auto-detect. */
+    readonly language?: string;
+    readonly turnStartThreshold?: number;
+    readonly turnEagerEndThreshold?: number;
+    readonly turnEndThreshold?: number;
+    readonly turnEndTimeoutMs?: number;
+    readonly clock?: ProviderClock;
+    readonly fetchImpl?: typeof fetch;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+declare class CartesiaSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "cartesia-stt";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        batch: {
+            input: true;
+            output: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: ("http" | "websocket")[];
+        audio: {
+            input: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly ["ink-2", "ink-preview", "ink-whisper-2025-06-04"];
+        batchModels: readonly ["ink-whisper"];
+        turnDetection: ("manual" | "provider")[];
+        metadata: {
+            realtimeModels: string[];
+            autoTurnModels: string[];
+            batchModels: string[];
+            partialTranscripts: boolean;
+            manualFinalize: boolean;
+        };
+    };
+    constructor(options: CartesiaSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+    transcribe(request: SttBatchTranscriptionRequest): Promise<SttBatchTranscription>;
+}
+declare function createCartesiaSttProvider(options: CartesiaSttProviderOptions): CartesiaSttProvider;
+
 type SarvamOutputMode = "transcribe" | "translate" | "verbatim" | "translit" | "codemix";
 interface SarvamSttProviderOptions {
     readonly apiKey: string;
@@ -2230,7 +2184,7 @@ interface SarvamSttProviderOptions {
     readonly flushSignal?: boolean;
     readonly inputAudioCodec?: "pcm_s16le" | "pcm_l16" | "pcm_raw";
     readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
 declare class SarvamSttProvider implements SpeechToTextProvider {
     #private;
@@ -2263,7 +2217,7 @@ declare class SarvamSttProvider implements SpeechToTextProvider {
             })[];
         };
         models: readonly ["saaras:v3", "saaras:v4"];
-        turnDetection: ("vad" | "manual")[];
+        turnDetection: ("manual" | "vad")[];
         metadata: {
             interimResults: boolean;
             outputModes: string[];
@@ -2274,38 +2228,189 @@ 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 Bulbul v3 and v4 Flash accept 0.5 through 2.0. */
+    readonly pace?: number;
+    /** Bulbul v3 temperature; Bulbul v4 Flash does not accept this option. */
+    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: {
-            input: true;
-            output: true;
-            native: true;
-        };
-        cancellation: {
-            request: true;
+    readonly capabilities: ProviderCapabilities;
+    constructor(options: SarvamTtsProviderOptions);
+    get configuredModel(): string;
+    get configuredLanguage(): string;
+    get languageWasExplicitlyConfigured(): boolean;
+    get configuredVoice(): string | undefined;
+    supportsVoice(voice: string, model?: string): boolean;
+    supportsLanguage(language: string, model?: string): boolean;
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+    openSession(request: TtsSessionOpenRequest): Promise<SarvamTtsStream>;
+}
+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;
+
+declare const SARVAM_TTS_V4_FLASH_MODEL: "bulbul:v4-flash";
+
+interface SarvamTtsHttpProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly voiceId?: string;
+    readonly modelId?: string;
+    readonly language?: string;
+    /** Provider pace. Sarvam Bulbul v3 and v4 Flash accept 0.5 through 2.0. */
+    readonly pace?: number;
+    /** HTTP temperature tuning for Sarvam Bulbul v3 and v4 Flash (0.01 through 1.0). */
+    readonly temperature?: number;
+    readonly pronunciationDictionaryId?: string;
+    /** Maximum time allowed for request headers and the complete response. Defaults to 10 minutes. */
+    readonly requestTimeoutMs?: number;
+    /** Maximum wait for response progress after headers arrive. Defaults to 30 seconds. */
+    readonly responseIdleTimeoutMs?: number;
+    readonly clock?: ProviderClock;
+    /** Fetch override for tests or custom transports. */
+    readonly fetchImpl?: typeof fetch;
+}
+
+declare class SarvamTtsRestProvider implements TextToSpeechProvider {
+    #private;
+    readonly name: "sarvam-tts";
+    readonly kind = "tts";
+    readonly version = "0.1.0";
+    readonly capabilities: ProviderCapabilities;
+    constructor(options: SarvamTtsHttpProviderOptions);
+    get configuredModel(): string;
+    get configuredLanguage(): string;
+    get languageWasExplicitlyConfigured(): boolean;
+    get configuredVoice(): string | undefined;
+    supportsVoice(voice: string, model?: string): boolean;
+    supportsLanguage(language: string, model?: string): boolean;
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+}
+declare class SarvamTtsHttpStreamProvider implements TextToSpeechProvider {
+    #private;
+    readonly name: "sarvam-tts";
+    readonly kind = "tts";
+    readonly version = "0.1.0";
+    readonly capabilities: ProviderCapabilities;
+    constructor(options: SarvamTtsHttpProviderOptions);
+    get configuredModel(): string;
+    get configuredLanguage(): string;
+    get languageWasExplicitlyConfigured(): boolean;
+    get configuredVoice(): string | undefined;
+    supportsVoice(voice: string, model?: string): boolean;
+    supportsLanguage(language: string, model?: string): boolean;
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+}
+declare function createSarvamTtsRestProvider(options: SarvamTtsHttpProviderOptions): SarvamTtsRestProvider;
+declare function createSarvamTtsHttpStreamProvider(options: SarvamTtsHttpProviderOptions): SarvamTtsHttpStreamProvider;
+
+type ElevenLabsBatchTimestampGranularity = "none" | "word" | "character";
+type ElevenLabsEntityDetection = string | readonly string[];
+interface ElevenLabsBatchSttRequest {
+    readonly audio: Uint8Array;
+    readonly format: AudioFormat;
+    readonly model?: string;
+    readonly language?: string;
+    readonly keyterms?: readonly string[];
+    readonly tagAudioEvents?: boolean;
+    readonly diarize?: boolean;
+    readonly numSpeakers?: number;
+    readonly timestampsGranularity?: ElevenLabsBatchTimestampGranularity;
+    readonly diarizationThreshold?: number;
+    readonly entityDetection?: ElevenLabsEntityDetection;
+    readonly noVerbatim?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface ElevenLabsBatchSttResult {
+    readonly modelId: string;
+    readonly text: string;
+    readonly languageCode?: string;
+    readonly languageProbability?: number;
+    readonly words: readonly Readonly<Record<string, unknown>>[];
+    readonly entities?: readonly Readonly<Record<string, unknown>>[];
+}
+
+type ElevenLabsSttCommitStrategy = "manual" | "vad";
+
+interface ElevenLabsSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly batchUrl?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly modelId?: string;
+    readonly commitStrategy?: ElevenLabsSttCommitStrategy;
+    readonly includeTimestamps?: boolean;
+    readonly includeLanguageDetection?: boolean;
+    readonly vadThreshold?: number;
+    readonly vadSilenceThresholdSecs?: number;
+    readonly secondaryLanguages?: readonly string[];
+    readonly minSpeechDurationMs?: number;
+    readonly minSilenceDurationMs?: number;
+    readonly noVerbatim?: boolean;
+    /** Detect bounded entity records on committed realtime transcript segments. */
+    readonly entityDetection?: ElevenLabsEntityDetection;
+    readonly filterBackgroundAudio?: boolean;
+    readonly enableLogging?: boolean;
+    /** Context sent with the first audio frame; useful after reconnects. */
+    readonly previousText?: string;
+    readonly clock?: ProviderClock;
+    readonly fetchImpl?: typeof fetch;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+declare class ElevenLabsSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "elevenlabs-stt-realtime";
+    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"[];
+        transports: ("http" | "websocket")[];
         audio: {
             input: readonly [{
                 readonly encoding: "pcm_s16le";
@@ -2333,18 +2438,311 @@ declare class ElevenLabsSttProvider implements SpeechToTextProvider {
                 readonly channels: 1;
             }];
         };
-        models: readonly ["scribe_v2_realtime"];
-        turnDetection: ("vad" | "manual")[];
+        models: readonly ["scribe_v2_realtime", "scribe_v2", "scribe_v2_medical"];
+        turnDetection: ("manual" | "vad")[];
         metadata: {
             realtimeModel: string;
+            realtimeModels: string[];
+            batchModels: string[];
+            batchTranscription: boolean;
             partialTranscripts: boolean;
         };
     };
     constructor(options: ElevenLabsSttProviderOptions);
     open(request: SttOpenRequest): Promise<SttStream>;
+    transcribe(request: ElevenLabsBatchSttRequest): Promise<ElevenLabsBatchSttResult>;
+    transcribe(request: SttBatchTranscriptionRequest): Promise<SttBatchTranscription>;
 }
 declare function createElevenLabsSttProvider(options: ElevenLabsSttProviderOptions): ElevenLabsSttProvider;
 
+/**
+ * Vendor facts that change on the provider's release schedule rather than ours:
+ * model catalogs and wire protocol versions.
+ *
+ * These deliberately live at the adapter edge instead of in `@tvic/core`. A model
+ * list is not a runtime contract, it is dated evidence. Compiling it into core made
+ * two things invisible: how old the claim was, and the fact that a vendor deprecating
+ * a model silently turns `capabilities.models` into a false statement.
+ *
+ * Every entry carries the date it was verified and the document it came from.
+ * Reverify before relying on an entry for a production or purchasing decision, and
+ * treat a stale `verifiedAt` as a reason to omit a capability rather than assert it.
+ */
+interface ProviderCatalogEntry {
+    /** ISO date the model list below was last checked against `source`. */
+    readonly verifiedAt: string;
+    /** Official provider documentation the entry was read from. */
+    readonly source: string;
+    /** Model used when the caller does not choose one. */
+    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. 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.
+ */
+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";
+    readonly webClientAudio: "stable";
+    readonly twilio: "stable";
+}>;
+declare const PROVIDER_CATALOG: {
+    readonly deepgram: {
+        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-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-10-09";
+        readonly source: "https://docs.sarvam.ai/api/getting-started/models/bulbul";
+        readonly defaultModel: "bulbul:v3";
+        readonly models: readonly ["bulbul:v3", "bulbul:v4-flash"];
+    };
+    readonly cartesia: {
+        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-09-25";
+        readonly source: "https://elevenlabs.io/docs/overview/models";
+        readonly defaultModel: "eleven_flash_v2_5";
+        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-09-24";
+        readonly source: "https://elevenlabs.io/docs/overview/models";
+        readonly defaultModel: "scribe_v2_realtime";
+        readonly models: readonly ["scribe_v2_realtime", "scribe_v2", "scribe_v2_medical"];
+    };
+    readonly assemblyai: {
+        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";
+        readonly source: "https://soniox.com/docs/api-reference/stt/websocket-api";
+        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";
+        readonly defaultModel: "gpt-4.1-mini";
+        readonly models: readonly ["gpt-5", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini"];
+    };
+};
+/**
+ * Provider wire protocol versions. Separate from the model catalog because a
+ * protocol version changes adapter parsing, not just which model is selected.
+ */
+declare const PROVIDER_API_VERSIONS: {
+    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,
+ * not facts about the provider, so they are not dated catalog entries.
+ */
+declare const ADAPTER_DEFAULTS: {
+    readonly deepgram: {
+        readonly endpointingMs: 300;
+        readonly vadEvents: true;
+        readonly punctuate: true;
+    };
+    readonly sarvam: {
+        readonly mode: "transcribe";
+        readonly highVadSensitivity: true;
+        readonly vadSignals: true;
+        readonly flushSignal: true;
+        readonly inputAudioCodec: "pcm_s16le";
+    };
+    readonly sarvamTts: {
+        readonly language: "en-IN";
+        readonly voice: "shubh";
+        readonly pace: 1;
+        readonly temperature: 0.6;
+        readonly minBufferSize: 50;
+        readonly maxChunkLength: 150;
+    };
+    readonly cartesia: {
+        readonly language: "en";
+    };
+    readonly cartesiaStt: {
+        readonly mode: "manual";
+    };
+};
+
+interface AssemblyAiSpeakerOptions {
+    readonly minSpeakersExpected?: number;
+    readonly maxSpeakersExpected?: number;
+    readonly includeSpeakerConfidence?: boolean;
+}
+type AssemblyAiPiiSubstitution = "entity_name" | "hash";
+type AssemblyAiRedactedAudioQuality = "mp3" | "wav";
+interface AssemblyAiRedactPiiAudioOptions {
+    readonly overrideAudioRedactionMethod?: "beep" | "silence";
+    readonly returnRedactedNoSpeechAudio?: boolean;
+}
+interface AssemblyAiPreRecordedSttRequest {
+    /** A complete local file or encoded media payload. */
+    readonly audio?: Uint8Array;
+    /** A public URL or AssemblyAI upload URL. Exactly one audio source is required. */
+    readonly audioUrl?: string;
+    /** Content type used when `audio` is uploaded. */
+    readonly mimeType?: string;
+    /** Filename used as the multipart upload filename. */
+    readonly fileName?: string;
+    /** Convenience single-model selector. Cannot be combined with speechModels. */
+    readonly model?: string;
+    /** Ordered model candidates. AssemblyAI may fall back to the next model. */
+    readonly speechModels?: readonly string[];
+    readonly language?: string;
+    readonly languageDetection?: boolean;
+    readonly prompt?: string;
+    readonly vocabulary?: readonly string[];
+    readonly punctuate?: boolean;
+    readonly formatText?: boolean;
+    readonly disfluencies?: boolean;
+    readonly speakerLabels?: boolean;
+    readonly speakersExpected?: number;
+    readonly speakerOptions?: AssemblyAiSpeakerOptions;
+    /** Current AssemblyAI name for separate-channel transcription. */
+    readonly multichannel?: boolean;
+    /** @deprecated Use `multichannel`. Kept as a compatibility alias. */
+    readonly dualChannel?: boolean;
+    readonly redactPii?: boolean;
+    readonly redactPiiPolicies?: readonly string[];
+    readonly redactPiiSub?: AssemblyAiPiiSubstitution;
+    readonly redactPiiAudio?: boolean;
+    readonly redactPiiAudioQuality?: AssemblyAiRedactedAudioQuality;
+    readonly redactPiiAudioOptions?: AssemblyAiRedactPiiAudioOptions;
+    readonly redactPiiReturnUnredacted?: boolean;
+    readonly redactStaticEntities?: Readonly<Record<string, readonly string[]>>;
+    readonly speechThreshold?: number;
+    readonly webhookUrl?: string;
+    readonly webhookAuthHeaderName?: string;
+    readonly webhookAuthHeaderValue?: string;
+    readonly signal?: AbortSignal;
+    readonly pollIntervalMs?: number;
+    readonly pollTimeoutMs?: number;
+}
+interface AssemblyAiSyncSttRequest {
+    /** Raw PCM16LE bytes. The format is sent in the Sync config part. */
+    readonly audio: Uint8Array;
+    readonly format: AudioFormat;
+    readonly model?: string;
+    readonly languageCodes?: readonly string[];
+    readonly prompt?: string;
+    readonly vocabulary?: readonly string[];
+    readonly timestamps?: boolean;
+    readonly fileName?: string;
+    readonly signal?: AbortSignal;
+}
+interface AssemblyAiSyncLiveSttRequest {
+    /** Async PCM16LE chunks produced while the recording is in progress. */
+    readonly audio: AsyncIterable<Uint8Array>;
+    readonly format: AudioFormat;
+    readonly model?: string;
+    readonly languageCodes?: readonly string[];
+    readonly prompt?: string;
+    readonly vocabulary?: readonly string[];
+    readonly timestamps?: boolean;
+    readonly fileName?: string;
+    readonly signal?: AbortSignal;
+}
+interface AssemblyAiTranscriptWord {
+    readonly text: string;
+    readonly start?: number;
+    readonly end?: number;
+    readonly confidence?: number;
+    readonly speaker?: string;
+    readonly [key: string]: unknown;
+}
+interface AssemblyAiTranscriptUtterance {
+    readonly text: string;
+    readonly start?: number;
+    readonly end?: number;
+    readonly confidence?: number;
+    readonly speaker?: string;
+    readonly words?: readonly AssemblyAiTranscriptWord[];
+    readonly [key: string]: unknown;
+}
+interface AssemblyAiPreRecordedSttResult {
+    readonly id: string;
+    readonly status: "completed";
+    readonly modelId: string;
+    readonly text: string;
+    readonly languageCode?: string;
+    readonly audioDurationMs?: number;
+    readonly audioChannels?: number;
+    readonly confidence?: number;
+    readonly words: readonly AssemblyAiTranscriptWord[];
+    readonly utterances: readonly AssemblyAiTranscriptUtterance[];
+    /** Bounded provider response for fields not yet promoted into the TVIC shape. */
+    readonly providerResponse: Readonly<Record<string, unknown>>;
+}
+interface AssemblyAiSyncSttResult {
+    readonly sessionId: string;
+    readonly modelId: string;
+    readonly text: string;
+    readonly confidence?: number;
+    readonly audioDurationMs?: number;
+    readonly requestTimeMs?: number;
+    readonly words: readonly AssemblyAiTranscriptWord[];
+    readonly providerResponse: Readonly<Record<string, unknown>>;
+}
+
 interface AssemblyAiSttProviderOptions {
     readonly apiKey: string;
     readonly url?: string;
@@ -2353,10 +2751,17 @@ interface AssemblyAiSttProviderOptions {
     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 webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    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;
@@ -2375,7 +2780,7 @@ declare class AssemblyAiSttProvider implements SpeechToTextProvider {
             buffer: false;
             truncation: false;
         };
-        transports: "websocket"[];
+        transports: ("http" | "websocket")[];
         audio: {
             input: {
                 readonly encoding: "pcm_s16le";
@@ -2383,16 +2788,30 @@ declare class AssemblyAiSttProvider implements SpeechToTextProvider {
                 readonly channels: 1;
             }[];
         };
-        models: readonly ["u3-rt-pro"];
+        models: readonly string[];
         turnDetection: "stt_endpointing"[];
         metadata: {
-            realtimeModel: "u3-rt-pro";
+            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;
 
@@ -2416,7 +2835,7 @@ interface SonioxSttProviderOptions {
     readonly endpointLatencyAdjustmentLevel?: number;
     readonly enableLanguageIdentification?: boolean;
     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 SonioxSttProvider implements SpeechToTextProvider {
     #private;
@@ -2448,7 +2867,7 @@ declare class SonioxSttProvider implements SpeechToTextProvider {
             }];
         };
         models: readonly ["stt-rt-v5"];
-        turnDetection: ("stt_endpointing" | "manual")[];
+        turnDetection: ("manual" | "stt_endpointing")[];
         metadata: {
             realtimeModel: "stt-rt-v5";
             partialTranscripts: boolean;
@@ -2530,6 +2949,17 @@ declare class GroqChatLlmProvider implements LLMProvider {
 }
 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;
@@ -2538,8 +2968,16 @@ interface CartesiaTtsProviderOptions {
     /** 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;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
 }
 declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
     #private;
@@ -2566,152 +3004,75 @@ declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
                 readonly channels: 1;
             }[];
         };
-        models: readonly ["sonic-3", "sonic-2"];
+        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);
+    get configuredModel(): string;
+    get allowUnknownModel(): boolean;
+    get configuredVoice(): string;
+    get configuredLanguage(): string;
     synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
     openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
 }
 declare function createCartesiaTtsProvider(options: CartesiaTtsProviderOptions): CartesiaTtsProvider;
 
-/**
- * Vendor facts that change on the provider's release schedule rather than ours:
- * model catalogs and wire protocol versions.
- *
- * These deliberately live at the adapter edge instead of in `@tvic/core`. A model
- * list is not a runtime contract, it is dated evidence. Compiling it into core made
- * two things invisible: how old the claim was, and the fact that a vendor deprecating
- * a model silently turns `capabilities.models` into a false statement.
- *
- * Every entry carries the date it was verified and the document it came from.
- * Reverify before relying on an entry for a production or purchasing decision, and
- * treat a stale `verifiedAt` as a reason to omit a capability rather than assert it.
- */
-interface ProviderCatalogEntry {
-    /** ISO date the model list below was last checked against `source`. */
-    readonly verifiedAt: string;
-    /** Official provider documentation the entry was read from. */
-    readonly source: string;
-    /** Model used when the caller does not choose one. */
-    readonly defaultModel: string;
-    /** Models this adapter is known to work with, not the vendor's full catalog. */
-    readonly models: readonly string[];
+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;
 }
-/**
- * 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.
- */
-type ProviderStability = "stable" | "experimental" | "deferred";
-declare const PROVIDER_STABILITY: Readonly<{
-    readonly deepgram: "experimental";
-    readonly sarvam: "experimental";
-    readonly elevenlabsStt: "experimental";
-    readonly assemblyai: "experimental";
-    readonly soniox: "experimental";
-    readonly groq: "experimental";
-    readonly openaiResponses: "experimental";
-    readonly cartesia: "experimental";
-    readonly elevenlabs: "experimental";
-    readonly webClientAudio: "stable";
-    readonly twilio: "stable";
-}>;
-declare const PROVIDER_CATALOG: {
-    readonly deepgram: {
-        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-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-09-15";
-        readonly source: "https://docs.cartesia.ai/build-with-cartesia/tts-models/older-models";
-        readonly defaultModel: "sonic-3";
-        readonly models: readonly ["sonic-3", "sonic-2"];
-    };
-    readonly elevenlabs: {
-        readonly verifiedAt: "2026-07-24";
-        readonly source: "https://elevenlabs.io/docs/models";
-        readonly defaultModel: "eleven_flash_v2_5";
-        readonly models: readonly ["eleven_flash_v2_5", "eleven_turbo_v2_5", "eleven_multilingual_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 defaultModel: "scribe_v2_realtime";
-        readonly models: readonly ["scribe_v2_realtime"];
-    };
-    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 soniox: {
-        readonly verifiedAt: "2026-08-20";
-        readonly source: "https://soniox.com/docs/api-reference/stt/websocket-api";
-        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";
-        readonly defaultModel: "gpt-4.1-mini";
-        readonly models: readonly ["gpt-5", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini"];
-    };
-};
-/**
- * Provider wire protocol versions. Separate from the model catalog because a
- * protocol version changes adapter parsing, not just which model is selected.
- */
-declare const PROVIDER_API_VERSIONS: {
-    readonly cartesia: "2026-03-01";
-};
-/**
- * TVIC's own adapter tuning. These are our decisions about how to drive a provider,
- * not facts about the provider, so they are not dated catalog entries.
- */
-declare const ADAPTER_DEFAULTS: {
-    readonly deepgram: {
-        readonly endpointingMs: 300;
-        readonly vadEvents: true;
-        readonly punctuate: true;
-    };
-    readonly sarvam: {
-        readonly mode: "transcribe";
-        readonly highVadSensitivity: true;
-        readonly vadSignals: true;
-        readonly flushSignal: true;
-        readonly inputAudioCodec: "pcm_s16le";
-    };
-    readonly cartesia: {
-        readonly language: "en";
-    };
-};
-
 interface ElevenLabsTtsProviderOptions {
     readonly apiKey: string;
     readonly voiceId: string;
     readonly modelId?: string;
     readonly language?: string;
     readonly url?: string;
+    /** Allows an explicitly configured compatible endpoint/model outside the dated catalog. */
+    readonly allowUnknownModel?: boolean;
     readonly stability?: number;
     readonly similarityBoost?: number;
+    /** Regular TTS WebSocket speaker boost. */
+    readonly useSpeakerBoost?: boolean;
+    /** Regular TTS WebSocket auto mode; use only when sending complete sentences. */
+    readonly autoMode?: boolean;
+    /** Regular TTS WebSocket generation schedule, in provider character thresholds. */
+    readonly chunkLengthSchedule?: readonly number[];
+    readonly applyTextNormalization?: ElevenLabsTextNormalization;
+    readonly enableLogging?: boolean;
+    readonly enableSsmlParsing?: boolean;
+    readonly seed?: number;
+    readonly inactivityTimeoutSeconds?: number;
+    /** Up to three dictionaries, applied in order on the first provider message. */
+    readonly pronunciationDictionaryLocators?: readonly ElevenLabsPronunciationDictionaryLocator[];
+    /** Voices registered for an Eleven v3 dialogue session. */
+    readonly dialogueVoices?: readonly string[];
     readonly clock?: ProviderClock;
-    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket__default;
+}
+
+interface ElevenLabsStreamOptions {
+    readonly clock: ProviderClock;
+    readonly modelId?: string;
+    readonly protocol?: ElevenLabsTtsProtocol;
+    readonly voice?: string;
+    readonly voices?: readonly string[];
+    readonly maxCharacters?: number | undefined;
+    readonly stability: number;
+    readonly similarityBoost: number;
+    readonly useSpeakerBoost?: boolean | undefined;
+    readonly applyTextNormalization?: ElevenLabsTextNormalization | undefined;
+    readonly chunkLengthSchedule?: readonly number[] | undefined;
+    readonly pronunciationDictionaryLocators?: readonly ElevenLabsPronunciationDictionaryLocator[] | undefined;
 }
 declare class ElevenLabsTtsProvider implements IncrementalTextToSpeechProvider {
     #private;
@@ -2738,24 +3099,121 @@ 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);
+    get configuredModel(): string;
+    get allowUnknownModel(): boolean;
+    get configuredVoice(): string;
+    get configuredLanguage(): string | undefined;
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+    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>;
+    sendDialogueTurn(text: string, options?: ElevenLabsDialogueTurnOptions): Promise<void>;
+    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>;
+    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 configuredModel(): string;
+    get allowUnknownModel(): boolean;
+    get configuredVoice(): string;
+    get configuredLanguage(): string | undefined;
+    get _httpOptions(): ElevenLabsHttpTtsProviderOptions;
+    get _httpModelId(): string;
+    get _httpAllowUnknownModel(): boolean;
+    get _httpClock(): ProviderClock;
+    get _httpFetch(): typeof fetch;
     synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
-    openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
+    synthesizeSpeech(request: ElevenLabsTtsHttpSynthesisRequest): Promise<TtsStream>;
+    synthesizeDialogue(request: ElevenLabsDialogueSynthesisRequest): Promise<TtsStream>;
 }
-declare function createElevenLabsTtsProvider(options: ElevenLabsTtsProviderOptions): ElevenLabsTtsProvider;
+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;
+}
+declare function createElevenLabsTtsRestProvider(options: ElevenLabsHttpTtsProviderOptions): ElevenLabsTtsRestProvider;
+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;
+    /** Map provider-specific values; callers own their semantic equivalence. */
+    readonly mapFallbackRequest?: (request: TtsSynthesisRequest, error: NormalizedError) => TtsSynthesisRequest;
+    /** Use only when the caller accepts a locale-to-language-code fallback mapping. */
+    readonly languageMatch?: "exact" | "base-language";
+    readonly shouldFallback?: (error: NormalizedError, request: TtsSynthesisRequest) => boolean;
+    readonly onFallback?: (context: TtsFailoverContext) => void | PromiseLike<void>;
+    readonly name?: string;
+}
+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;
@@ -2773,11 +3231,6 @@ declare class AsyncQueueConsumerError extends Error {
 }
 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;
 }
 /**
@@ -2803,137 +3256,38 @@ interface AudioNormalizerOptions {
 interface AudioNormalizer {
     readonly inputFormat: AudioFormat;
     readonly outputFormat: AudioFormat;
+    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
- * key that appears N times in the request will appear N times here.
- */
 type TwilioParamValue = string | readonly string[];
-/**
- * The set of POST parameters signed by Twilio. Twilio sorts by key (NOT by
- * the order they appear in the body), and concatenates `key + value` for
- * each entry, with no separator.
- */
 type TwilioParams = Readonly<Record<string, TwilioParamValue>>;
-/**
- * The simplest form: a single string value per key. Most webhooks fit this
- * shape; use `TwilioParams` directly only when you need to handle repeated
- * keys.
- */
 type TwilioFlatParams = Readonly<Record<string, string>>;
 interface VerifyTwilioOptions {
-    /** The X-Twilio-Signature header value. */
     readonly signature: string;
-    /** The full request URL (with query string). */
     readonly url: string;
-    /** The parsed POST params, as a key-value map. */
     readonly params: TwilioFlatParams | TwilioParams;
-    /**
-     * The Twilio auth token. Used as the HMAC key. Required.
-     *
-     * For token rotation, wrap the verifier yourself:
-     *   const ok = verifyTwilioSignature({...authTokenA}) ||
-     *             verifyTwilioSignature({...authTokenB});
-     */
     readonly authToken: string;
 }
 declare function canonicalizeTwilioData(url: string, params: TwilioFlatParams | TwilioParams): Buffer;
-/**
- * Compute the expected signature for a given auth token, URL, and params.
- * Exposed for tests and golden fixtures. Production code should call
- * `verifyTwilioSignature` instead.
- */
 declare function computeTwilioSignature(authToken: string, url: string, params: TwilioFlatParams | TwilioParams): string;
-/**
- * Verify a Twilio X-Twilio-Signature header. Returns true if the signature
- * matches the configured auth token.
- *
- * Returns false (does not throw) for malformed inputs:
- *   - missing or empty signature
- *   - signature is not valid base64 of length 28
- *   - signature decodes to a byte array that does not match the expected HMAC
- *
- * Throws (programmer error, not attacker error):
- *   - when `authToken` is empty string
- *
- * @remarks
- * Twilio's signature does NOT include a timestamp or nonce. To prevent replay,
- * the caller MUST enforce an idempotency check (e.g. dedupe by `CallSid` +
- * `MessageSid` with a TTL).
- *
- * @example
- *   ```ts
- *   const sig = Array.isArray(req.headers["x-twilio-signature"])
- *     ? req.headers["x-twilio-signature"][0]
- *     : req.headers["x-twilio-signature"];
- *   const ok = verifyTwilioSignature({
- *     signature: sig,
- *     url: `https://example.com${req.url}`,
- *     params: parsedFormBody,
- *     authToken: process.env.TWILIO_AUTH_TOKEN!,
- *   });
- *   if (!ok) return new Response("invalid signature", { status: 403 });
- *   ```
- */
 declare function verifyTwilioSignature(options: VerifyTwilioOptions): boolean;
 
 interface VerifyVoiceSessionTokenOptions {
-    /** The token from the WebSocket upgrade query string. */
     readonly token: string | null | undefined;
-    /** The expected session reference (e.g. "voice_<uuid>"). */
     readonly sessionRef: string;
-    /** The expiry as a string of non-negative integer milliseconds. */
     readonly exp: string | null | undefined;
-    /** The shared secret used to sign the token. */
     readonly secret: string;
-    /** Optional: current time in ms. Defaults to Date.now. Injected for tests. */
     readonly now?: () => number;
-    /**
-     * Optional: tolerance window in ms for the expiry check. Default 0.
-     * Use this if server and client clocks are skewed.
-     */
     readonly toleranceMs?: number;
 }
-/**
- * Compute the expected voice-session token for a given session ref
- * and expiry. Exposed for tests and the example app's token generator.
- */
 declare function signVoiceSessionToken(secret: string, sessionRef: string, expMs: number): string;
-/**
- * Verify a voice-session token. Returns true on success, false
- * otherwise. Does NOT throw for invalid input — callers should branch
- * on the boolean.
- *
- * @example
- *   ```ts
- *   const ok = verifyVoiceSessionToken({
- *     token: url.searchParams.get("token"),
- *     sessionRef: matchPathParams.url.sessionRef,
- *     exp: url.searchParams.get("exp"),
- *     secret: process.env.VOICE_TOKEN_SECRET!,
- *   });
- *   if (!ok) return new Response("invalid token", { status: 401 });
- *   ```
- */
 declare function verifyVoiceSessionToken(options: VerifyVoiceSessionTokenOptions): boolean;
 
 type RuntimeProvider = TelephonyProvider | SpeechToTextProvider | TextToSpeechProvider | LLMProvider;
@@ -2943,8 +3297,9 @@ type ProviderForKind<K extends ProviderKind> = Extract<RuntimeProvider, {
 declare function isProviderKind<K extends ProviderKind>(provider: RuntimeProvider, kind: K): provider is ProviderForKind<K>;
 type AudioFormatDirection = "input" | "output";
 declare function supportsAudioFormat(provider: Provider, format: AudioFormat, direction: AudioFormatDirection): boolean;
-declare function supportsLanguage(provider: Provider, language: string): boolean;
+declare function supportsLanguage(provider: Provider, language: string, model?: 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> {
@@ -2957,6 +3312,10 @@ interface DefineToolInput<TInput, TOutput> {
     readonly timeout?: TimeoutPolicy;
     readonly retry?: RetryPolicy;
     readonly idempotency?: IdempotencyPolicy;
+    /**
+     * @deprecated This field is a no-op. Enforce authorization in `execute`
+     * using `ctx.tenant?.scopes`.
+     */
     readonly authScope?: readonly string[];
     readonly tags?: readonly string[];
     readonly metadata?: Readonly<Record<string, unknown>>;
@@ -2984,6 +3343,8 @@ declare function defineAgent(input: DefineAgentInput): Agent;
 
 declare function createRuntime(options?: RuntimeOptions): Runtime;
 
+declare function toRuntimeSessionTrace(event: SessionEndEvent): RuntimeSessionTrace;
+
 interface ResolvePreCallContextInput {
     readonly memory: Memory;
     readonly resolver?: PreCallContextResolver;
@@ -3001,33 +3362,14 @@ interface ResolvePreCallContextInput {
     readonly maxEntries?: number;
     /** Maximum bytes rendered for the combined static and memory context. */
     readonly maxBytes?: number;
-    /**
-     * Optional provider of the static (non-memory) context. The default
-     * resolver returns an empty static map; the user-provided resolver
-     * (via `options.preCallContextResolver`) is the place to inject CRM,
-     * feature flags, and tenant config.
-     */
     readonly staticProvider?: () => Promise<ReadonlyMap<string, string>>;
 }
 declare function resolvePreCallContext(input: ResolvePreCallContextInput): Promise<PreCallContext>;
-/**
- * Format the pre-call context as a system-prompt block. Renders the
- * `<memory>...</memory>` block and (if non-empty or degraded) the
- * `<context>...</context>` block above it.
- */
 declare function formatPreCallContextAsSystemBlock(context: PreCallContext, maxBytes?: number): string;
-/**
- * @deprecated Use `resolvePreCallContext` and `formatPreCallContextAsSystemBlock`.
- * Kept for one compatibility release as a memory-only projection.
- */
+/** @deprecated Use `resolvePreCallContext` and `formatPreCallContextAsSystemBlock`. */
 declare function resolvePreCallMemory(input: ResolvePreCallContextInput): Promise<PreCallMemoryContext>;
 declare function formatMemoryContextAsSystemBlock(context: PreCallMemoryContext, maxBytes?: number): string;
 
-/**
- * Fails before a live session starts when the configured memory adapter cannot
- * provide the behavior the agent's policy promises. Memory adapters remain
- * pluggable; the adapter's instance-level declaration is the source of truth.
- */
 declare function assertMemoryPolicySupported(memory: Memory, policy: AgentMemoryPolicy): void;
 declare function assertMemoryCapability(memory: Memory, capability: "search.exact" | "write.explicit" | "write.implicit" | "write.sessionQuota" | "purge.perScope", operation: string): void;
 
@@ -3037,6 +3379,11 @@ interface SessionActivator {
         readonly agent: Agent;
         readonly attachment: SessionAttachment;
     }): Promise<void>;
+    deactivate?(input: {
+        readonly sessionId: SessionId;
+        readonly agent: Agent;
+        readonly attachment: SessionAttachment;
+    }): Promise<void>;
 }
 interface SessionRecoveryCoordinatorOptions {
     readonly runtime: Runtime;
@@ -3052,6 +3399,7 @@ interface SessionRecoveryCoordinatorOptions {
         readonly name: string;
         readonly value: number;
     }) => void;
+    readonly onError?: (error: unknown) => void;
 }
 interface RecoveryPollResult {
     readonly candidates: number;
@@ -3062,7 +3410,7 @@ declare class SessionRecoveryCoordinator {
     #private;
     constructor(options: SessionRecoveryCoordinatorOptions);
     start(): void;
-    stop(): Promise<void>;
+    stop(): Promise<boolean>;
     pollOnce(): Promise<RecoveryPollResult>;
 }
 interface SessionReaperOptions {
@@ -3078,12 +3426,13 @@ interface SessionReaperOptions {
         readonly name: string;
         readonly value: number;
     }) => void;
+    readonly onError?: (error: unknown) => void;
 }
 declare class SessionReaper {
     #private;
     constructor(options: SessionReaperOptions);
     start(): void;
-    stop(): Promise<void>;
+    stop(): Promise<boolean>;
     reapOnce(): Promise<number>;
 }
 
@@ -3107,25 +3456,11 @@ declare class ConversationPolicy {
     #private;
     constructor(options: ConversationPolicyOptions);
     hydrateTurns(turns: readonly Turn[]): void;
-    /**
-     * Set the session-level system instruction. Pre-call context and variables
-     * remain attached because the system message is rebuilt from canonical state.
-     */
     replaceSystemInstruction(instruction: string): void;
-    /**
-     * Set or clear a per-turn instruction. Clearing it restores the session-level
-     * instruction without losing the tenant variables or pre-call context.
-     */
     setTurnSystemInstruction(instruction: string | undefined): void;
-    /**
-     * Replace the static variables map. Values are substituted into `{{name}}`
-     * placeholders and also rendered in a dedicated block so the model can see
-     * variables that the base instruction did not reference explicitly.
-     */
     setStaticVariables(variables: ReadonlyMap<string, string>): void;
     acceptTranscript(event: TranscriptEvent): string | null;
     get hasBufferedTranscript(): boolean;
-    /** 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[], assistantToolCalls?: readonly LlmInlineToolCall[]): readonly LlmMessage[];
@@ -3137,13 +3472,9 @@ declare class ConversationPolicy {
 interface SttCommandController {
     /** Resolves only when this controller reaches a terminal state. */
     readonly failure: Promise<never>;
-    /** Admit audio without waiting for provider I/O. */
     admitAudio(chunk: InputAudioChunk): Promise<void>;
-    /** Admit an ordered barrier and settle it after provider command acceptance. */
     admitCommit(): Promise<void>;
-    /** Drain admitted commands in order and then close the stream. */
     drain(): Promise<void>;
-    /** Abandon queued work and close the stream immediately. */
     abort(error?: unknown): Promise<void>;
 }
 
@@ -3173,11 +3504,6 @@ interface SttReconnectOptions {
     readonly audioWriteTimeoutMs?: number;
     readonly closeTimeoutMs?: number;
 }
-/**
- * Wraps one STT provider with bounded, best-effort reconnect and replay policy.
- * The wrapper is deliberately runtime-owned: adapters only need to expose honest
- * transport and timestamp semantics.
- */
 declare function withSttReconnect(provider: SpeechToTextProvider, options?: SttReconnectOptions): SpeechToTextProvider;
 
 interface AssistantTextRecord {
@@ -3197,7 +3523,6 @@ interface TextDeliveryDecision {
     readonly hasTransport: boolean;
     readonly cancelledByBargeIn: boolean;
 }
-/** Decides whether participant-visible text should be attempted for a terminal turn. */
 declare function shouldDeliverText(decision: TextDeliveryDecision): boolean;
 declare function deliverAssistantText(options: {
     readonly callHandle: CallHandle;
@@ -3210,16 +3535,6 @@ declare function deliverAssistantText(options: {
     readonly timeoutMs?: number;
 }): Promise<boolean | undefined>;
 
-/**
- * Public-facing event emitted by a voice pipeline run. A discriminated
- * union of 8 kinds so consumers can `switch (event.kind)` without
- * runtime guessing.
- *
- * The shape is intentionally a *friendlier* view than the internal
- * `MediaEvent`. The runtime's `MediaEvent` includes IDs, sequence
- * numbers, and provider metadata; `VoiceEvent` strips those and exposes
- * the same data in a UX-friendly form.
- */
 type VoiceEvent = {
     readonly kind: "transcript_delta";
     readonly text: string;
@@ -3239,6 +3554,7 @@ type VoiceEvent = {
     readonly turnId: TurnId;
     readonly status: "completed" | "cancelled" | "failed";
     readonly latencyMs: number;
+    readonly delivery?: TurnOutputDelivery;
 } | {
     readonly kind: "tool_call";
     readonly toolCallId: ToolCallId;
@@ -3248,6 +3564,9 @@ type VoiceEvent = {
     readonly kind: "tool_result";
     readonly toolCallId: ToolCallId;
     readonly output: unknown;
+    readonly status: "succeeded" | "failed" | "timed_out" | "cancelled";
+    readonly error?: Pick<NormalizedError, "code" | "message">;
+    readonly recoveryPolicy?: "do_not_replay";
     readonly latencyMs: number;
 } | {
     readonly kind: "error";
@@ -3258,26 +3577,11 @@ type VoiceEvent = {
     readonly reason: "completed" | "cancelled" | "failed" | "remote_hangup";
     readonly totalTurns: number;
 };
-/**
- * The result of starting a `PipelineVoiceLoop`. Dual-protocol: awaits
- * 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>`
- * and `AsyncIterable<VoiceEvent>`. Awaiting and iterating are independent
- * — the run starts on the first await/iteration. Subsequent awaits share
- * the same promise. Iteration drains buffered events before completing.
- */
 interface DualProtocolResult extends PromiseLike<PipelineVoiceLoopResult> {
     then<TResult1 = PipelineVoiceLoopResult, TResult2 = never>(onfulfilled?: ((value: PipelineVoiceLoopResult) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): PromiseLike<PipelineVoiceLoopResult | TResult>;
     finally(onfinally?: (() => void) | null | undefined): PromiseLike<PipelineVoiceLoopResult>;
     [Symbol.asyncIterator](): AsyncIterator<VoiceEvent>;
-    /**
-     * The session ID this result is for. Exposed for consumer convenience
-     * (e.g., logging).
-     */
     readonly sessionId: SessionId;
 }
 /**
@@ -3305,12 +3609,6 @@ type PipelineVoiceLoopResultLike = PipelineVoiceLoopResult;
 declare class PipelineVoiceLoopBuilder {
     #private;
     constructor(loop: PipelineVoiceLoopLike, overrideSignal?: AbortSignal);
-    /**
-     * Attach an `AbortSignal` that cancels the run when triggered. Composed
-     * with `attachment.signal` (both fire to cancel; the lease-loss reason
-     * on the attachment is preserved). Throws if called twice on the same
-     * builder.
-     */
     abortSignal(signal: AbortSignal): this;
     then<TResult1 = PipelineVoiceLoopResultLike, TResult2 = never>(onfulfilled?: ((value: PipelineVoiceLoopResultLike) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): PromiseLike<PipelineVoiceLoopResultLike | TResult>;
@@ -3327,7 +3625,6 @@ 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;
 }
@@ -3351,7 +3648,6 @@ interface PipelineVoiceLoopOptions {
     readonly callHandle: CallHandle;
     readonly llmModel: string;
     readonly sttModel?: string;
-    /** Allows a custom/self-hosted STT endpoint to accept a model outside TVIC's dated catalog. */
     readonly sttAllowUnknownModel?: boolean;
     readonly sttReconnect?: boolean | SttReconnectOptions;
     readonly sttLanguage?: string;
@@ -3366,19 +3662,10 @@ interface PipelineVoiceLoopOptions {
     readonly preCallContext?: PreCallContext;
     readonly safetyIdentifier?: string;
     readonly textDelivery?: TextDeliveryMode;
-    /** Max ms a provider stream may stall (no events) before the turn fails. */
     readonly streamStallTimeoutMs?: number;
-    /** Inactivity debounce after the latest immutable final segment. */
     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
-     * ignored, and a throw from it is swallowed so an observer can never affect a call.
-     */
     readonly onTurnLatency?: (record: TurnLatencyRecord) => void;
     readonly onAssistantText?: (record: AssistantTextRecord) => void;
     readonly sessionMetricsRecorder?: SessionMetricsRecorder;
@@ -3390,45 +3677,21 @@ interface PipelineVoiceLoopResult {
     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.
- * This module owns only live execution and failure handling; telemetry belongs
- * outside the runtime's critical path.
- */
 declare class PipelineVoiceLoop {
     #private;
     constructor(options: PipelineVoiceLoopOptions);
-    /** Start a call and expose an awaitable, iterable result. */
     start(options?: {
         readonly overrideSignal?: AbortSignal;
     }): PipelineVoiceLoopBuilder;
-    /**
-     * Legacy: returns `Promise<PipelineVoiceLoopResult>`. Equivalent to
-     * `await this.start(options)`. Convenience wrapper preserved for backward
-     * compatibility with the v0.0.x API.
-     */
     run(options?: {
         readonly overrideSignal?: AbortSignal;
     }): Promise<PipelineVoiceLoopResult>;
-    /**
-     * Implementation hook for {@link PipelineVoiceLoopBuilder}. Returns a
-     * `DualProtocolResult` that wraps the run promise and event queue.
-     */
     _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;
 }
@@ -3509,43 +3772,35 @@ 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>>;
     readonly upgradeContext?: TContext;
 }
 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 NodeMediaPlaneRequestHandler = (request: IncomingMessage, response: ServerResponse, signal: AbortSignal) => boolean | Promise<boolean>;
+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 maxInboundFrameFragments?: number;
+    readonly webSocketCloseTimeoutMs?: number;
     readonly healthPath?: string;
-    /**
-     * Optional health check. Called when the plane's `healthPath` endpoint
-     * is hit. The plane responds 200 with `{ ok: true }` if the check
-     * returns `ok: true`, and 503 with the check details otherwise. This
-     * is where the runtime's `RuntimeOptions.healthCheck` plugs in so
-     * the load balancer can drain traffic before a replica's Postgres
-     * becomes unreachable. See `docs/operations/multi-replica.md`.
-     */
-    readonly healthCheck?: () => Promise<{
+    readonly healthCheck?: (signal: AbortSignal) => Promise<{
         readonly ok: boolean;
         readonly checks?: Readonly<Record<string, unknown>>;
     }>;
     readonly onConnection: NodeMediaPlaneConnectionHandler<TContext>;
-    /** Handle non-WebSocket HTTP requests (e.g. the Twilio TwiML webhook). Return true if handled. */
     readonly onRequest?: NodeMediaPlaneRequestHandler;
-    /** Routes failures from an async onConnection handler. Defaults to closing the socket. */
     readonly onConnectionError?: NodeMediaPlaneConnectionErrorHandler;
-    /** Synchronous, pre-handshake authorization. Throwing rejects with HTTP 500. */
-    readonly authorizeUpgrade?: (request: IncomingMessage, url: URL, params: Readonly<Record<string, string>>) => UpgradeAuthorization<TContext>;
-    /** Releases state reserved by a successful authorization if the handshake aborts. */
-    readonly onUpgradeAborted?: (context: TContext) => void;
+    readonly authorizeUpgrade?: (request: IncomingMessage, url: URL, params: Readonly<Record<string, string>>, signal: AbortSignal) => UpgradeAuthorization<TContext> | PromiseLike<UpgradeAuthorization<TContext>>;
+    readonly authorizationTimeoutMs?: number;
+    readonly maxPendingAuthorizations?: number;
+    readonly onUpgradeAborted?: (context: TContext) => void | PromiseLike<void>;
+    readonly onUpgradeAbortedError?: (error: unknown, context: TContext) => void | PromiseLike<void>;
 }
 declare class NodeMediaPlane<TContext = unknown> {
     #private;
@@ -3579,17 +3834,21 @@ 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;
     readonly model?: string;
-    /** Allows a custom OpenAI-compatible endpoint to use a model outside TVIC's dated catalog. */
     readonly allowUnknownModel?: boolean;
 };
 type GroqProviderConfig = Omit<GroqChatLlmProviderOptions, "apiKey"> & {
@@ -3605,13 +3864,33 @@ type CartesiaProviderConfig = Omit<CartesiaTtsProviderOptions, "apiKey" | "voice
     readonly model?: string;
     readonly voiceId?: string;
 };
-type ElevenLabsTtsProviderConfig = Omit<ElevenLabsTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
+type ElevenLabsTtsProviderConfig = (Omit<ElevenLabsTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
     readonly provider: "elevenlabs";
+    readonly transport?: "websocket";
     readonly apiKey?: string;
     readonly model?: string;
     readonly voiceId?: string;
-};
-type TtsProviderConfig = CartesiaProviderConfig | ElevenLabsTtsProviderConfig;
+}) | (Omit<ElevenLabsHttpTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
+    readonly provider: "elevenlabs";
+    readonly transport: "rest" | "http-stream";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+});
+type SarvamTtsProviderConfig = (Omit<SarvamTtsProviderOptions, "apiKey" | "modelId" | "voiceId"> & {
+    readonly provider: "sarvam";
+    readonly transport?: "websocket";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+}) | (Omit<SarvamTtsHttpProviderOptions, "apiKey" | "modelId" | "voiceId"> & {
+    readonly provider: "sarvam";
+    readonly transport: "rest" | "http-stream";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+});
+type TtsProviderConfig = CartesiaProviderConfig | ElevenLabsTtsProviderConfig | SarvamTtsProviderConfig;
 type TelephonyProviderConfig = {
     readonly provider: "web-client-audio";
     readonly options?: WebClientAudioProviderOptions;
@@ -3637,7 +3916,6 @@ interface CreateVoiceAgentOptions {
     readonly version?: string;
     readonly providers: VoiceAgentProviders;
     readonly models?: VoiceAgentModels;
-    /** Tool generics are intentionally erased at the heterogeneous agent boundary. */
     readonly tools?: readonly ToolDefinition<any, any>[];
     readonly audio?: Partial<AgentAudioPolicy>;
     readonly memoryPolicy?: AgentMemoryPolicy;
@@ -3646,13 +3924,7 @@ interface CreateVoiceAgentOptions {
     readonly runtime?: RuntimeOptions;
 }
 interface VoiceAgentRunOptions {
-    /**
-     * A handle created by a stable TVIC transport adapter or a custom adapter.
-     * A factory is useful for transports whose events must be stamped with the
-     * runtime-created session id; it runs after the session is created.
-     */
     readonly callHandle: CallHandle | VoiceAgentCallHandleFactory;
-    /** Optional complete call record. A safe inbound record is synthesized when omitted. */
     readonly call?: Call;
     readonly channel?: ChannelKind;
     readonly variables?: Readonly<Record<string, unknown>>;
@@ -3661,7 +3933,6 @@ 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;
@@ -3673,10 +3944,8 @@ interface VoiceAgentRunOptions {
 }
 interface VoiceAgentCallHandleContext {
     readonly sessionId: SessionId;
-    /** 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>;
@@ -3686,6 +3955,11 @@ interface VoiceAgentSession {
     readonly sessionId: SessionId;
     readonly run: VoiceAgentRun;
 }
+interface ManagedVoiceAgentSession extends VoiceAgentSession {
+    readonly finalSession: Promise<TerminalSession>;
+    complete(): Promise<TerminalSession>;
+    stop(): Promise<void>;
+}
 interface VoiceAgentProviderNames {
     readonly telephony: string;
     readonly stt: string;
@@ -3702,7 +3976,10 @@ interface VoiceAgent {
     stop(): Promise<void>;
     healthCheck(): Promise<HealthSnapshot>;
 }
-declare function createVoiceAgent(options: CreateVoiceAgentOptions): VoiceAgent;
+interface VoiceAgentWithSessionLifecycle extends VoiceAgent {
+    start(options: VoiceAgentRunOptions): Promise<ManagedVoiceAgentSession>;
+}
+declare function createVoiceAgent(options: CreateVoiceAgentOptions): VoiceAgentWithSessionLifecycle;
 
 declare class InMemorySessionStore implements SessionStore {
     #private;
@@ -3711,7 +3988,6 @@ declare class InMemorySessionStore implements SessionStore {
     put(record: StoredSessionRecord): Promise<void>;
     update(id: SessionId, updater: (record: StoredSessionRecord) => StoredSessionRecord): Promise<StoredSessionRecord>;
     close(): Promise<void>;
-    /** Internal aggregate-transaction rollback hook. */
     restore(id: SessionId, record: StoredSessionRecord | null): void;
 }
 declare function createInMemorySessionStore(): InMemorySessionStore;
@@ -3722,7 +3998,6 @@ declare class InMemoryTurnStore implements TurnStore {
     put(record: StoredTurnRecord): Promise<void>;
     update(sessionId: SessionId, id: TurnId, updater: (record: StoredTurnRecord) => StoredTurnRecord): Promise<StoredTurnRecord>;
     close(): Promise<void>;
-    /** Internal aggregate-transaction rollback hook. */
     restore(sessionId: SessionId, records: readonly StoredTurnRecord[]): void;
 }
 declare function createInMemoryTurnStore(): InMemoryTurnStore;
@@ -3733,7 +4008,6 @@ declare class InMemoryToolCallStore implements ToolCallStore {
     put(record: StoredToolCallRecord): Promise<void>;
     update(sessionId: SessionId, id: ToolCallId, updater: (record: StoredToolCallRecord) => StoredToolCallRecord): Promise<StoredToolCallRecord>;
     close(): Promise<void>;
-    /** Internal aggregate-transaction rollback hook. */
     restore(sessionId: SessionId, records: readonly StoredToolCallRecord[]): void;
 }
 declare function createInMemoryToolCallStore(): InMemoryToolCallStore;
@@ -3741,33 +4015,28 @@ declare class InMemorySessionLeaseStore implements SessionLeaseStore {
     #private;
     constructor(now?: () => number);
     acquire(sessionId: SessionId, holder: string, ttlMs: number): Promise<SessionLease | null>;
-    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number): Promise<SessionLease | null>;
-    release(sessionId: SessionId, holder: string, fence: number): Promise<void>;
+    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number, generationId: string): Promise<SessionLease | null>;
+    release(sessionId: SessionId, holder: string, fence: number, generationId: string): Promise<void>;
+    getCurrent(sessionId: SessionId): SessionLease | null;
     get(sessionId: SessionId): Promise<SessionLease | null>;
     listRecoveryCandidates(options: {
         readonly nowMs: number;
         readonly limit: number;
         readonly cursor?: string;
     }): Promise<{
-        readonly sessionIds: readonly SessionId[];
+        readonly candidates: readonly SessionRecoveryCandidate[];
         readonly nextCursor?: string;
     }>;
+    acknowledgeRecoveryCandidate(candidate: SessionRecoveryCandidate): Promise<void>;
     close(): Promise<void>;
 }
 
 interface InMemoryDurableRuntimeStore extends DurableRuntimeStore {
     readonly outbox: readonly DurableOutboxEvent[];
+    currentLease(sessionId: SessionId): SessionLease | null;
 }
 interface InMemoryDurableRuntimeStoreOptions {
     readonly nowMs?: () => number;
-    /**
-     * Legacy stores can be supplied while callers migrate to DurableRuntimeStore.
-     * The aggregate transaction facade serializes access to them and uses the
-     * optional internal restore hooks when the store provides one. Custom stores
-     * without those hooks receive ordering isolation but cannot receive a full
-     * rollback guarantee; production adapters should implement DurableRuntimeStore
-     * directly when atomicity is required.
-     */
     readonly sessionStore?: SessionStore;
     readonly turnStore?: TurnStore;
     readonly toolCallStore?: ToolCallStore;
@@ -3795,78 +4064,57 @@ declare class InMemoryMemory implements Memory {
 }
 declare function createInMemoryMemory(options?: InMemoryMemoryOptions): InMemoryMemory;
 
+declare function idempotencyKeyFor<TInput, TOutput>(input: ExecuteToolInput<TInput, TOutput>): string | null;
+declare function idempotencyRequestHashFor<TInput, TOutput>(input: ExecuteToolInput<TInput, TOutput>): string;
+
 declare function stableStringify(value: unknown): string;
 
 interface SchemaValidationResult {
     readonly valid: boolean;
     readonly errors: readonly string[];
 }
-/**
- * Validates a value against a deliberately small, well-defined subset of JSON Schema
- * (Draft-07 keywords): `type` (incl. "integer"), `enum`, `const`, object
- * `properties` / `required` / `additionalProperties: false`, array `items` /
- * `minItems` / `maxItems`, string `minLength` / `maxLength`, and numeric `minimum` /
- * `maximum`. It is intentionally NOT a full validator: unsupported keywords are
- * ignored. Swap in Ajv at the call site if full JSON Schema compliance is required.
- */
 declare function validateJsonSchemaSubset(value: unknown, schema: Readonly<Record<string, unknown>>, path?: string): SchemaValidationResult;
 
+type InMemoryLeaseSnapshot = {
+    readonly holder: string;
+    readonly fence: number;
+    readonly generationId: string;
+    readonly expiresAtMs: number;
+};
+declare class InMemoryToolIdempotencyStore implements ToolIdempotencyStore {
+    #private;
+    constructor(now?: () => number, readLeaseSnapshot?: (sessionId: SessionId) => InMemoryLeaseSnapshot | null);
+    pruneExpired(): number;
+    lookup(key: string, requestHash: string, sessionId?: SessionId, lease?: ToolIdempotencyLease): Promise<ToolIdempotencyLookupResult>;
+    claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
+    releaseClaim(input: ToolIdempotencyRelease): Promise<boolean>;
+    complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
+    quarantine(input: ToolIdempotencyQuarantine): Promise<ToolIdempotencyQuarantineResult>;
+}
+
 interface ToolRegistry {
     register(tool: ToolDefinition): void;
     get(id: ToolId): ToolDefinition | null;
     list(): readonly ToolDefinition[];
 }
 declare function createToolRegistry(tools?: readonly ToolDefinition[]): ToolRegistry;
-declare class InMemoryToolIdempotencyStore implements ToolIdempotencyStore {
-    #private;
-    constructor(now?: () => number, readLease?: (sessionId: SessionId) => Promise<{
-        readonly holder: string;
-        readonly fence: number;
-        readonly expiresAtMs: number;
-    } | null>);
-    lookup(key: string, requestHash: string): Promise<ToolIdempotencyRecord | null>;
-    claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
-    complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
-}
+
 interface ExecuteToolInput<TInput, TOutput> {
     readonly tool: ToolDefinition<TInput, TOutput>;
     readonly input: TInput;
     readonly sessionId: SessionId;
     readonly turnId: TurnId;
     readonly toolCallId: ToolCallId;
-    /** Reuses the durable queue timestamp when the runtime has already persisted the call. */
     readonly queuedAt?: Timestamp;
     readonly attempt?: number;
     readonly logger?: ToolLogger;
     readonly now?: () => Date;
-    /** Aborts the tool call (e.g. on barge-in). The tool's ctx.signal mirrors this. */
     readonly signal?: AbortSignal;
-    /** Current process lease used to fence durable idempotency operations. */
     readonly lease?: ToolIdempotencyLease;
-    /** Honours the tool's idempotency policy when provided. */
     readonly idempotencyStore?: ToolIdempotencyStore;
-    /**
-     * Tenant identity propagated into the tool's `ctx.tenant`. The runtime
-     * populates this from the session attachment's `memoryUserId` /
-     * `organizationId` / `workflowId` so the tool can enforce its own
-     * auth/RBAC. TVIC ships no auth layer; the tool author reads
-     * `ctx.tenant` and decides.
-     */
     readonly tenant?: ToolTenant;
 }
-/**
- * Performs the input checks that must complete before a tool call reaches a
- * durable store. Keeping this at the tools boundary lets the runtime reject
- * provider-produced values before it creates queued/running records.
- */
 declare function toolInputError(value: unknown, schema: Readonly<Record<string, unknown>>): NormalizedError | null;
-declare function idempotencyKeyFor<TInput, TOutput>(input: ExecuteToolInput<TInput, TOutput>): string | null;
-/**
- * The request hash paired with idempotencyKeyFor. Keep this beside the key
- * builder so execution and crash recovery cannot silently hash different
- * request shapes.
- */
-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 {
@@ -3884,9 +4132,31 @@ declare class PostgresToolIdempotencyStore implements ToolIdempotencyStore {
     constructor(client: SqlClient$1, options?: {
         readonly onCompatibilityDiagnostic?: (diagnostic: PersistedErrorCompatibilityDiagnostic) => void;
     });
-    lookup(key: string, requestHash: string): Promise<ToolIdempotencyRecord | null>;
+    lookup(key: string, requestHash: string, sessionId?: SessionId, lease?: NonNullable<ToolIdempotencyClaim["lease"]>): Promise<ToolIdempotencyLookupResult>;
     claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
+    releaseClaim(input: ToolIdempotencyRelease): Promise<boolean>;
     complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
+    quarantine(input: ToolIdempotencyQuarantine): Promise<ToolIdempotencyQuarantineResult>;
+}
+
+declare class PostgresSessionLeaseStore implements SessionLeaseStore {
+    readonly client: SqlPool$1;
+    constructor(client: SqlPool$1);
+    acquire(sessionId: SessionId, holder: string, ttlMs: number): Promise<SessionLease | null>;
+    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number, generationId: string): Promise<SessionLease | null>;
+    release(sessionId: SessionId, holder: string, fence: number, generationId: string): Promise<void>;
+    get(sessionId: SessionId): Promise<SessionLease | null>;
+    listRecoveryCandidates(options: {
+        readonly nowMs: number;
+        readonly limit: number;
+        readonly cursor?: string;
+    }): Promise<{
+        readonly candidates: readonly SessionRecoveryCandidate[];
+        readonly corruptLeaseSessionIds?: readonly SessionId[];
+        readonly nextCursor?: string;
+    }>;
+    acknowledgeRecoveryCandidate(candidate: SessionRecoveryCandidate): Promise<void>;
+    close(): Promise<void>;
 }
 
 interface PostgresOutboxWorkerOptions {
@@ -3901,12 +4171,37 @@ interface PostgresOutboxWorkerOptions {
     }) => void;
 }
 
+interface PostgresRetentionSessionIdentity {
+    readonly sessionId: string;
+    readonly incarnation: number | string;
+    readonly version: number | string;
+    readonly fence: number | string;
+}
+interface PostgresRetentionJobOptions {
+    readonly pool: SqlPool$1;
+    readonly terminalRetentionMs: number;
+    readonly outboxRetentionMs?: number;
+    readonly hasLegalHold: (sessionId: string) => Promise<boolean>;
+    readonly archive?: (sessionId: string) => Promise<void>;
+    readonly beforeSessionDelete?: (candidate: PostgresRetentionSessionIdentity, purgeToken: string) => Promise<void>;
+    readonly afterSessionDeleteFailure?: (candidate: PostgresRetentionSessionIdentity, purgeToken: string) => Promise<void>;
+}
+interface RetentionRunResult {
+    readonly sessionsDeleted: number;
+    readonly outboxDeleted: number;
+    readonly idempotencyDeleted: number;
+}
+declare class PostgresRetentionJob {
+    #private;
+    constructor(options: PostgresRetentionJobOptions);
+    runOnce(): Promise<RetentionRunResult>;
+}
+
 interface PostgresMigration$1 {
     readonly version: number;
     readonly name: string;
     readonly sql: string;
 }
-/** Runs the ordered SQL files exactly once and records the applied filename. */
 declare function runPostgresMigrations(pool: SqlPool$1, migrations?: readonly PostgresMigration$1[]): Promise<readonly number[]>;
 
 interface SqlResult<Row extends Record<string, unknown> = Record<string, unknown>> {
@@ -3920,9 +4215,12 @@ interface SqlPool$1 extends SqlClient$1 {
     connect(): Promise<SqlClient$1 & {
         readonly release: () => void;
     }>;
-    /** If provided, the durable store owns this pool and calls it once on close. */
     end?(): Promise<void>;
 }
+interface PostgresSessionChildPage<RecordType> {
+    readonly records: readonly RecordType[];
+    readonly nextCursor: string | undefined;
+}
 interface PostgresDurableStoreOptions {
     readonly pool: SqlPool$1;
 }
@@ -3940,6 +4238,7 @@ declare class PostgresTurnStore implements TurnStore {
     constructor(client: SqlClient$1);
     get(sessionId: SessionId, id: TurnId): Promise<StoredTurnRecord | null>;
     listBySession(sessionId: SessionId): Promise<readonly StoredTurnRecord[]>;
+    listBySessionPage(sessionId: SessionId, afterId?: string, pageSize?: number): Promise<PostgresSessionChildPage<StoredTurnRecord>>;
     put(record: StoredTurnRecord): Promise<void>;
     update(sessionId: SessionId, id: TurnId, updater: (record: StoredTurnRecord) => StoredTurnRecord): Promise<StoredTurnRecord>;
     close(): Promise<void>;
@@ -3949,27 +4248,11 @@ declare class PostgresToolCallStore implements ToolCallStore {
     constructor(client: SqlClient$1);
     get(sessionId: SessionId, id: ToolCallId): Promise<StoredToolCallRecord | null>;
     listBySession(sessionId: SessionId): Promise<readonly StoredToolCallRecord[]>;
+    listBySessionPage(sessionId: SessionId, afterId?: string, pageSize?: number): Promise<PostgresSessionChildPage<StoredToolCallRecord>>;
     put(record: StoredToolCallRecord): Promise<void>;
     update(sessionId: SessionId, id: ToolCallId, updater: (record: StoredToolCallRecord) => StoredToolCallRecord): Promise<StoredToolCallRecord>;
     close(): Promise<void>;
 }
-declare class PostgresSessionLeaseStore implements SessionLeaseStore {
-    readonly client: SqlPool$1;
-    constructor(client: SqlPool$1);
-    acquire(sessionId: SessionId, holder: string, ttlMs: number): Promise<SessionLease | null>;
-    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number): Promise<SessionLease | null>;
-    release(sessionId: SessionId, holder: string, fence: number): Promise<void>;
-    get(sessionId: SessionId): Promise<SessionLease | null>;
-    listRecoveryCandidates(options: {
-        readonly nowMs: number;
-        readonly limit: number;
-        readonly cursor?: string;
-    }): Promise<{
-        readonly sessionIds: readonly SessionId[];
-        readonly nextCursor?: string;
-    }>;
-    close(): Promise<void>;
-}
 declare class PostgresDurableRuntimeStore implements DurableRuntimeStore {
     #private;
     readonly pool: SqlPool$1;
@@ -3980,7 +4263,7 @@ declare class PostgresDurableRuntimeStore implements DurableRuntimeStore {
     readonly toolIdempotencyStore: PostgresToolIdempotencyStore;
     constructor(pool: SqlPool$1);
     createSessionWithLease(record: StoredSessionRecord, holder: string, ttlMs: number, initialEvent?: (lease: SessionLease) => DurableOutboxEvent): Promise<SessionLease | null>;
-    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
+    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence" | "generationId">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
     runUnfencedSessionTransaction<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
     close(): Promise<void>;
 }
@@ -3990,23 +4273,70 @@ declare class RedisToolIdempotencyStore implements ToolIdempotencyStore {
     #private;
     readonly client: RedisClient;
     constructor(client: RedisClient, options?: RedisStoreOptions);
-    lookup(key: string, _requestHash: string): Promise<ToolIdempotencyRecord | null>;
+    lookup(key: string, requestHash: string, sessionId?: SessionId, lease?: ToolIdempotencyClaim["lease"]): Promise<ToolIdempotencyLookupResult>;
     claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
+    releaseClaim(input: ToolIdempotencyRelease): Promise<boolean>;
     complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
+    quarantine(input: ToolIdempotencyQuarantine): Promise<ToolIdempotencyQuarantineResult>;
+    pruneExpiredIdempotencyPage(cursor?: string, limit?: number): Promise<{
+        readonly cursor: string;
+        readonly scanned: number;
+        readonly deleted: number;
+    }>;
 }
 
-/**
- * Applies Postgres outbox events to Redis as a version/fence guarded cache.
- * Redis is intentionally not a second runtime authority: a cache event can be
- * replayed, duplicated, or delivered out of order without replacing a newer
- * value. Postgres remains the source of truth and the outbox worker supplies
- * the retry boundary.
- */
+declare class RedisSessionStore implements SessionStore {
+    readonly client: RedisClient;
+    readonly options: RedisStoreOptions;
+    constructor(client: RedisClient, options?: RedisStoreOptions);
+    get(id: SessionId): Promise<StoredSessionRecord | null>;
+    list(): Promise<readonly StoredSessionRecord[]>;
+    put(record: StoredSessionRecord): Promise<void>;
+    update(id: SessionId, updater: (record: StoredSessionRecord) => StoredSessionRecord): Promise<StoredSessionRecord>;
+    close(): Promise<void>;
+}
+declare class RedisTurnStore implements TurnStore {
+    readonly client: RedisClient;
+    readonly options: RedisStoreOptions;
+    constructor(client: RedisClient, options?: RedisStoreOptions);
+    get(sessionId: SessionId, id: TurnId): Promise<StoredTurnRecord | null>;
+    listBySession(sessionId: SessionId): Promise<readonly StoredTurnRecord[]>;
+    put(record: StoredTurnRecord): Promise<void>;
+    update(sessionId: SessionId, id: TurnId, updater: (record: StoredTurnRecord) => StoredTurnRecord): Promise<StoredTurnRecord>;
+    close(): Promise<void>;
+}
+declare class RedisToolCallStore implements ToolCallStore {
+    readonly client: RedisClient;
+    readonly options: RedisStoreOptions;
+    constructor(client: RedisClient, options?: RedisStoreOptions);
+    get(sessionId: SessionId, id: ToolCallId): Promise<StoredToolCallRecord | null>;
+    listBySession(sessionId: SessionId): Promise<readonly StoredToolCallRecord[]>;
+    put(record: StoredToolCallRecord): Promise<void>;
+    update(sessionId: SessionId, id: ToolCallId, updater: (record: StoredToolCallRecord) => StoredToolCallRecord): Promise<StoredToolCallRecord>;
+    close(): Promise<void>;
+}
+
+interface ProjectedSessionRetentionIdentity {
+    readonly sessionId: SessionId;
+    readonly incarnation: number | string;
+    readonly version: number | string;
+    readonly fence: number | string;
+}
+interface ProjectedSessionCacheSnapshot {
+    readonly session: StoredSessionRecord;
+    readonly turns: Iterable<StoredTurnRecord> | AsyncIterable<StoredTurnRecord>;
+    readonly toolCalls: Iterable<StoredToolCallRecord> | AsyncIterable<StoredToolCallRecord>;
+}
 declare class RedisOutboxCacheProjector {
+    #private;
     readonly client: RedisClient;
     readonly options: RedisStoreOptions;
     constructor(client: RedisClient, options?: RedisStoreOptions);
     apply(event: DurableOutboxEvent): Promise<void>;
+    purgeSession(identity: ProjectedSessionRetentionIdentity, purgeToken: string): Promise<void>;
+    resumeSessionPurge(identity: ProjectedSessionRetentionIdentity, purgeToken: string): Promise<boolean>;
+    getSessionPurgeToken(identity: Pick<ProjectedSessionRetentionIdentity, "sessionId" | "incarnation">): Promise<string | null>;
+    restoreSessionProjection(identity: ProjectedSessionRetentionIdentity, purgeToken: string, snapshot: ProjectedSessionCacheSnapshot): Promise<void>;
 }
 
 type RedisSetResult = "OK" | "ok" | boolean | null;
@@ -4018,6 +4348,7 @@ interface RedisClient {
     get(key: string): Promise<string | null>;
     set(key: string, value: string, options?: {
         readonly NX?: boolean;
+        readonly PX?: number;
     }): Promise<RedisSetResult>;
     del(...keys: readonly string[]): Promise<number>;
     eval(script: string, keys: readonly string[], args: readonly string[]): Promise<unknown>;
@@ -4031,7 +4362,9 @@ interface RedisClient {
     quit?(): Promise<void>;
 }
 interface RedisMulti {
-    set(key: string, value: string): RedisMulti;
+    set(key: string, value: string, options?: {
+        readonly PX?: number;
+    }): RedisMulti;
     del(...keys: readonly string[]): RedisMulti;
     exec(): Promise<readonly unknown[] | null>;
 }
@@ -4043,52 +4376,24 @@ interface RedisStoreOptions {
     readonly onCompatibilityDiagnostic?: (diagnostic: PersistedErrorCompatibilityDiagnostic) => void;
 }
 
-declare class RedisSessionStore implements SessionStore {
-    readonly client: RedisClient;
-    readonly options: RedisStoreOptions;
-    constructor(client: RedisClient, options?: RedisStoreOptions);
-    get(id: SessionId): Promise<StoredSessionRecord | null>;
-    list(): Promise<readonly StoredSessionRecord[]>;
-    put(record: StoredSessionRecord): Promise<void>;
-    update(id: SessionId, updater: (record: StoredSessionRecord) => StoredSessionRecord): Promise<StoredSessionRecord>;
-    close(): Promise<void>;
-}
-declare class RedisTurnStore implements TurnStore {
-    readonly client: RedisClient;
-    readonly options: RedisStoreOptions;
-    constructor(client: RedisClient, options?: RedisStoreOptions);
-    get(sessionId: SessionId, id: TurnId): Promise<StoredTurnRecord | null>;
-    listBySession(sessionId: SessionId): Promise<readonly StoredTurnRecord[]>;
-    put(record: StoredTurnRecord): Promise<void>;
-    update(sessionId: SessionId, id: TurnId, updater: (record: StoredTurnRecord) => StoredTurnRecord): Promise<StoredTurnRecord>;
-    close(): Promise<void>;
-}
-declare class RedisToolCallStore implements ToolCallStore {
-    readonly client: RedisClient;
-    readonly options: RedisStoreOptions;
-    constructor(client: RedisClient, options?: RedisStoreOptions);
-    get(sessionId: SessionId, id: ToolCallId): Promise<StoredToolCallRecord | null>;
-    listBySession(sessionId: SessionId): Promise<readonly StoredToolCallRecord[]>;
-    put(record: StoredToolCallRecord): Promise<void>;
-    update(sessionId: SessionId, id: ToolCallId, updater: (record: StoredToolCallRecord) => StoredToolCallRecord): Promise<StoredToolCallRecord>;
-    close(): Promise<void>;
-}
 declare class RedisSessionLeaseStore implements SessionLeaseStore {
     #private;
     readonly client: RedisClient;
     constructor(client: RedisClient, options?: RedisStoreOptions);
     acquire(sessionId: SessionId, holder: string, ttlMs: number): Promise<SessionLease | null>;
-    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number): Promise<SessionLease | null>;
-    release(sessionId: SessionId, holder: string, fence: number): Promise<void>;
+    renew(sessionId: SessionId, holder: string, fence: number, ttlMs: number, generationId: string): Promise<SessionLease | null>;
+    release(sessionId: SessionId, holder: string, fence: number, generationId: string): Promise<void>;
     get(sessionId: SessionId): Promise<SessionLease | null>;
     listRecoveryCandidates(options: {
         readonly nowMs: number;
         readonly limit: number;
         readonly cursor?: string;
     }): Promise<{
-        readonly sessionIds: readonly SessionId[];
+        readonly candidates: readonly SessionRecoveryCandidate[];
+        readonly corruptLeaseSessionIds?: readonly SessionId[];
         readonly nextCursor?: string;
     }>;
+    acknowledgeRecoveryCandidate(candidate: SessionRecoveryCandidate): Promise<void>;
     close(): Promise<void>;
 }
 declare class RedisDurableRuntimeStore implements DurableRuntimeStore {
@@ -4100,7 +4405,7 @@ declare class RedisDurableRuntimeStore implements DurableRuntimeStore {
     readonly toolIdempotencyStore: RedisToolIdempotencyStore;
     constructor(client: RedisClient, options?: RedisStoreOptions);
     createSessionWithLease(record: StoredSessionRecord, holder: string, ttlMs: number, initialEvent?: (lease: SessionLease) => DurableOutboxEvent): Promise<SessionLease | null>;
-    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
+    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence" | "generationId">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
     runUnfencedSessionTransaction<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
     close(): Promise<void>;
 }
@@ -4111,12 +4416,6 @@ interface PostgresRedisDurableStoreOptions {
     readonly redis: RedisClient;
     readonly redisOptions?: RedisStoreOptions;
 }
-/**
- * The production composition: PostgreSQL owns all mutations, leases,
- * idempotency, and reads; the outbox asynchronously projects committed
- * envelopes into Redis. A Redis outage therefore cannot turn a committed
- * runtime mutation into a failed domain operation.
- */
 declare class PostgresRedisDurableRuntimeStore implements DurableRuntimeStore {
     #private;
     readonly primary: PostgresDurableRuntimeStore;
@@ -4128,9 +4427,10 @@ declare class PostgresRedisDurableRuntimeStore implements DurableRuntimeStore {
     readonly toolIdempotencyStore: ToolIdempotencyStore;
     constructor(options: PostgresRedisDurableStoreOptions);
     createSessionWithLease(record: StoredSessionRecord, holder: string, ttlMs: number, initialEvent?: (lease: SessionLease) => DurableOutboxEvent): Promise<SessionLease | null>;
-    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
+    runSessionTransaction<T>(sessionId: SessionId, lease: Pick<SessionLease, "holder" | "fence" | "generationId">, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
     runUnfencedSessionTransaction<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
     startOutboxWorker(options: Omit<PostgresOutboxWorkerOptions, "pool" | "deliver">): void;
+    createRetentionJob(options: Omit<PostgresRetentionJobOptions, "pool">): PostgresRetentionJob;
     stopOutboxWorker(): Promise<void>;
     close(): Promise<void>;
 }
@@ -4186,5 +4486,5 @@ declare class PostgresMemory implements Memory {
 }
 declare function createPostgresMemory(options: PostgresMemoryOptions): PostgresMemory;
 
-export { ADAPTER_DEFAULTS, AssemblyAiSttProvider, AsyncQueue, AsyncQueueConsumerError, BackendUnavailableError, CartesiaTtsProvider, ConversationPolicy, CorruptRecordError, DEFAULT_DURABLE_RUNTIME_POLICY, DTMF_DIGITS, DeepgramSttProvider, DurableError, EVENT_KIND_MAP, ElevenLabsSttProvider, ElevenLabsTtsProvider, InMemoryMemory, InMemorySessionLeaseStore, InMemorySessionStore, InMemoryToolCallStore, InMemoryToolIdempotencyStore, InMemoryTurnStore, InvalidArgumentError, LeaseLostError, LeaseUnavailableError, MemoryBackendUnavailableError, MemoryEntryTooLargeError, MemorySessionQuotaExceededError, NodeMediaPlane, PCM16_16K_MONO, PCM16_8K_MONO, PROVIDER_API_VERSIONS, PROVIDER_CATALOG, PROVIDER_ERROR_CODES, PROVIDER_NAMES, PROVIDER_STABILITY, PipelineVoiceLoop, PipelineVoiceLoopBuilder, RUNTIME_SAMPLE_RATE_HZ, RecordConflictError, RecordNotFoundError, STT_ERROR_CODES, STT_STREAM_ENDED_REASON, SarvamSttProvider, SessionReaper, SessionRecoveryCoordinator, SonioxSttProvider, TELEPHONY_SAMPLE_RATE_HZ, TVIC_ERROR_CODES, TVIC_ERROR_CODE_ALIASES, TVIC_ERROR_MARKER, TVIC_ERROR_NAMES, TvicThrowableError, TwilioMediaStreamCallHandle, TwilioMediaStreamsProvider, VoiceRuntimeFinalizationError, WEB_CLIENT_AUDIO_CLOSE_CODES, WEB_CLIENT_AUDIO_DEFAULTS, WebClientAudioCallHandle, WebClientAudioProvider, assertMemoryCapability, assertMemoryPolicySupported, assertPcm16leFormat, authError, base64ToBytes, bytesToBase64, cancelledError, canonicalizeTwilioData, computeTwilioSignature, connectionError, counterIdGenerator, createAssemblyAiSttProvider, createAudioNormalizer, createCartesiaTtsProvider, createDeepgramSttProvider, createDefaultIdGenerator, createElevenLabsSttProvider, createElevenLabsTtsProvider, createGroqChatLlmProvider, createInMemoryDurableRuntimeStore, createInMemoryMemory, createInMemorySessionStore, createInMemoryToolCallStore, createInMemoryTurnStore, createMediaEvent, createNodeMediaPlane, createOpenAiResponsesLlmProvider, createPostgresDurableRuntimeStore, createPostgresMemory, createPostgresRedisDurableRuntimeStore, createRedisDurableRuntimeStore, createRuntime, createSarvamSttProvider, createSonioxSttProvider, createSttSession, createSystemClock, createToolRegistry, createTwilioMediaStreamsProvider, createVoiceAgent, createWebClientAudioProvider, defineAgent, defineTool, deliverAssistantText, durationMsForPcm16le, evaluateProviderCompatibility, executeTool, formatMemoryContextAsSystemBlock, formatPreCallContextAsSystemBlock, frameCountForPcm16le, getSttRecoveryControl, idempotencyKeyFor, idempotencyRequestHashFor, internalError, interruptedError, isDtmfDigit, isIncrementalTextToSpeechProvider, isInputMediaEvent, isNormalizedError, isOutputMediaEvent, isProviderKind, isReconstructableAudioFormat, isSampleRateHz, isTerminalSession, isTerminalTurn, isTranscriptSegmentEvent, isTvicError, isTvicErrorName, kindForMediaEvent, matchPath, mediaError, monotonicOffsetMs, mulawToPcm16le, normalizeLegacyError, normalizeUnknownError, normalizedError, nowTimestamp, pcm16leToMulaw, providerError, rateLimitError, requireProviderKind, resamplePcm16le, resolvePreCallContext, resolvePreCallMemory, runPostgresMemoryMigrations, runPostgresMigrations, sameAudioFormat, shouldDeliverText, signVoiceSessionToken, signatureError, splitPcm16leFrames, stableStringify, supportsAudioFormat, supportsLanguage, supportsModel, terminalSessionFromRequest, terminalSourceForRequest, terminalTurnFromRequest, timeoutError, toTimestamp, toolError, toolInputError, tvicErrorFromJSON, unknownErrorMessage, validateJsonSchemaSubset, validationError, verifyTwilioSignature, verifyVoiceSessionToken, withSttReconnect };
-export type { ActiveSession, ActiveTurn, Agent, AgentAudioPolicy, AgentContextPolicy, AgentId, AgentMemoryPolicy, AgentProviders, AnyMediaEventInit, AssemblyAiProviderConfig, AssemblyAiSttProviderOptions, AssistantTextRecord, AudioFormat, AudioNormalizationMode, AudioNormalizer, AudioNormalizerOptions, AudioPayload, BackoffStrategy, Brand, Call, CallControlCapability, CallDirection, CallHandle, CallId, CallSnapshot, CallStatus, CancelledSession, CancelledTurn, CartesiaProviderConfig, CartesiaTtsProviderOptions, ChannelKind, ChannelLayout, CleanupErrorSummary, CleanupStage, Clock, CompletedSession, CompletedTurn, ConnectedCall, ConnectionObservabilityEvent, ConversationPolicyOptions, CounterIdGenerator, CreateVoiceAgentOptions, CreatedCall, CreatedSession, DeepgramProviderConfig, DeepgramSttProviderOptions, DefineAgentInput, DefineToolInput, DtmfDigit, DtmfReceivedEvent, DualProtocolResult, DurableErrorCode, DurableOutboxEvent, DurableRuntimeMetric, DurableRuntimePolicy, DurableRuntimeStore, DurableSessionTransaction, ElevenLabsSttCommitStrategy, ElevenLabsSttProviderConfig, ElevenLabsSttProviderOptions, ElevenLabsTtsProviderConfig, ElevenLabsTtsProviderOptions, EndSessionReason, EndSessionRequest, EndTurnRequest, EndedCall, ErrorCategory, ExecuteToolInput, FailedCall, FailedSession, FailedToolCall, FailedToolCallStatus, FailedTurn, GroqChatLlmProviderOptions, GroqProviderConfig, HealthCheckResult, HealthSnapshot, IdGenerator, IdempotencyPolicy, InMemoryDurableRuntimeStore, InMemoryDurableRuntimeStoreOptions, InMemoryMemoryOptions, InboundCallContext, InboundMediaEvent, IncrementalTextToSpeechProvider, InputAudioChunk, InputMediaEvent, InternalMediaEvent, InterruptRequestedEvent, InterruptionMode, InterruptionPolicy, JsonSchemaDocument, JsonValue, LLMProvider, LiveTerminalSource, LlmCompletion, LlmCompletionRequest, LlmInlineToolCall, LlmMessage, LlmMessageRole, LlmProviderConfig, LlmStreamEvent, LlmUsage, MediaAudioChunkEvent, MediaAudioCommittedEvent, MediaDirection, MediaErrorEvent, MediaEvent, MediaEventId, MediaEventKind, MediaEventType, MediaStreamEndedEvent, MediaStreamStartedEvent, MediaTransport, MediaTransportKind, Memory, MemoryCapabilities, MemoryEntry, MemoryEntryId, MemoryKind, MemoryPutOptions, MemoryQuery, MemoryRef, MemoryScope, NodeMediaPlaneConnection, NodeMediaPlaneConnectionErrorHandler, NodeMediaPlaneConnectionHandler, NodeMediaPlaneOptions, NodeMediaPlaneRequestHandler, NormalizedAudioEncoding, NormalizedError, OpenAiProviderConfig, OpenAiResponsesLlmProviderOptions, OrganizationId, OutboundCallRequest, OutputAudioChunk, OutputMediaEvent, PersonaConfig, PipelineVoiceLoopOptions, PipelineVoiceLoopResult, PostgresDurableStoreOptions, PostgresMemoryOptions, PostgresMigration, PostgresRedisDurableStoreOptions, PreCallContext, PreCallContextResolver, PreCallMemoryContext, PreCallMemoryResolver, Provider, ProviderAudioCapabilities, ProviderCancellationCapabilities, ProviderCapabilities, ProviderCatalogEntry, ProviderCompatibility, ProviderCompatibilityIssue, ProviderCompatibilityIssueCode, ProviderDataPolicy, ProviderEventId, ProviderForKind, ProviderKind, ProviderPlayoutCapabilities, ProviderRequirements, ProviderStability, ProviderStreamingCapabilities, ProviderToolCapabilities, ProviderTransport, QueuedToolCall, RecoveryPollResult, RedisClient, RedisMulti, RedisScanOptions, RedisSetResult, RedisStoreOptions, RequiredProviderCapabilities, RetryPolicy, RingingCall, RunningToolCall, Runtime, RuntimeOptions, RuntimeProvider, RuntimeServiceLifecycle, SampleRateHz, SarvamOutputMode, SarvamProviderConfig, SarvamSttProviderOptions, SchemaValidationResult, Session, SessionAttachment, SessionAttachmentHealth, SessionCancellationReason, SessionEndEvent, SessionEndMemorySnapshot, SessionId, SessionLease, SessionLeaseStore, SessionMemoryFinalization, SessionMetricsRecorder, SessionReaperOptions, SessionRecoveryCoordinatorOptions, SessionRuntimeMetadata, SessionSnapshot, SessionState, SessionStatus, SessionStore, SonioxProviderConfig, SonioxStructuredContext, SonioxSttProviderOptions, SpeechToTextProvider, SqlClient$1 as SqlClient, SqlPool$1 as SqlPool, SqlResult, StartAttachedSessionOptions, StartSessionOptions, StartTurnRequest, StartingSession, StoredSessionRecord, StoredToolCallRecord, StoredTurnRecord, StreamEndReason, SttCommitMode, SttOpenRequest, SttProviderConfig, SttReconnectOptions, SttRecoveryControl, SttRecoveryState, SttSession, SttSessionInputOptions, SttSessionOptions, SttStream, SttTimestampOrigin, SucceededToolCall, TelephonyProvider, TelephonyProviderConfig, TerminalSession, TerminalSessionDraft, TerminalSessionStatus, TerminalSource, TerminalToolCall, TerminalTurn, TextDeliveryMode, TextToSpeechProvider, TimeoutAction, TimeoutPolicy, Timestamp, ToolCall, ToolCallId, ToolCallRuntimeMetadata, ToolCallStatus, ToolCallStore, ToolDefinition, ToolExecutionContext, ToolExecutor, ToolId, ToolIdempotencyClaim, ToolIdempotencyClaimResult, ToolIdempotencyLease, ToolIdempotencyOutcome, ToolIdempotencyRecord, ToolIdempotencyStatus, ToolIdempotencyStore, ToolLogger, ToolName, ToolRegistry, ToolTenant, TranscriptEndpointEvent, TranscriptEndpointReason, TranscriptEvent, TranscriptEventType, TranscriptSegmentEvent, TranscriptSegmentEventType, TranscriptSpeechStartedEvent, TransportAudioEncoding, TransportAudioFormat, TtsAlignmentEvent, TtsAlignmentUnit, TtsEvent, TtsFlushAcknowledgement, TtsFlushCompletedEvent, TtsFlushId, TtsFlushResult, TtsProviderConfig, TtsSession, TtsSessionOpenRequest, TtsStream, TtsSynthesisRequest, Turn, TurnCancellationReason, TurnCommitRequestedEvent, TurnDetectionMode, TurnId, TurnInput, TurnLatency, TurnLatencyRecord, TurnOutput, TurnRuntimeMetadata, TurnStatus, TurnStore, TvicErrorName, TwilioFlatParams, TwilioMediaStreamCallHandleOptions, TwilioMediaStreamSocket, TwilioParamValue, TwilioParams, UpgradeAuthorization, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceEvent, VoiceRuntimeFailureMetadata, WebClientAudioCallHandleOptions, WebClientAudioConnectionEvent, WebClientAudioProviderOptions, WebClientAudioSocket, WorkflowId };
+export { ADAPTER_DEFAULTS, AssemblyAiSttProvider, AsyncQueue, AsyncQueueConsumerError, BackendUnavailableError, CartesiaSttProvider, CartesiaTtsProvider, ConversationPolicy, CorruptRecordError, DEFAULT_DURABLE_RUNTIME_POLICY, DTMF_DIGITS, DeepgramSttProvider, DurableError, EVENT_KIND_MAP, ElevenLabsSttProvider, ElevenLabsTtsHttpStreamProvider, ElevenLabsTtsProvider, ElevenLabsTtsRestProvider, InMemoryMemory, InMemorySessionLeaseStore, InMemorySessionStore, InMemoryToolCallStore, InMemoryToolIdempotencyStore, InMemoryTurnStore, InvalidArgumentError, LeaseLostError, LeaseUnavailableError, MAX_CARTESIA_INPUT_UTF16_CODE_UNITS, MAX_CARTESIA_INPUT_UTF8_BYTES, MAX_ERROR_CODE_UTF8_BYTES, MAX_PROVIDER_AUDIO_OFFSET_MS, MAX_RECOVERY_PAGE_SIZE, MAX_SAFE_LEASE_TIMESTAMP, 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, SARVAM_TTS_V4_FLASH_MODEL, 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, assertLeaseFence, assertLeaseTimestampMs, assertLeaseTtlMs, assertMemoryCapability, assertMemoryPolicySupported, assertPcm16leFormat, assertRecoveryPageSize, 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, isValidErrorCode, jsonSerializableNormalizedError, kindForMediaEvent, matchPath, mediaError, monotonicOffsetMs, mulawToPcm16le, normalizeLegacyError, normalizeUnknownError, normalizedError, normalizedErrorFromTvicError, nowTimestamp, pcm16leToMulaw, providerError, rateLimitError, requireProviderKind, resamplePcm16le, resolvePreCallContext, resolvePreCallMemory, runPostgresMemoryMigrations, runPostgresMigrations, safeLeaseExpiryAt, sameAudioFormat, shouldDeliverText, signVoiceSessionToken, signatureError, splitPcm16leFrames, stableStringify, supportsAudioFormat, supportsBatchModel, supportsLanguage, supportsModel, terminalSessionFromRequest, terminalSourceForRequest, terminalTurnFromRequest, timeoutError, toRuntimeSessionTrace, 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, AudioOutputDeliveryStatus, 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, ManagedVoiceAgentSession, 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, RuntimeSessionTrace, RuntimeTraceError, SampleRateHz, SarvamOutputMode, SarvamProviderConfig, SarvamSttProviderOptions, SarvamTtsHttpProviderOptions, SarvamTtsProviderConfig, SarvamTtsProviderOptions, SchemaValidationResult, Session, SessionAttachment, SessionAttachmentHealth, SessionCancellationReason, SessionEndEvent, SessionEndMemorySnapshot, SessionId, SessionLease, SessionLeaseStore, SessionMemoryFinalization, SessionMetricsRecorder, SessionReaperOptions, SessionRecoveryCandidate, 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, TextOutputDeliveryStatus, TextToSpeechProvider, TimeoutAction, TimeoutPolicy, Timestamp, ToolCall, ToolCallId, ToolCallRuntimeMetadata, ToolCallStatus, ToolCallStore, ToolDefinition, ToolExecutionContext, ToolExecutor, ToolId, ToolIdempotencyClaim, ToolIdempotencyClaimResult, ToolIdempotencyLease, ToolIdempotencyLookupResult, ToolIdempotencyOutcome, ToolIdempotencyQuarantine, ToolIdempotencyQuarantineResult, ToolIdempotencyRecord, ToolIdempotencyRelease, 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, TurnOutputDelivery, TurnRuntimeMetadata, TurnStatus, TurnStore, TvicErrorName, TwilioFlatParams, TwilioMediaStreamCallHandleOptions, TwilioMediaStreamSocket, TwilioParamValue, TwilioParams, UpgradeAuthorization, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceAgentWithSessionLifecycle, VoiceEvent, VoiceRuntimeFailureMetadata, WebClientAudioCallHandleOptions, WebClientAudioConnectionEvent, WebClientAudioProviderOptions, WebClientAudioSocket, WorkflowId };