voice-runtime 1.2.0 → 2.0.0

package/dist/index.d.ts

@@ -50,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";
@@ -76,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;
@@ -101,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;
@@ -128,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;
@@ -153,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";
@@ -251,7 +200,7 @@ 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";
@@ -343,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";
 
 /**
@@ -410,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";
@@ -508,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"];
@@ -521,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;
@@ -562,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[];
@@ -584,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;
@@ -609,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;
@@ -737,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;
 }
@@ -776,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>;
 }
 
@@ -849,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 {
@@ -972,6 +930,8 @@ interface ProviderCapabilities {
     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;
@@ -985,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>>;
 }
@@ -1046,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 {
@@ -1232,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 {
@@ -1327,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;
     /**
@@ -1424,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 {
@@ -1452,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>>;
@@ -1472,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 {
@@ -1526,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>;
 }
 
@@ -1558,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;
@@ -1713,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;
 }
@@ -1754,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>>;
@@ -1773,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 {
@@ -1810,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";
@@ -1873,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>;
@@ -1922,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;
@@ -2047,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;
@@ -2057,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>;
 }
 
@@ -2110,22 +1959,25 @@ declare class TwilioMediaStreamsProvider implements TelephonyProvider {
 }
 declare function createTwilioMediaStreamsProvider(): TwilioMediaStreamsProvider;
 
-declare const WEB_CLIENT_AUDIO_CLOSE_CODES: {
-    protocol: number;
-    heartbeatTimeout: number;
-    superseded: number;
-    maxDuration: number;
-    resourceLimit: number;
-    operatorTerminated: number;
-};
 declare const WEB_CLIENT_AUDIO_DEFAULTS: {
     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 {
@@ -2133,6 +1985,7 @@ interface WebClientAudioSocket {
     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;
@@ -2180,6 +2033,7 @@ interface WebClientAudioCallHandle extends CallHandle {
     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>;
@@ -2380,9 +2234,9 @@ interface SarvamTtsProviderOptions {
     readonly voiceId?: string;
     readonly modelId?: string;
     readonly language?: string;
-    /** Provider pace. Sarvam v3 accepts 0.5 through 2.0. */
+    /** Provider pace. Sarvam Bulbul v3 and v4 Flash accept 0.5 through 2.0. */
     readonly pace?: number;
-    /** Provider temperature. Sarvam's streaming schema accepts 0.01 through 1.0. */
+    /** Bulbul v3 temperature; Bulbul v4 Flash does not accept this option. */
     readonly temperature?: number;
     readonly minBufferSize?: number;
     readonly maxChunkLength?: number;
@@ -2397,7 +2251,7 @@ interface SarvamTtsStreamOptions {
     readonly language: string;
     readonly voice: string;
     readonly pace: number;
-    readonly temperature: number;
+    readonly temperature?: number;
     readonly minBufferSize: number;
     readonly maxChunkLength: number;
     readonly pronunciationDictionaryId?: string;
@@ -2408,36 +2262,14 @@ declare class SarvamTtsProvider implements IncrementalTextToSpeechProvider {
     readonly name: "sarvam-tts";
     readonly kind = "tts";
     readonly version = "0.1.0";
-    readonly capabilities: {
-        streaming: {
-            input: true;
-            output: true;
-            native: true;
-        };
-        cancellation: {
-            request: true;
-            output: false;
-            buffer: false;
-            truncation: false;
-        };
-        transports: "websocket"[];
-        audio: {
-            output: {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 16000;
-                readonly channels: 1;
-            }[];
-        };
-        languages: readonly ["hi-IN", "bn-IN", "ta-IN", "te-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "pa-IN", "od-IN", "en-IN"];
-        models: readonly ["bulbul:v3"];
-        voices: readonly ["shubh", "aditya", "ritu", "priya", "neha", "rahul", "pooja", "rohan", "simran", "kavya", "amit", "dev", "ishita", "shreya", "ratan", "varun", "manan", "sumit", "roopa", "kabir", "aayan", "ashutosh", "advait", "anand", "tanya", "tarun", "sunny", "mani", "gokul", "vijay", "shruti", "suhani", "mohit", "kavitha", "rehan", "soham", "rupali"];
-        metadata: {
-            outputAudioCodec: string;
-            outputSampleRateHz: number;
-            completionEvent: string;
-        };
-    };
+    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>;
 }
@@ -2453,59 +2285,41 @@ declare class SarvamTtsStream implements TtsSession {
 }
 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 accepts 0.5 through 2.0. */
+    /** Provider pace. Sarvam Bulbul v3 and v4 Flash accept 0.5 through 2.0. */
     readonly pace?: number;
-    /** Provider temperature. Sarvam Bulbul v3 accepts 0.01 through 1.0. */
+    /** 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;
-    /** Injectable fetch makes protocol and failure tests hermetic. */
+    /** 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: {
-        streaming: {
-            input: false;
-            output: false;
-            native: false;
-        };
-        cancellation: {
-            request: true;
-            output: false;
-            buffer: false;
-            truncation: false;
-        };
-        transports: "http"[];
-        audio: {
-            output: {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 16000;
-                readonly channels: 1;
-            }[];
-        };
-        languages: readonly ["hi-IN", "bn-IN", "ta-IN", "te-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "pa-IN", "od-IN", "en-IN"];
-        models: readonly ["bulbul:v3"];
-        voices: readonly ["shubh", "aditya", "ritu", "priya", "neha", "rahul", "pooja", "rohan", "simran", "kavya", "amit", "dev", "ishita", "shreya", "ratan", "varun", "manan", "sumit", "roopa", "kabir", "aayan", "ashutosh", "advait", "anand", "tanya", "tarun", "sunny", "mani", "gokul", "vijay", "shruti", "suhani", "mohit", "kavitha", "rehan", "soham", "rupali"];
-        metadata: {
-            transport: string;
-            endpoint: string;
-            requestTextLimit: number;
-            wireOutputCodec: string;
-            normalizedOutput: string;
-            documentation: string;
-        };
-    };
+    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 {
@@ -2513,39 +2327,14 @@ declare class SarvamTtsHttpStreamProvider implements TextToSpeechProvider {
     readonly name: "sarvam-tts";
     readonly kind = "tts";
     readonly version = "0.1.0";
-    readonly capabilities: {
-        streaming: {
-            input: false;
-            output: true;
-            native: true;
-        };
-        cancellation: {
-            request: true;
-            output: true;
-            buffer: false;
-            truncation: false;
-        };
-        transports: "http"[];
-        audio: {
-            output: {
-                readonly encoding: "pcm_s16le";
-                readonly sampleRateHz: 16000;
-                readonly channels: 1;
-            }[];
-        };
-        languages: readonly ["hi-IN", "bn-IN", "ta-IN", "te-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "pa-IN", "od-IN", "en-IN"];
-        models: readonly ["bulbul:v3"];
-        voices: readonly ["shubh", "aditya", "ritu", "priya", "neha", "rahul", "pooja", "rohan", "simran", "kavya", "amit", "dev", "ishita", "shreya", "ratan", "varun", "manan", "sumit", "roopa", "kabir", "aayan", "ashutosh", "advait", "anand", "tanya", "tarun", "sunny", "mani", "gokul", "vijay", "shruti", "suhani", "mohit", "kavitha", "rehan", "soham", "rupali"];
-        metadata: {
-            transport: string;
-            endpoint: string;
-            requestTextLimit: number;
-            wireOutputCodec: string;
-            normalizedOutput: string;
-            documentation: string;
-        };
-    };
+    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;
@@ -2742,10 +2531,10 @@ declare const PROVIDER_CATALOG: {
         readonly models: readonly ["saaras:v3", "saaras:v4"];
     };
     readonly sarvamTts: {
-        readonly verifiedAt: "2026-09-25";
-        readonly source: "https://docs.sarvam.ai/api-reference/text-to-speech/convert";
+        readonly verifiedAt: "2026-10-09";
+        readonly source: "https://docs.sarvam.ai/api/getting-started/models/bulbul";
         readonly defaultModel: "bulbul:v3";
-        readonly models: readonly ["bulbul:v3"];
+        readonly models: readonly ["bulbul:v3", "bulbul:v4-flash"];
     };
     readonly cartesia: {
         readonly verifiedAt: "2026-09-25";
@@ -3218,6 +3007,10 @@ declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
         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>;
 }
@@ -3309,6 +3102,10 @@ declare class ElevenLabsTtsProvider implements IncrementalTextToSpeechProvider {
         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>;
 }
@@ -3317,9 +3114,7 @@ declare class ElevenLabsTtsStream implements TtsSession {
     readonly events: AsyncIterable<TtsEvent>;
     constructor(socket: WebSocket__default, request: TtsSessionOpenRequest, options: ElevenLabsStreamOptions);
     sendText(text: string, options?: ElevenLabsTtsSendTextOptions): Promise<void>;
-    /** Sends one incremental line in a Text-to-Dialogue session. */
     sendDialogueTurn(text: string, options?: ElevenLabsDialogueTurnOptions): Promise<void>;
-    /** Resets the provider receive timeout without causing a generation. */
     keepAlive(): Promise<void>;
     flush(): Promise<TtsFlushResult>;
     finish(): Promise<void>;
@@ -3355,7 +3150,6 @@ interface ElevenLabsDialogueSynthesisRequest extends Omit<TtsSynthesisRequest, "
 }
 interface ElevenLabsDialogueProvider extends TextToSpeechProvider {
     synthesizeDialogue(request: ElevenLabsDialogueSynthesisRequest): Promise<TtsStream>;
-    /** Forces the regular single-voice TTS HTTP endpoint, including for v3 models. */
     synthesizeSpeech(request: ElevenLabsTtsHttpSynthesisRequest): Promise<TtsStream>;
 }
 declare class ElevenLabsTtsRestProvider implements ElevenLabsDialogueProvider {
@@ -3365,6 +3159,10 @@ declare class ElevenLabsTtsRestProvider implements ElevenLabsDialogueProvider {
     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;
@@ -3384,9 +3182,7 @@ declare class ElevenLabsTtsHttpStreamProvider extends ElevenLabsTtsRestProvider
     private executeStreamDialogue;
     private executeViaProtectedPath;
 }
-/** The factory is the preferred entry point for complete HTTP responses. */
 declare function createElevenLabsTtsRestProvider(options: ElevenLabsHttpTtsProviderOptions): ElevenLabsTtsRestProvider;
-/** The factory is the preferred entry point for chunked HTTP responses. */
 declare function createElevenLabsTtsHttpStreamProvider(options: ElevenLabsHttpTtsProviderOptions): ElevenLabsTtsHttpStreamProvider;
 
 /** The point at which the primary TTS provider became unavailable. */
@@ -3404,41 +3200,20 @@ interface TtsFailoverProviderOptions {
     readonly primary: TextToSpeechProvider;
     /** The provider used only after the failover policy accepts the error. */
     readonly fallback: TextToSpeechProvider;
-    /**
-     * Maps the primary request to the fallback provider's model and voice. The
-     * session, turn, signal, and output format must remain unchanged.
-     */
+    /** Map provider-specific values; callers own their semantic equivalence. */
     readonly mapFallbackRequest?: (request: TtsSynthesisRequest, error: NormalizedError) => TtsSynthesisRequest;
-    /**
-     * Defaults to operational provider/network/timeout failures. Validation,
-     * authentication, protocol, identity, and cancellation errors do not fail
-     * over because retrying them on another provider usually hides a bug.
-     */
+    /** 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;
-    /** Best-effort observability hook; observer failures never block fallback. */
     readonly onFallback?: (context: TtsFailoverContext) => void | PromiseLike<void>;
     readonly name?: string;
 }
-/**
- * Builds an explicit TTS failover provider for host-owned routing.
- *
- * Failover is attempted when the primary request fails before a stream is
- * returned, or when its stream fails before any audio chunk is emitted. Once
- * audio has been delivered, the original failure is propagated instead of
- * replaying the whole response and risking duplicated speech.
- */
 declare function createTtsFailoverProvider(options: TtsFailoverProviderOptions): TextToSpeechProvider;
 
 declare function bytesToBase64(bytes: Uint8Array): string;
 declare function base64ToBytes(value: string): Uint8Array;
 declare function mulawToPcm16le(mulaw: Uint8Array): Uint8Array;
 declare function pcm16leToMulaw(pcm: Uint8Array): Uint8Array;
-/**
- * v0.1 normalized audio is frozen to **pcm_s16le, mono**. The frame/duration/
- * resample helpers below compute on interleaved-sample assumptions that only hold
- * for a single channel, so a stereo format would silently corrupt timing. We
- * reject it at the boundary rather than miscompute.
- */
 declare function assertPcm16leFormat(format: AudioFormat): void;
 declare function resamplePcm16le(pcm: Uint8Array, fromSampleRateHz: number, toSampleRateHz: number): Uint8Array;
 declare function frameCountForPcm16le(bytes: Uint8Array): number;
@@ -3456,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;
 }
 /**
@@ -3486,139 +3256,38 @@ interface AudioNormalizerOptions {
 interface AudioNormalizer {
     readonly inputFormat: AudioFormat;
     readonly outputFormat: AudioFormat;
-    /** Create an independent copy at the current sample-clock position. */
     fork(): AudioNormalizer;
     push(bytes: Uint8Array): Uint8Array;
     finishSegment(): Uint8Array;
     finish(): Uint8Array;
 }
-/**
- * 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;
@@ -3628,7 +3297,7 @@ 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>;
@@ -3643,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>>;
@@ -3670,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;
@@ -3687,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;
 
@@ -3723,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;
@@ -3738,6 +3399,7 @@ interface SessionRecoveryCoordinatorOptions {
         readonly name: string;
         readonly value: number;
     }) => void;
+    readonly onError?: (error: unknown) => void;
 }
 interface RecoveryPollResult {
     readonly candidates: number;
@@ -3748,7 +3410,7 @@ declare class SessionRecoveryCoordinator {
     #private;
     constructor(options: SessionRecoveryCoordinatorOptions);
     start(): void;
-    stop(): Promise<void>;
+    stop(): Promise<boolean>;
     pollOnce(): Promise<RecoveryPollResult>;
 }
 interface SessionReaperOptions {
@@ -3764,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>;
 }
 
@@ -3793,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[];
@@ -3823,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>;
 }
 
@@ -3859,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 {
@@ -3883,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;
@@ -3896,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;
@@ -3925,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;
@@ -3934,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";
@@ -3944,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;
 }
 /**
@@ -3991,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>;
@@ -4013,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;
 }
@@ -4037,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;
@@ -4052,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;
@@ -4076,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;
 }
@@ -4202,36 +3779,28 @@ interface NodeMediaPlaneConnection<TContext = unknown> {
     readonly upgradeContext?: TContext;
 }
 type NodeMediaPlaneConnectionHandler<TContext = unknown> = (connection: NodeMediaPlaneConnection<TContext>) => Promise<void> | void;
-type NodeMediaPlaneRequestHandler = (request: IncomingMessage, response: ServerResponse) => boolean | Promise<boolean>;
+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;
@@ -4280,7 +3849,6 @@ 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"> & {
@@ -4348,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;
@@ -4357,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>>;
@@ -4372,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;
@@ -4384,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>;
@@ -4397,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;
@@ -4413,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;
@@ -4422,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;
@@ -4433,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;
@@ -4444,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;
@@ -4452,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;
@@ -4506,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 {
@@ -4595,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 {
@@ -4612,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>> {
@@ -4631,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;
 }
@@ -4651,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>;
@@ -4660,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;
@@ -4691,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>;
 }
@@ -4701,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;
@@ -4729,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>;
@@ -4742,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>;
 }
@@ -4754,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 {
@@ -4811,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>;
 }
@@ -4822,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;
@@ -4839,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>;
 }
@@ -4897,5 +4486,5 @@ declare class PostgresMemory implements Memory {
 }
 declare function createPostgresMemory(options: PostgresMemoryOptions): PostgresMemory;
 
-export { ADAPTER_DEFAULTS, AssemblyAiSttProvider, AsyncQueue, AsyncQueueConsumerError, BackendUnavailableError, CartesiaSttProvider, CartesiaTtsProvider, ConversationPolicy, CorruptRecordError, DEFAULT_DURABLE_RUNTIME_POLICY, DTMF_DIGITS, DeepgramSttProvider, DurableError, EVENT_KIND_MAP, ElevenLabsSttProvider, ElevenLabsTtsHttpStreamProvider, ElevenLabsTtsProvider, ElevenLabsTtsRestProvider, InMemoryMemory, InMemorySessionLeaseStore, InMemorySessionStore, InMemoryToolCallStore, InMemoryToolIdempotencyStore, InMemoryTurnStore, InvalidArgumentError, LeaseLostError, LeaseUnavailableError, MAX_CARTESIA_INPUT_UTF16_CODE_UNITS, MAX_CARTESIA_INPUT_UTF8_BYTES, MAX_PROVIDER_AUDIO_OFFSET_MS, MemoryBackendUnavailableError, MemoryEntryTooLargeError, MemorySessionQuotaExceededError, NodeMediaPlane, PCM16_16K_MONO, PCM16_8K_MONO, PROVIDER_API_VERSIONS, PROVIDER_CATALOG, PROVIDER_ERROR_CODES, PROVIDER_NAMES, PROVIDER_STABILITY, PROVIDER_STABILITY_LEVELS, PipelineVoiceLoop, PipelineVoiceLoopBuilder, RUNTIME_SAMPLE_RATE_HZ, RecordConflictError, RecordNotFoundError, STT_ERROR_CODES, STT_STREAM_ENDED_REASON, SarvamSttProvider, SarvamTtsHttpStreamProvider, SarvamTtsProvider, SarvamTtsRestProvider, SessionReaper, SessionRecoveryCoordinator, SonioxSttProvider, TELEPHONY_SAMPLE_RATE_HZ, TVIC_ERROR_CODES, TVIC_ERROR_CODE_ALIASES, TVIC_ERROR_MARKER, TVIC_ERROR_NAMES, TWILIO_MAX_AUDIO_EVENT_BYTES, TvicThrowableError, TwilioMediaStreamCallHandle, TwilioMediaStreamsProvider, VoiceRuntimeFinalizationError, WEB_CLIENT_AUDIO_ACK_RETENTION_MS, WEB_CLIENT_AUDIO_CLOSE_CODES, WEB_CLIENT_AUDIO_DEFAULTS, WebClientAudioCallHandle, WebClientAudioProvider, assertMemoryCapability, assertMemoryPolicySupported, assertPcm16leFormat, authError, base64ToBytes, bytesToBase64, cancelledError, canonicalizeTwilioData, computeTwilioSignature, connectionError, counterIdGenerator, createAssemblyAiSttProvider, createAudioNormalizer, createCartesiaSttProvider, createCartesiaTtsProvider, createDeepgramSttProvider, createDefaultIdGenerator, createElevenLabsSttProvider, createElevenLabsTtsHttpStreamProvider, createElevenLabsTtsProvider, createElevenLabsTtsRestProvider, createGroqChatLlmProvider, createInMemoryDurableRuntimeStore, createInMemoryMemory, createInMemorySessionStore, createInMemoryToolCallStore, createInMemoryTurnStore, createMediaEvent, createNodeMediaPlane, createOpenAiResponsesLlmProvider, createPostgresDurableRuntimeStore, createPostgresMemory, createPostgresRedisDurableRuntimeStore, createRedisDurableRuntimeStore, createRuntime, createSarvamSttProvider, createSarvamTtsHttpStreamProvider, createSarvamTtsProvider, createSarvamTtsRestProvider, createSonioxSttProvider, createSttSession, createSystemClock, createToolRegistry, createTtsFailoverProvider, createTwilioMediaStreamsProvider, createVoiceAgent, createWebClientAudioProvider, defineAgent, defineTool, deliverAssistantText, durationMsForPcm16le, evaluateProviderCompatibility, executeTool, formatMemoryContextAsSystemBlock, formatPreCallContextAsSystemBlock, frameCountForPcm16le, getSttRecoveryControl, idempotencyKeyFor, idempotencyRequestHashFor, internalError, interruptedError, isDtmfDigit, isIncrementalTextToSpeechProvider, isInputMediaEvent, isNormalizedError, isOutputMediaEvent, isProviderKind, isReconstructableAudioFormat, isSampleRateHz, isTerminalSession, isTerminalTurn, isTranscriptSegmentEvent, isTvicError, isTvicErrorName, kindForMediaEvent, matchPath, mediaError, monotonicOffsetMs, mulawToPcm16le, normalizeLegacyError, normalizeUnknownError, normalizedError, nowTimestamp, pcm16leToMulaw, providerError, rateLimitError, requireProviderKind, resamplePcm16le, resolvePreCallContext, resolvePreCallMemory, runPostgresMemoryMigrations, runPostgresMigrations, sameAudioFormat, shouldDeliverText, signVoiceSessionToken, signatureError, splitPcm16leFrames, stableStringify, supportsAudioFormat, supportsBatchModel, supportsLanguage, supportsModel, terminalSessionFromRequest, terminalSourceForRequest, terminalTurnFromRequest, timeoutError, toTimestamp, toolError, toolInputError, tvicErrorFromJSON, unknownErrorMessage, validateJsonSchemaSubset, validationError, verifyTwilioSignature, verifyVoiceSessionToken, withSttReconnect };
-export type { ActiveSession, ActiveTurn, Agent, AgentAudioPolicy, AgentContextPolicy, AgentId, AgentMemoryPolicy, AgentProviders, AnyMediaEventInit, AssemblyAiProviderConfig, AssemblyAiSttProviderOptions, AssistantTextRecord, AudioFormat, AudioNormalizationMode, AudioNormalizer, AudioNormalizerOptions, AudioPayload, BackoffStrategy, Brand, Call, CallControlCapability, CallDirection, CallHandle, CallId, CallSnapshot, CallStatus, CancelledSession, CancelledTurn, CartesiaGenerationConfig, CartesiaProviderConfig, CartesiaSttMode, CartesiaSttProviderConfig, CartesiaSttProviderOptions, CartesiaTtsProviderOptions, ChannelKind, ChannelLayout, CleanupErrorSummary, CleanupStage, Clock, CompletedSession, CompletedTurn, ConnectedCall, ConnectionObservabilityEvent, ConversationPolicyOptions, CounterIdGenerator, CreateVoiceAgentOptions, CreatedCall, CreatedSession, DeepgramProviderConfig, DeepgramSttProviderOptions, DefineAgentInput, DefineToolInput, DtmfDigit, DtmfReceivedEvent, DualProtocolResult, DurableErrorCode, DurableOutboxEvent, DurableRuntimeMetric, DurableRuntimePolicy, DurableRuntimeStore, DurableSessionTransaction, ElevenLabsBatchSttRequest, ElevenLabsBatchSttResult, ElevenLabsBatchTimestampGranularity, ElevenLabsDialogueInput, ElevenLabsDialogueProvider, ElevenLabsDialogueSynthesisRequest, ElevenLabsDialogueTurnOptions, ElevenLabsEntityDetection, ElevenLabsHttpTtsProviderOptions, ElevenLabsPronunciationDictionaryLocator, ElevenLabsSttCommitStrategy, ElevenLabsSttProviderConfig, ElevenLabsSttProviderOptions, ElevenLabsTextNormalization, ElevenLabsTtsHttpSynthesisRequest, ElevenLabsTtsProviderConfig, ElevenLabsTtsProviderOptions, ElevenLabsTtsSendTextOptions, EndSessionReason, EndSessionRequest, EndTurnRequest, EndedCall, ErrorCategory, ExecuteToolInput, FailedCall, FailedSession, FailedToolCall, FailedToolCallStatus, FailedTurn, GroqChatLlmProviderOptions, GroqProviderConfig, HealthCheckResult, HealthSnapshot, IdGenerator, IdempotencyPolicy, InMemoryDurableRuntimeStore, InMemoryDurableRuntimeStoreOptions, InMemoryMemoryOptions, InboundCallContext, InboundMediaEvent, IncrementalTextToSpeechProvider, InputAudioChunk, InputMediaEvent, InternalMediaEvent, InterruptRequestedEvent, InterruptionMode, InterruptionPolicy, JsonSchemaDocument, JsonValue, LLMProvider, LiveTerminalSource, LlmCompletion, LlmCompletionRequest, LlmInlineToolCall, LlmMessage, LlmMessageRole, LlmProviderConfig, LlmStreamEvent, LlmUsage, MediaAudioChunkEvent, MediaAudioCommittedEvent, MediaDirection, MediaErrorEvent, MediaEvent, MediaEventId, MediaEventKind, MediaEventType, MediaStreamEndedEvent, MediaStreamStartedEvent, MediaTransport, MediaTransportKind, Memory, MemoryCapabilities, MemoryEntry, MemoryEntryId, MemoryKind, MemoryPutOptions, MemoryQuery, MemoryRef, MemoryScope, NodeMediaPlaneConnection, NodeMediaPlaneConnectionErrorHandler, NodeMediaPlaneConnectionHandler, NodeMediaPlaneOptions, NodeMediaPlaneRequestHandler, NormalizedAudioEncoding, NormalizedError, OpenAiProviderConfig, OpenAiResponsesLlmProviderOptions, OrganizationId, OutboundCallRequest, OutputAudioChunk, OutputMediaEvent, PersonaConfig, PipelineVoiceLoopOptions, PipelineVoiceLoopResult, PostgresDurableStoreOptions, PostgresMemoryOptions, PostgresMigration, PostgresRedisDurableStoreOptions, PreCallContext, PreCallContextResolver, PreCallMemoryContext, PreCallMemoryResolver, Provider, ProviderAudioCapabilities, ProviderBatchCapabilities, ProviderCancellationCapabilities, ProviderCapabilities, ProviderCatalogEntry, ProviderClock, ProviderCompatibility, ProviderCompatibilityIssue, ProviderCompatibilityIssueCode, ProviderDataPolicy, ProviderEventId, ProviderForKind, ProviderKind, ProviderPlayoutCapabilities, ProviderRequirements, ProviderStability, ProviderStreamingCapabilities, ProviderToolCapabilities, ProviderTransport, QueuedToolCall, RecoveryPollResult, RedisClient, RedisMulti, RedisScanOptions, RedisSetResult, RedisStoreOptions, RequiredProviderCapabilities, RetryPolicy, RingingCall, RunningToolCall, Runtime, RuntimeOptions, RuntimeProvider, RuntimeServiceLifecycle, SampleRateHz, SarvamOutputMode, SarvamProviderConfig, SarvamSttProviderOptions, SarvamTtsHttpProviderOptions, SarvamTtsProviderConfig, SarvamTtsProviderOptions, SchemaValidationResult, Session, SessionAttachment, SessionAttachmentHealth, SessionCancellationReason, SessionEndEvent, SessionEndMemorySnapshot, SessionId, SessionLease, SessionLeaseStore, SessionMemoryFinalization, SessionMetricsRecorder, SessionReaperOptions, SessionRecoveryCoordinatorOptions, SessionRuntimeMetadata, SessionSnapshot, SessionState, SessionStatus, SessionStore, SonioxProviderConfig, SonioxStructuredContext, SonioxSttProviderOptions, SpeechToTextProvider, SqlClient$1 as SqlClient, SqlPool$1 as SqlPool, SqlResult, StartAttachedSessionOptions, StartSessionOptions, StartTurnRequest, StartingSession, StoredSessionRecord, StoredToolCallRecord, StoredTurnRecord, StreamEndReason, SttBatchTimestampGranularity, SttBatchTranscription, SttBatchTranscriptionRequest, SttBatchWord, SttCommitMode, SttOpenRequest, SttProviderConfig, SttReconnectOptions, SttRecoveryControl, SttRecoveryState, SttSession, SttSessionInputOptions, SttSessionOptions, SttStream, SttTimestampOrigin, SucceededToolCall, TelephonyProvider, TelephonyProviderConfig, TerminalSession, TerminalSessionDraft, TerminalSessionStatus, TerminalSource, TerminalToolCall, TerminalTurn, TextDeliveryMode, TextToSpeechProvider, TimeoutAction, TimeoutPolicy, Timestamp, ToolCall, ToolCallId, ToolCallRuntimeMetadata, ToolCallStatus, ToolCallStore, ToolDefinition, ToolExecutionContext, ToolExecutor, ToolId, ToolIdempotencyClaim, ToolIdempotencyClaimResult, ToolIdempotencyLease, ToolIdempotencyOutcome, ToolIdempotencyRecord, ToolIdempotencyStatus, ToolIdempotencyStore, ToolLogger, ToolName, ToolRegistry, ToolTenant, TranscriptEndpointEvent, TranscriptEndpointReason, TranscriptEvent, TranscriptEventType, TranscriptSegmentEvent, TranscriptSegmentEventType, TranscriptSpeechStartedEvent, TransportAudioEncoding, TransportAudioFormat, TtsAlignmentEvent, TtsAlignmentUnit, TtsEvent, TtsFailoverContext, TtsFailoverPhase, TtsFailoverProviderOptions, TtsFlushAcknowledgement, TtsFlushCompletedEvent, TtsFlushId, TtsFlushResult, TtsProviderConfig, TtsSession, TtsSessionOpenRequest, TtsStream, TtsSynthesisRequest, Turn, TurnCancellationReason, TurnCommitRequestedEvent, TurnDetectionMode, TurnId, TurnInput, TurnLatency, TurnLatencyRecord, TurnOutput, TurnRuntimeMetadata, TurnStatus, TurnStore, TvicErrorName, TwilioFlatParams, TwilioMediaStreamCallHandleOptions, TwilioMediaStreamSocket, TwilioParamValue, TwilioParams, UpgradeAuthorization, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceEvent, VoiceRuntimeFailureMetadata, WebClientAudioCallHandleOptions, WebClientAudioConnectionEvent, WebClientAudioProviderOptions, WebClientAudioSocket, WorkflowId };
+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 };