voice-runtime 0.0.1 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,3976 @@
+import WebSocket from 'ws';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { AddressInfo } from 'node:net';
+
+declare const brand: unique symbol;
+type Brand<T, B extends string> = T & {
+    readonly [brand]: B;
+};
+
+type AgentId = Brand<string, "AgentId">;
+type SessionId = Brand<string, "SessionId">;
+type CallId = Brand<string, "CallId">;
+type TurnId = Brand<string, "TurnId">;
+type ToolId = Brand<string, "ToolId">;
+type ToolName = Brand<string, "ToolName">;
+type ToolCallId = Brand<string, "ToolCallId">;
+type MediaEventId = Brand<string, "MediaEventId">;
+type ProviderEventId = Brand<string, "ProviderEventId">;
+type MemoryEntryId = Brand<string, "MemoryEntryId">;
+type UserId = Brand<string, "UserId">;
+type OrganizationId = Brand<string, "OrganizationId">;
+type WorkflowId = Brand<string, "WorkflowId">;
+
+type Timestamp = Brand<string, "Timestamp">;
+declare function toTimestamp(date: Date): Timestamp;
+declare function nowTimestamp(): Timestamp;
+
+interface Clock {
+    now(): Timestamp;
+    monotonicMs(): number;
+}
+declare function monotonicOffsetMs(clock: Clock, startedAtMs: number): number;
+declare function createSystemClock(): Clock;
+
+interface CounterIdGenerator<TId extends string = string> {
+    next(): TId;
+}
+interface IdGenerator {
+    agent(): AgentId;
+    session(): SessionId;
+    call(): CallId;
+    turn(): TurnId;
+    tool(): ToolId;
+    toolCall(): ToolCallId;
+    mediaEvent(): MediaEventId;
+    memoryEntry(): MemoryEntryId;
+}
+declare function counterIdGenerator<TId extends string = string>(prefix: string): CounterIdGenerator<TId>;
+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 TVIC_ERROR_NAMES: Readonly<{
+    readonly AuthError: "AuthError";
+    readonly RateLimitError: "RateLimitError";
+    readonly InvalidRequestError: "InvalidRequestError";
+    readonly ConnectionError: "ConnectionError";
+    readonly ProviderError: "ProviderError";
+    readonly SignatureError: "SignatureError";
+    readonly ValidationError: "ValidationError";
+    readonly TimeoutError: "TimeoutError";
+    readonly InternalError: "InternalError";
+    readonly MediaError: "MediaError";
+    readonly ToolError: "ToolError";
+    readonly CancelledError: "CancelledError";
+    readonly InterruptedError: "InterruptedError";
+    readonly UnknownError: "UnknownError";
+}>;
+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;
+    readonly code: string;
+    readonly category: ErrorCategory;
+    readonly message: string;
+    readonly retriable: boolean;
+    readonly provider?: string;
+    readonly cause?: unknown;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface ErrorFactoryOptions {
+    readonly category?: ErrorCategory;
+    readonly retriable?: boolean;
+    readonly provider?: string;
+    readonly cause?: unknown;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+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: {
+    readonly code: string;
+    readonly category?: ErrorCategory;
+    readonly provider?: string;
+    readonly retriable?: boolean;
+}): 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;
+declare function validationError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category" | "retriable">): NormalizedError;
+declare function timeoutError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category">): NormalizedError;
+declare function internalError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category" | "retriable">): NormalizedError;
+declare function authError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category">): NormalizedError;
+declare function rateLimitError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category">): NormalizedError;
+declare function connectionError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category">): NormalizedError;
+declare function signatureError(code: string, message: string, options?: Omit<ErrorFactoryOptions, "category" | "retriable">): NormalizedError;
+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;
+    readonly name: TvicErrorName;
+    readonly code: string;
+    readonly category: ErrorCategory;
+    readonly retriable: boolean;
+    readonly provider?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly cause?: unknown;
+    constructor(error: NormalizedError);
+    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 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 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";
+declare class DurableError extends Error {
+    readonly code: DurableErrorCode;
+    readonly retriable: boolean;
+    constructor(code: DurableErrorCode, message: string, retriable: boolean);
+}
+declare class RecordNotFoundError extends DurableError {
+    constructor(key: string);
+}
+declare class RecordConflictError extends DurableError {
+    constructor(key: string);
+}
+declare class LeaseUnavailableError extends DurableError {
+    constructor(sessionId: string);
+}
+declare class LeaseLostError extends DurableError {
+    constructor(sessionId: string);
+}
+declare class BackendUnavailableError extends DurableError {
+    constructor(message: string);
+}
+declare class CorruptRecordError extends DurableError {
+    readonly key: string;
+    readonly schemaVersion: number | undefined;
+    constructor(key: string, message: string, schemaVersion?: number);
+}
+declare class InvalidArgumentError extends DurableError {
+    constructor(message: string);
+}
+declare class MemoryBackendUnavailableError extends DurableError {
+    constructor(message: string);
+}
+declare class MemoryEntryTooLargeError extends DurableError {
+    readonly key: string;
+    readonly sizeBytes: number;
+    readonly maxBytes: number;
+    constructor(key: string, sizeBytes: number, maxBytes: number);
+}
+declare class MemorySessionQuotaExceededError extends DurableError {
+    readonly sessionId: string;
+    readonly usedBytes: number;
+    readonly requestedBytes: number;
+    readonly maxBytes: number;
+    constructor(sessionId: string, usedBytes: number, requestedBytes: number, maxBytes: number);
+}
+
+declare const TELEPHONY_SAMPLE_RATE_HZ = 8000;
+declare const RUNTIME_SAMPLE_RATE_HZ = 16000;
+declare const PCM16_16K_MONO: {
+    readonly encoding: "pcm_s16le";
+    readonly sampleRateHz: 16000;
+    readonly channels: 1;
+};
+declare const PCM16_8K_MONO: {
+    readonly encoding: "pcm_s16le";
+    readonly sampleRateHz: 8000;
+    readonly channels: 1;
+};
+declare const PROVIDER_NAMES: {
+    readonly twilio: "twilio-media-streams";
+    readonly deepgram: "deepgram";
+    readonly cartesia: "cartesia";
+    readonly elevenlabs: "elevenlabs";
+    readonly elevenlabsStt: "elevenlabs-stt-realtime";
+    readonly sarvam: "sarvam";
+    readonly assemblyaiStt: "assemblyai-stt";
+    readonly sonioxStt: "soniox-stt";
+    readonly openaiResponses: "openai-responses";
+    readonly webClientAudio: "web-client-audio";
+};
+declare const PROVIDER_ERROR_CODES: {
+    readonly twilioMedia: "twilio.media_stream.error";
+    readonly deepgramStt: "deepgram.stt.error";
+    readonly cartesiaTts: "cartesia.tts.error";
+    readonly elevenlabsTts: "elevenlabs.tts.error";
+    readonly elevenlabsStt: "elevenlabs.stt.error";
+    readonly sarvamStt: "sarvam.stt.error";
+    readonly assemblyaiStt: "assemblyai.stt.error";
+    readonly sonioxStt: "soniox.stt.error";
+    readonly openaiResponses: "openai.responses.error";
+    readonly openaiHttp: "openai.http_error";
+    readonly openaiResponseFailed: "openai.response.failed";
+    readonly webClientAudio: "web_client_audio.error";
+};
+/** Stable runtime taxonomy consumed by reconnect and call-failure policy. */
+declare const STT_ERROR_CODES: {
+    readonly transportWriteFailed: "stt.transport.write_failed";
+    readonly unexpectedEof: "stt.transport.unexpected_eof";
+    readonly connectFailed: "stt.transport.connect_failed";
+    readonly connectTimeout: "stt.transport.connect_timeout";
+    readonly authFailed: "stt.provider.auth_failed";
+    readonly invalidRequest: "stt.provider.invalid_request";
+    readonly inputRejected: "stt.provider.input_rejected";
+    readonly rateLimited: "stt.provider.rate_limited";
+    readonly quotaExceeded: "stt.provider.quota_exceeded";
+    readonly serviceUnavailable: "stt.provider.service_unavailable";
+    readonly providerInternal: "stt.provider.internal";
+    readonly protocolError: "stt.provider.protocol_error";
+    readonly sessionExpired: "stt.provider.session_expired";
+    readonly streamEnded: "stt.stream_ended";
+    readonly bufferOverflow: "stt.reconnect.buffer_overflow";
+    readonly recoveryExhausted: "stt.reconnect.recovery_exhausted";
+    readonly closed: "stt.reconnect.closed";
+};
+
+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";
+
+/**
+ * Encodings carried on the wire by upstream providers. Adapters MUST decode or
+ * convert to a NormalizedAudioEncoding before emitting MediaEvent at the runtime
+ * boundary. These show up only inside adapter-internal transport types.
+ */
+type TransportAudioEncoding = "pcm_s16le" | "pcm_s16be" | "pcm_f32le" | "mulaw" | "alaw" | "opus" | "g722" | "mp3" | "ogg_opus";
+/**
+ * The only encodings allowed in MediaEvent payloads. The runtime contract is
+ * PCM-only at the boundary; provider-specific encodings must be decoded at the
+ * adapter edge.
+ */
+type NormalizedAudioEncoding = "pcm_s16le" | "pcm_s16be" | "pcm_f32le";
+type SampleRateHz = 8000 | 16000 | 22050 | 24000 | 44100 | 48000;
+type ChannelLayout = 1 | 2;
+interface TransportAudioFormat {
+    readonly encoding: TransportAudioEncoding;
+    readonly sampleRateHz: SampleRateHz;
+    readonly channels: ChannelLayout;
+    readonly frameDurationMs?: number;
+}
+interface AudioFormat {
+    readonly encoding: NormalizedAudioEncoding;
+    readonly sampleRateHz: SampleRateHz;
+    readonly channels: ChannelLayout;
+    readonly frameDurationMs?: number;
+}
+interface AudioPayload {
+    readonly format: AudioFormat;
+    readonly durationMs: number;
+    readonly frameCount: number;
+    readonly bytes: Uint8Array;
+    readonly checksum?: string;
+}
+declare function isSampleRateHz(value: unknown): value is SampleRateHz;
+declare function isReconstructableAudioFormat(format: unknown): format is AudioFormat;
+
+type BackoffStrategy = "fixed" | "linear" | "exponential";
+interface RetryPolicy {
+    readonly maxAttempts: number;
+    readonly initialDelayMs: number;
+    readonly maxDelayMs: number;
+    readonly backoff: BackoffStrategy;
+    readonly jitter: boolean;
+    readonly retryableErrorCodes?: readonly string[];
+}
+type TimeoutAction = "fail" | "interrupt";
+interface TimeoutPolicy {
+    readonly timeoutMs: number;
+    readonly onTimeout: TimeoutAction;
+}
+type InterruptionMode = "allow" | "ignore" | "graceful";
+interface InterruptionPolicy {
+    readonly mode: InterruptionMode;
+    readonly minSpeechMs: number;
+    readonly trimOutputOnInterrupt: boolean;
+}
+interface IdempotencyPolicy {
+    readonly enabled: boolean;
+    readonly keyTemplate?: string;
+    readonly ttlMs?: number;
+}
+
+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";
+/**
+ * Coarse-grained category of a media event. Use `kind` (a string field on
+ * every `MediaEvent`) to filter or dispatch without depending on the
+ * finer-grained `type` literal.
+ *
+ *   - `"media"`     — audio data frames, audio delivery confirmations
+ *   - `"signal"`    — control signals (commit, interrupt, DTMF)
+ *   - `"lifecycle"` — stream start/end, errors
+ */
+type MediaEventKind = "media" | "signal" | "lifecycle";
+/**
+ * Compile-time map of every `MediaEventType` to its `MediaEventKind`. Using
+ * a `Record<MediaEventType, MediaEventKind>` (not a `Map`) means adding a
+ * new event type to the union forces a compile error here until the
+ * entry is added. The map is the single source of truth for "what kind
+ * is this event?"
+ */
+declare const EVENT_KIND_MAP: {
+    readonly "media.stream.started": "lifecycle";
+    readonly "media.stream.ended": "lifecycle";
+    readonly "media.audio.chunk": "media";
+    readonly "media.audio.committed": "media";
+    readonly "media.turn.commit_requested": "signal";
+    readonly "media.interrupt.requested": "signal";
+    readonly "dtmf.received": "signal";
+    readonly "media.error": "lifecycle";
+};
+declare function kindForMediaEvent(type: MediaEventType): MediaEventKind;
+declare const DTMF_DIGITS: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "#", "A", "B", "C", "D"];
+type DtmfDigit = (typeof DTMF_DIGITS)[number];
+declare function isDtmfDigit(value: string | undefined): value is DtmfDigit;
+interface MediaEventBase<T extends MediaEventType, D extends MediaDirection> {
+    readonly id: MediaEventId;
+    readonly type: T;
+    /**
+     * Coarse-grained category derived from `type`. Every media event must carry
+     * the category that corresponds to its event type; use `createMediaEvent`
+     * when constructing an event so the value cannot drift from the map below.
+     */
+    readonly kind: MediaEventKind;
+    readonly sessionId: SessionId;
+    readonly callId?: CallId;
+    readonly turnId?: TurnId;
+    readonly sequence: number;
+    readonly direction: D;
+    readonly timestamp: Timestamp;
+    /**
+     * Source-clock position of the audio. Input events carry the transport's own
+     * timeline (e.g. Twilio's media timestamp, the browser client's capture
+     * clock). Output chunks are constructed with `0` by synthesis adapters and
+     * restamped by `PipelineVoiceLoop` with its monotonic send clock before
+     * delivery; delivery proof travels via commit marks, not this field.
+     */
+    readonly monotonicOffsetMs: number;
+    readonly provider?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+type StreamEndReason = "completed" | "cancelled" | "remote_hangup" | "timeout" | "error";
+interface MediaStreamStartedEvent<D extends MediaDirection = MediaDirection> extends MediaEventBase<"media.stream.started", D> {
+    readonly format: AudioFormat;
+}
+interface MediaStreamEndedEvent<D extends MediaDirection = MediaDirection> extends MediaEventBase<"media.stream.ended", D> {
+    readonly reason: StreamEndReason;
+    readonly durationMs: number;
+}
+interface MediaAudioChunkEvent<D extends MediaDirection = MediaDirection> extends MediaEventBase<"media.audio.chunk", D> {
+    readonly audio: AudioPayload;
+}
+interface MediaAudioCommittedEvent extends MediaEventBase<"media.audio.committed", "output"> {
+    readonly durationMs: number;
+    readonly frameCount: number;
+    readonly sequenceRange: readonly [number, number];
+    readonly chunkIds: readonly MediaEventId[];
+}
+interface DtmfReceivedEvent extends MediaEventBase<"dtmf.received", "input"> {
+    readonly digit: DtmfDigit;
+    readonly durationMs?: number;
+}
+interface TurnCommitRequestedEvent extends MediaEventBase<"media.turn.commit_requested", "input"> {
+}
+interface InterruptRequestedEvent extends MediaEventBase<"media.interrupt.requested", "input"> {
+}
+interface MediaErrorEvent<D extends MediaDirection = MediaDirection> extends MediaEventBase<"media.error", D> {
+    readonly error: NormalizedError;
+}
+type InputMediaEvent = MediaStreamStartedEvent<"input"> | MediaStreamEndedEvent<"input"> | MediaAudioChunkEvent<"input"> | TurnCommitRequestedEvent | InterruptRequestedEvent | DtmfReceivedEvent | MediaErrorEvent<"input">;
+type OutputMediaEvent = MediaStreamStartedEvent<"output"> | MediaStreamEndedEvent<"output"> | MediaAudioChunkEvent<"output"> | MediaAudioCommittedEvent | MediaErrorEvent<"output">;
+type InternalMediaEvent = MediaStreamStartedEvent<"internal"> | MediaStreamEndedEvent<"internal"> | MediaErrorEvent<"internal">;
+type MediaEvent = InputMediaEvent | OutputMediaEvent | InternalMediaEvent;
+/**
+ * Initialization shape for any media event. The union preserves each event's
+ * type-specific fields while leaving out the derived `kind` field.
+ */
+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"];
+}>;
+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 attempt: number;
+    readonly signal: AbortSignal;
+    readonly logger: ToolLogger;
+    readonly tenant?: ToolTenant;
+}
+interface ToolLogger {
+    debug(message: string, fields?: Readonly<Record<string, unknown>>): void;
+    info(message: string, fields?: Readonly<Record<string, unknown>>): void;
+    warn(message: string, fields?: Readonly<Record<string, unknown>>): void;
+    error(message: string, fields?: Readonly<Record<string, unknown>>): void;
+}
+type ToolExecutor<TInput, TOutput> = (input: TInput, ctx: ToolExecutionContext) => Promise<TOutput>;
+interface ToolDefinition<TInput = unknown, TOutput = unknown> {
+    readonly id: ToolId;
+    readonly name: ToolName;
+    readonly description: string;
+    readonly version: string;
+    readonly inputSchema: JsonSchemaDocument;
+    readonly outputSchema: JsonSchemaDocument;
+    readonly timeout: TimeoutPolicy;
+    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.
+     */
+    readonly authScope?: readonly string[];
+    readonly tags?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly execute: ToolExecutor<TInput, TOutput>;
+}
+type ToolCallStatus = "queued" | "running" | "succeeded" | "failed" | "timed_out" | "cancelled";
+type ToolIdempotencyStatus = "claimed" | "succeeded" | "failed" | "timed_out" | "cancelled";
+interface ToolIdempotencyRecord {
+    readonly key: string;
+    readonly sessionId?: SessionId;
+    readonly toolId?: ToolId;
+    readonly toolVersion?: string;
+    readonly requestHash: string;
+    readonly status: ToolIdempotencyStatus;
+    readonly owner?: string;
+    readonly claimedFence?: number;
+    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;
+}
+interface ToolIdempotencyClaim {
+    readonly key: string;
+    readonly lease?: ToolIdempotencyLease;
+    readonly toolId?: ToolId;
+    readonly toolVersion?: string;
+    readonly requestHash: string;
+    readonly owner: string;
+    readonly ttlMs: number;
+}
+type ToolIdempotencyClaimResult = {
+    readonly status: "claimed";
+    readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "succeeded";
+    readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "in_progress";
+    readonly record: ToolIdempotencyRecord;
+} | {
+    readonly status: "conflict";
+    readonly record: ToolIdempotencyRecord;
+};
+interface ToolIdempotencyOutcome {
+    readonly status: Exclude<ToolIdempotencyStatus, "claimed">;
+    readonly ttlMs: number;
+    readonly owner: string;
+    readonly lease?: ToolIdempotencyLease;
+    readonly output?: unknown;
+    readonly error?: NormalizedError;
+}
+interface ToolIdempotencyStore {
+    lookup(key: string, requestHash: string): Promise<ToolIdempotencyRecord | null>;
+    claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
+    complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
+}
+interface ToolCallBase {
+    readonly toolCallId: ToolCallId;
+    readonly toolId: ToolId;
+    readonly toolName: ToolName;
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly input: unknown;
+    readonly attempts: number;
+    readonly idempotencyKey?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface QueuedToolCall extends ToolCallBase {
+    readonly status: "queued";
+    readonly queuedAt: Timestamp;
+}
+interface RunningToolCall extends ToolCallBase {
+    readonly status: "running";
+    readonly queuedAt: Timestamp;
+    readonly startedAt: Timestamp;
+}
+interface SucceededToolCall extends ToolCallBase {
+    readonly status: "succeeded";
+    readonly queuedAt: Timestamp;
+    readonly startedAt: Timestamp;
+    readonly endedAt: Timestamp;
+    readonly output: unknown;
+}
+type FailedToolCallStatus = "failed" | "timed_out" | "cancelled";
+interface FailedToolCall extends ToolCallBase {
+    readonly status: FailedToolCallStatus;
+    readonly queuedAt: Timestamp;
+    readonly startedAt: Timestamp;
+    readonly endedAt: Timestamp;
+    readonly error: NormalizedError;
+}
+type ToolCall = QueuedToolCall | RunningToolCall | SucceededToolCall | FailedToolCall;
+type TerminalToolCall = SucceededToolCall | FailedToolCall;
+
+type MemoryScope = "session" | "user" | "organization" | "workflow";
+type MemoryRef = {
+    readonly scope: "session";
+    readonly sessionId: SessionId;
+} | {
+    readonly scope: "user";
+    readonly userId: UserId;
+} | {
+    readonly scope: "organization";
+    readonly organizationId: OrganizationId;
+} | {
+    readonly scope: "workflow";
+    readonly workflowId: WorkflowId;
+};
+type MemoryKind = "fact" | "summary" | "open_item" | "entity_ref" | "raw" | "working_memory";
+interface MemoryEntry<T = unknown> {
+    readonly id: MemoryEntryId;
+    readonly ref: MemoryRef;
+    readonly key: string;
+    readonly kind: MemoryKind;
+    readonly value: T;
+    readonly version: number;
+    readonly createdAt: Timestamp;
+    readonly updatedAt: Timestamp;
+    readonly expiresAtMs?: number;
+    readonly tags?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Values in the provider-neutral memory contract must be finite, acyclic JSON
+ * data. Adapters validate this at runtime because TypeScript cannot protect
+ * JavaScript callers and JSONB-backed adapters cannot preserve richer objects.
+ */
+type JsonValue = null | string | boolean | number | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+interface MemoryPutOptions {
+    readonly tags?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly ttlMs?: number;
+    /**
+     * Trusted runtime attribution for a session-scoped entry. Adapters persist
+     * this separately from caller metadata so `deleteForUser` can erase a
+     * user's session data without treating arbitrary metadata as ownership.
+     * This is not an authorization mechanism; callers must already be trusted.
+     */
+    readonly sessionUserId?: UserId;
+    /**
+     * Runtime-only aggregate quota for a session-scoped write. Adapters that
+     * advertise `write.sessionQuota` must enforce this atomically, including
+     * entries written before the current process started. The byte count is the
+     * adapter's canonical UTF-8 JSON representation; callers should not assume
+     * identical byte counts across adapters with different storage encodings.
+     */
+    readonly maxSessionBytes?: number;
+    /**
+     * If true, the put is a no-op when an entry with the same (ref, key, kind)
+     * already exists; the existing entry is returned unchanged. If false and the
+     * entry exists with a different value, the call throws `RecordConflictError`.
+     * Default: false.
+     */
+    readonly ifNotExists?: boolean;
+}
+interface MemoryQuery {
+    readonly key?: string;
+    readonly prefix?: string;
+    readonly kind?: MemoryKind;
+    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.
+     */
+    readonly cursor?: string;
+}
+interface MemoryCapabilities {
+    readonly search: {
+        readonly exact: boolean;
+        readonly vector: boolean;
+        readonly hybrid: boolean;
+    };
+    readonly write: {
+        readonly explicit: boolean;
+        readonly implicit: boolean;
+        /** Whether `put(..., { maxSessionBytes })` is atomically enforced. */
+        readonly sessionQuota?: boolean;
+    };
+    readonly retention: {
+        readonly ttl: boolean;
+        readonly policy: boolean;
+    };
+    readonly purge: {
+        readonly perEntry: boolean;
+        readonly perScope: boolean;
+        readonly tenant: boolean;
+    };
+    readonly maxEntryBytes?: number;
+}
+interface Memory {
+    /** Implementation name (e.g., "in-memory", "postgres", "mem0"). */
+    readonly name: string;
+    /** Adapter version (semver-style string). */
+    readonly version: string;
+    /** Capability declaration used by the runtime to fail fast on mismatch. */
+    readonly capabilities: MemoryCapabilities;
+    get<T = unknown>(ref: MemoryRef, key: string, kind?: MemoryKind): Promise<MemoryEntry<T> | null>;
+    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>;
+}
+
+type CallStatus = "created" | "ringing" | "connected" | "active" | "held" | "ended" | "failed";
+/** Transports TVIC 1.0 can execute. SIP/WebRTC return alongside native topologies. */
+type MediaTransportKind = "websocket";
+interface MediaTransport {
+    readonly kind: MediaTransportKind;
+    readonly format: AudioFormat;
+    readonly remoteEndpoint?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface CallBase {
+    readonly id: CallId;
+    readonly provider: string;
+    readonly direction: CallDirection;
+    readonly from: string;
+    readonly to: string;
+    readonly sessionId?: SessionId;
+    readonly mediaTransport: MediaTransport;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly createdAt: Timestamp;
+}
+interface CreatedCall extends CallBase {
+    readonly status: "created";
+}
+interface RingingCall extends CallBase {
+    readonly status: "ringing";
+}
+interface ConnectedCall extends CallBase {
+    readonly status: "connected" | "active" | "held";
+    readonly startedAt: Timestamp;
+}
+interface EndedCall extends CallBase {
+    readonly status: "ended";
+    readonly startedAt: Timestamp;
+    readonly endedAt: Timestamp;
+}
+interface FailedCall extends CallBase {
+    readonly status: "failed";
+    readonly endedAt: Timestamp;
+    readonly error: NormalizedError;
+    readonly startedAt?: Timestamp;
+}
+type Call = CreatedCall | RingingCall | ConnectedCall | EndedCall | FailedCall;
+
+type SessionCancellationReason = "caller_hangup" | "transport_lost" | "recovery_expired" | "operator_requested" | "shutdown";
+type SessionStatus = "created" | "starting" | "active" | "interrupted" | "waiting_for_tool" | "ending" | "completed" | "failed" | "cancelled";
+interface SessionState {
+    readonly variables: Readonly<Record<string, unknown>>;
+    readonly currentTurnId?: TurnId;
+    readonly pendingToolCallIds: readonly ToolCallId[];
+    readonly turnSequence: number;
+}
+interface SessionBase {
+    readonly id: SessionId;
+    readonly agentId: AgentId;
+    readonly channel: ChannelKind;
+    readonly callId?: CallId;
+    /**
+     * Reserved for a future durable reference index. The runtime currently
+     * leaves this empty; memory adapters and session-end snapshots are the
+     * authoritative memory surfaces.
+     */
+    readonly memoryRefs: readonly MemoryEntryId[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly createdAt: Timestamp;
+    readonly state: SessionState;
+}
+interface CreatedSession extends SessionBase {
+    readonly status: "created";
+}
+interface StartingSession extends SessionBase {
+    readonly status: "starting";
+}
+interface ActiveSession extends SessionBase {
+    readonly status: "active" | "interrupted" | "waiting_for_tool" | "ending";
+    readonly startedAt: Timestamp;
+}
+type TerminalSessionStatus = "completed" | "failed" | "cancelled";
+interface TerminalSessionBase extends SessionBase {
+    readonly startedAt: Timestamp;
+    readonly endedAt: Timestamp;
+}
+interface CompletedSession extends TerminalSessionBase {
+    readonly status: "completed";
+}
+interface FailedSession extends TerminalSessionBase {
+    readonly status: "failed";
+    readonly error: NormalizedError;
+}
+interface CancelledSession extends TerminalSessionBase {
+    readonly status: "cancelled";
+    readonly cancelReason: SessionCancellationReason;
+}
+type TerminalSession = CompletedSession | FailedSession | CancelledSession;
+type Session = CreatedSession | StartingSession | ActiveSession | TerminalSession;
+
+type TurnCancellationReason = "barge_in" | "dtmf" | "explicit" | "timeout" | "not_heard" | "transport_lost" | "lease_lost" | "runtime_restarted";
+type TurnStatus = "started" | "listening" | "thinking" | "calling_tool" | "speaking" | "interrupted" | "completed" | "cancelled" | "failed";
+interface TurnInput {
+    readonly transcript?: string;
+    readonly mediaEventIds: readonly MediaEventId[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface TurnOutput {
+    readonly text?: string;
+    readonly mediaEventIds: readonly MediaEventId[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * 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 {
+    readonly id: TurnId;
+    readonly sessionId: SessionId;
+    readonly sequence: number;
+    readonly input: TurnInput;
+    readonly output: TurnOutput;
+    readonly toolCallIds: readonly ToolCallId[];
+    readonly startedAt: Timestamp;
+    readonly latency: TurnLatency;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface ActiveTurn extends TurnBase {
+    readonly status: "started" | "listening" | "thinking" | "calling_tool" | "speaking" | "interrupted";
+}
+interface CompletedTurn extends TurnBase {
+    readonly status: "completed";
+    readonly endedAt: Timestamp;
+}
+interface CancelledTurn extends TurnBase {
+    readonly status: "cancelled";
+    readonly endedAt: Timestamp;
+    readonly reason: TurnCancellationReason;
+}
+interface FailedTurn extends TurnBase {
+    readonly status: "failed";
+    readonly endedAt: Timestamp;
+    readonly error: NormalizedError;
+}
+type TerminalTurn = CompletedTurn | CancelledTurn | FailedTurn;
+type Turn = ActiveTurn | TerminalTurn;
+
+type ProviderKind = "telephony" | "stt" | "tts" | "llm" | "storage";
+/** Transports TVIC 1.0 executes. gRPC/http2 arrive with the SDK-based STT wave. */
+type ProviderTransport = "http" | "sse" | "websocket";
+type TurnDetectionMode = "provider" | "stt_endpointing" | "vad" | "semantic" | "manual";
+type ProviderDataPolicy = "standard" | "no_training" | "zero_retention";
+type CallControlCapability = "inbound" | "outbound" | "reject" | "progress" | "dtmf_receive" | "dtmf_send" | "transfer_blind" | "transfer_consult" | "early_media" | "conference";
+interface ProviderStreamingCapabilities {
+    /** Accepts incremental input instead of requiring a complete request payload. */
+    readonly input: boolean;
+    /** Produces incremental output instead of one complete response payload. */
+    readonly output: boolean;
+    /** Streaming is supported by the provider protocol, not emulated by chunked requests. */
+    readonly native: boolean;
+}
+interface ProviderCancellationCapabilities {
+    /** Active provider work can be stopped rather than merely ignored by TVIC. */
+    readonly request: boolean;
+    /** In-progress generated output can be stopped. */
+    readonly output: boolean;
+    /** Already queued transport audio can be removed before playout. */
+    readonly buffer: boolean;
+    /** Provider conversation state can be truncated to the audio actually played. */
+    readonly truncation: boolean;
+}
+interface ProviderAudioCapabilities {
+    /** Formats accepted at the TVIC adapter boundary after any wire decoding. */
+    readonly input?: readonly AudioFormat[];
+    /** Formats emitted at the TVIC adapter boundary before any wire encoding. */
+    readonly output?: readonly AudioFormat[];
+}
+interface ProviderToolCapabilities {
+    readonly functionCalling: boolean;
+    readonly parallelCalls: boolean;
+}
+interface ProviderPlayoutCapabilities {
+    /** The transport can remove queued output that has not played. */
+    readonly clearBuffer: boolean;
+    /** The transport acknowledges a marker after preceding audio is consumed. */
+    readonly acknowledgement: boolean;
+    /** The transport reports an exact played position, not only a marker boundary. */
+    readonly position: boolean;
+}
+/**
+ * Capabilities describe one configured adapter/deployment, not every feature sold by
+ * the provider. Mutable catalog facts may be omitted until they are verified.
+ */
+interface ProviderCapabilities {
+    readonly streaming: ProviderStreamingCapabilities;
+    readonly cancellation: ProviderCancellationCapabilities;
+    readonly transports: readonly ProviderTransport[];
+    readonly audio?: ProviderAudioCapabilities;
+    readonly languages?: readonly string[];
+    readonly models?: readonly string[];
+    readonly voices?: readonly string[];
+    readonly turnDetection?: readonly TurnDetectionMode[];
+    readonly tools?: ProviderToolCapabilities;
+    readonly playout?: ProviderPlayoutCapabilities;
+    readonly callControl?: readonly CallControlCapability[];
+    readonly regions?: readonly string[];
+    readonly dataPolicies?: readonly ProviderDataPolicy[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface Provider {
+    readonly name: string;
+    readonly kind: ProviderKind;
+    readonly version: string;
+    readonly capabilities: ProviderCapabilities;
+    readonly region?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * A requirement is opt-in: a present flag can only mean "must be supported".
+ * Callers omit capabilities they do not require instead of passing a misleading
+ * `false` that could be read as "must not support".
+ */
+type RequiredProviderCapabilities<T extends object> = {
+    readonly [K in keyof T]?: true;
+};
+interface ProviderRequirements {
+    readonly kind: ProviderKind;
+    readonly streaming?: RequiredProviderCapabilities<ProviderStreamingCapabilities>;
+    readonly cancellation?: RequiredProviderCapabilities<ProviderCancellationCapabilities>;
+    readonly transport?: ProviderTransport;
+    readonly inputFormat?: AudioFormat;
+    readonly outputFormat?: AudioFormat;
+    readonly language?: string;
+    readonly model?: string;
+    readonly voice?: string;
+    readonly turnDetection?: TurnDetectionMode;
+    readonly functionCalling?: boolean;
+    readonly parallelToolCalls?: boolean;
+    readonly playout?: RequiredProviderCapabilities<ProviderPlayoutCapabilities>;
+    readonly callControl?: readonly CallControlCapability[];
+    readonly region?: string;
+    readonly dataPolicy?: ProviderDataPolicy;
+}
+type ProviderCompatibilityIssueCode = "kind.unsupported" | "streaming.unsupported" | "cancellation.unsupported" | "transport.unsupported" | "audio.input_unsupported" | "audio.output_unsupported" | "language.unsupported" | "model.unsupported" | "voice.unsupported" | "turn_detection.unsupported" | "tools.unsupported" | "playout.unsupported" | "call_control.unsupported" | "region.unsupported" | "data_policy.unsupported";
+interface ProviderCompatibilityIssue {
+    readonly code: ProviderCompatibilityIssueCode;
+    readonly requirement: string;
+    readonly message: string;
+}
+type ProviderCompatibility = {
+    readonly compatible: true;
+    readonly issues: readonly [];
+} | {
+    readonly compatible: false;
+    readonly issues: readonly ProviderCompatibilityIssue[];
+};
+declare function evaluateProviderCompatibility(provider: Provider, requirements: ProviderRequirements): ProviderCompatibility;
+declare function sameAudioFormat(left: AudioFormat, right: AudioFormat): boolean;
+
+interface OutboundCallRequest {
+    readonly callId: CallId;
+    readonly sessionId: SessionId;
+    readonly from: string;
+    readonly to: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface InboundCallContext {
+    readonly call: Call;
+}
+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.
+     */
+    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>;
+    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 {
+    readonly kind: "telephony";
+    dial(request: OutboundCallRequest): Promise<CallHandle>;
+    accept(ctx: InboundCallContext): Promise<CallHandle>;
+    hangup(callId: CallId): Promise<void>;
+}
+
+interface SttEventBase {
+    readonly id: ProviderEventId;
+    readonly direction: "input";
+    readonly sessionId: SessionId;
+    readonly turnId?: TurnId;
+    readonly sequence: number;
+    readonly provider: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+type TranscriptSegmentEventType = "stt.partial" | "stt.final";
+/** A provider-defined transcript segment; final means immutable, not end-of-turn. */
+interface TranscriptSegmentEvent extends SttEventBase {
+    readonly type: TranscriptSegmentEventType;
+    readonly text: string;
+    readonly segmentId?: string;
+    readonly revision?: number;
+    readonly confidence?: number;
+    readonly language?: string;
+    readonly startTimestamp: Timestamp;
+    readonly endTimestamp: Timestamp;
+    /** Offset into the provider audio stream, independent from wall-clock receipt time. */
+    readonly audioStartMs?: number;
+    readonly audioEndMs?: number;
+}
+type TranscriptEndpointReason = "provider" | "silence" | "manual" | "max_duration";
+/** The STT/turn detector decided buffered final segments form a complete user turn. */
+interface TranscriptEndpointEvent extends SttEventBase {
+    readonly type: "stt.endpoint";
+    readonly reason: TranscriptEndpointReason;
+    readonly timestamp: Timestamp;
+    readonly audioOffsetMs?: number;
+    readonly confidence?: number;
+}
+interface TranscriptSpeechStartedEvent extends SttEventBase {
+    readonly type: "stt.speech.started";
+    readonly timestamp: Timestamp;
+    readonly audioOffsetMs?: number;
+}
+type TranscriptEvent = TranscriptSegmentEvent | TranscriptEndpointEvent | TranscriptSpeechStartedEvent;
+type TranscriptEventType = TranscriptEvent["type"];
+declare function isTranscriptSegmentEvent(event: TranscriptEvent): event is TranscriptSegmentEvent;
+
+interface SttOpenRequest {
+    readonly sessionId: SessionId;
+    readonly format: AudioFormat;
+    readonly language?: string;
+    readonly model?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly interimResults: boolean;
+    readonly vocabulary?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+type SttCommitMode = "provider" | "none";
+/**
+ * Origin of audio offsets emitted by an STT stream. Reconnectable streams must
+ * declare this so the runtime can keep one session-relative timeline across fresh
+ * provider generations.
+ */
+type SttTimestampOrigin = "session" | "generation";
+declare const STT_STREAM_ENDED_REASON = "stream_ended";
+interface SttStream {
+    readonly events: AsyncIterable<TranscriptEvent>;
+    readonly commitMode?: SttCommitMode;
+    readonly timestampOrigin?: SttTimestampOrigin;
+    sendAudio(chunk: InputAudioChunk): Promise<void>;
+    commit(): Promise<void>;
+    close(): Promise<void>;
+}
+interface SpeechToTextProvider extends Provider {
+    readonly kind: "stt";
+    open(request: SttOpenRequest): Promise<SttStream>;
+}
+
+interface TtsSessionOpenRequest {
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly voice?: string;
+    readonly model?: string;
+    readonly format: AudioFormat;
+    readonly speed?: number;
+    readonly timestamps?: boolean;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    /** Aborts startup (e.g. a connect timeout) so a stalled connection does not leak. */
+    readonly signal?: AbortSignal;
+}
+interface TtsSynthesisRequest extends TtsSessionOpenRequest {
+    readonly text: string;
+    readonly stream: boolean;
+}
+type TtsAlignmentUnit = "character" | "word" | "phoneme";
+type TtsFlushId = string | number;
+type TtsFlushAcknowledgement = "provider" | "transport";
+interface TtsFlushResult {
+    readonly id: TtsFlushId;
+    readonly acknowledgedBy: TtsFlushAcknowledgement;
+}
+interface TtsAlignmentEvent {
+    readonly type: "tts.alignment";
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly sequence: number;
+    readonly provider: string;
+    readonly timestamp: Timestamp;
+    readonly unit: TtsAlignmentUnit;
+    readonly tokens: readonly string[];
+    readonly startMs: readonly number[];
+    readonly endMs: readonly number[];
+    readonly flushId?: TtsFlushId;
+}
+interface TtsFlushCompletedEvent {
+    readonly type: "tts.flush.completed";
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly sequence: number;
+    readonly provider: string;
+    readonly timestamp: Timestamp;
+    readonly flushId: TtsFlushId;
+    readonly acknowledgedBy: TtsFlushAcknowledgement;
+}
+type TtsEvent = OutputAudioChunk | MediaAudioCommittedEvent | TtsAlignmentEvent | TtsFlushCompletedEvent;
+interface TtsStream {
+    readonly events: AsyncIterable<TtsEvent>;
+    cancel(): Promise<void>;
+}
+/** 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 {
+    readonly kind: "tts";
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+}
+interface IncrementalTextToSpeechProvider extends TextToSpeechProvider {
+    openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
+}
+declare function isIncrementalTextToSpeechProvider(provider: TextToSpeechProvider): provider is IncrementalTextToSpeechProvider;
+
+type LlmMessageRole = "system" | "user" | "assistant" | "tool";
+interface LlmMessage {
+    readonly role: LlmMessageRole;
+    readonly content: string;
+    readonly toolCallRef?: string;
+    readonly toolName?: ToolName;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface LlmInlineToolCall {
+    readonly callRef: string;
+    readonly toolName: ToolName;
+    readonly input: unknown;
+}
+interface LlmCompletionRequest {
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly model: string;
+    readonly messages: readonly LlmMessage[];
+    readonly tools?: readonly ToolDefinition[];
+    readonly stream: boolean;
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    /** Stable, non-PII identifier forwarded to providers with a dedicated safety field. */
+    readonly safetyIdentifier?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    /** Aborts startup (e.g. a connect timeout) so a stalled request does not leak. */
+    readonly signal?: AbortSignal;
+}
+interface LlmEventBase {
+    readonly id: ProviderEventId;
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly sequence: number;
+    readonly provider: string;
+    readonly timestamp: Timestamp;
+}
+interface LlmUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cachedTokens?: number;
+}
+type LlmStreamEvent = (LlmEventBase & {
+    readonly type: "llm.started";
+    readonly model: string;
+}) | (LlmEventBase & {
+    readonly type: "llm.token";
+    readonly text: string;
+}) | (LlmEventBase & {
+    readonly type: "llm.tool_call";
+    readonly call: LlmInlineToolCall;
+}) | (LlmEventBase & {
+    readonly type: "llm.completed";
+    readonly text: string;
+    readonly toolCalls: readonly LlmInlineToolCall[];
+    readonly usage?: LlmUsage;
+}) | (LlmEventBase & {
+    readonly type: "llm.failed";
+    readonly error: NormalizedError;
+});
+interface LlmCompletion {
+    readonly events: AsyncIterable<LlmStreamEvent>;
+    cancel(): Promise<void>;
+}
+interface LLMProvider extends Provider {
+    readonly kind: "llm";
+    complete(request: LlmCompletionRequest): Promise<LlmCompletion>;
+}
+
+interface AgentMemoryPolicy {
+    readonly enabled: boolean;
+    readonly scopes: readonly MemoryScope[];
+    /** Maximum cumulative UTF-8 bytes admitted to this session's memory scope. */
+    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.
+     */
+    readonly deleteSessionScopeOnEnd?: boolean;
+    /**
+     * If true, the LLM is given a `remember_fact` tool to write to memory.
+     * Default false — explicit opt-in per agent.
+     */
+    readonly canLlmWrite?: boolean;
+    /**
+     * What to load into the agent's context before a call starts.
+     * - "none": do not load any memory.
+     * - "all": load all enabled scopes (default).
+     * - "kind:fact" / "kind:summary" / "kind:open_item" / "kind:entity_ref" / "kind:raw" / "kind:working_memory":
+     *   load only entries of the given kind.
+     */
+    readonly preCallLoad?: "none" | "all" | `kind:${MemoryKind}`;
+}
+/**
+ * Bounds the live prompt assembled for each LLM request. These limits apply
+ * to live execution context, not recordings or durable operational evidence.
+ */
+interface AgentContextPolicy {
+    /** Maximum serialized UTF-8 bytes in one LLM request's messages. */
+    readonly maxHistoryBytes?: number;
+    /** Maximum number of messages in one LLM request, including system/current/active messages. */
+    readonly maxHistoryMessages?: number;
+    /** Maximum serialized UTF-8 bytes rendered from pre-call memory/static context. */
+    readonly maxPreCallBytes?: number;
+    /** Maximum pre-call memory entries loaded from one adapter scope. */
+    readonly maxPreCallEntries?: number;
+}
+interface AgentAudioPolicy {
+    readonly input: AudioFormat;
+    readonly output: AudioFormat;
+}
+interface AgentProviders {
+    readonly telephony: TelephonyProvider;
+    readonly stt: SpeechToTextProvider;
+    readonly llm: LLMProvider;
+    readonly tts?: TextToSpeechProvider;
+}
+interface PersonaConfig {
+    /**
+     * Per-tenant context resolution at session start. The runtime calls
+     * this once when a session is attached; the result is
+     * merged into the system prompt alongside the pre-call memory block.
+     */
+    readonly resolveTenantContext?: (input: {
+        readonly sessionId: SessionId;
+        readonly userId?: UserId;
+        readonly organizationId?: OrganizationId;
+        readonly workflowId?: WorkflowId;
+    }) => Promise<{
+        /** Optional override for the agent's instructions. */
+        readonly instructionsOverride?: string;
+        /** Optional pre-call variables, e.g. `{{customer_name}} = "Ada"`. */
+        readonly variables?: ReadonlyMap<string, string>;
+    }>;
+    /**
+     * Per-turn context resolution. The runtime calls this before each
+     * turn, allowing the prompt to adapt as the call progresses (e.g.,
+     * "after turn 3, soften the language"). The default behavior is to
+     * call this on every turn; the user can return the same
+     * `instructionsOverride` to keep the prompt stable.
+     */
+    readonly systemPromptForTurn?: (input: {
+        readonly sessionId: SessionId;
+        readonly turnNumber: number;
+    }) => Promise<{
+        readonly instructionsOverride?: string;
+    }>;
+}
+interface Agent {
+    readonly id: AgentId;
+    readonly name: string;
+    readonly version: string;
+    readonly instructions: string;
+    readonly tools: readonly ToolDefinition[];
+    readonly providers: AgentProviders;
+    readonly audioPolicy: AgentAudioPolicy;
+    readonly memoryPolicy: AgentMemoryPolicy;
+    readonly interruptionPolicy: InterruptionPolicy;
+    readonly contextPolicy?: AgentContextPolicy;
+    /** Per-tenant context resolution. Optional. */
+    readonly persona?: PersonaConfig;
+    /** Per-operation timeout for provider streams (wired into the loop's stall guard). */
+    readonly timeoutPolicy: TimeoutPolicy;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+interface SessionLease {
+    readonly sessionId: SessionId;
+    readonly holder: string;
+    readonly fence: number;
+    readonly acquiredAtMs: number;
+    readonly renewedAtMs: number;
+    readonly expiresAtMs: number;
+}
+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>;
+    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>;
+}
+interface DurableOutboxEvent {
+    readonly id: string;
+    readonly aggregateType: "session" | "turn" | "tool_call";
+    readonly aggregateId: string;
+    readonly sessionId: SessionId;
+    readonly version: number;
+    readonly fence: number;
+    readonly envelope: Readonly<Record<string, unknown>>;
+}
+interface SessionRuntimeMetadata {
+    readonly monotonicStartedAtMs: number;
+    readonly lastActivityWallAtMs?: number;
+    readonly clockEpoch?: number;
+    readonly clockDiscontinuityMs?: number;
+}
+interface TurnRuntimeMetadata {
+    readonly monotonicStartedAtMs: number;
+    readonly recoveryGapMs?: number;
+}
+interface ToolCallRuntimeMetadata {
+    readonly monotonicQueuedAtMs: number;
+}
+interface StoredSessionRecord {
+    readonly session: Session;
+    readonly runtime: SessionRuntimeMetadata;
+    /** Persistence-local aggregate version used for outbox ordering/fencing. */
+    readonly version?: number;
+}
+interface StoredTurnRecord {
+    readonly turn: Turn;
+    readonly runtime: TurnRuntimeMetadata;
+    readonly version?: number;
+}
+interface StoredToolCallRecord {
+    readonly toolCall: ToolCall;
+    readonly runtime: ToolCallRuntimeMetadata;
+    readonly version?: number;
+}
+interface SessionStore {
+    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>;
+}
+interface TurnStore {
+    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>;
+}
+interface ToolCallStore {
+    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 DurableSessionTransaction {
+    getSession(id: SessionId): Promise<StoredSessionRecord | null>;
+    putSession(record: StoredSessionRecord): Promise<void>;
+    updateSession(id: SessionId, updater: (record: StoredSessionRecord) => StoredSessionRecord): Promise<StoredSessionRecord>;
+    getTurn(sessionId: SessionId, id: TurnId): Promise<StoredTurnRecord | null>;
+    listTurns(sessionId: SessionId): Promise<readonly StoredTurnRecord[]>;
+    putTurn(record: StoredTurnRecord): Promise<void>;
+    updateTurn(sessionId: SessionId, id: TurnId, updater: (record: StoredTurnRecord) => StoredTurnRecord): Promise<StoredTurnRecord>;
+    getToolCall(sessionId: SessionId, id: ToolCallId): Promise<StoredToolCallRecord | null>;
+    listToolCalls(sessionId: SessionId): Promise<readonly StoredToolCallRecord[]>;
+    putToolCall(record: StoredToolCallRecord): Promise<void>;
+    updateToolCall(sessionId: SessionId, id: ToolCallId, updater: (record: StoredToolCallRecord) => StoredToolCallRecord): Promise<StoredToolCallRecord>;
+    appendOutbox(event: DurableOutboxEvent): Promise<void>;
+}
+interface DurableRuntimeStore {
+    readonly sessions: SessionStore;
+    readonly turns: TurnStore;
+    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.
+     */
+    runUnfencedSessionTransaction?<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
+}
+
+interface RuntimeOptions {
+    readonly sessionStore?: SessionStore;
+    readonly turnStore?: TurnStore;
+    readonly toolCallStore?: ToolCallStore;
+    readonly clock?: Clock;
+    readonly idGenerator?: IdGenerator;
+    readonly durableStore?: DurableRuntimeStore;
+    /** 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;
+    };
+}
+/**
+ * @deprecated Use `PreCallContext` and `PreCallContextResolver`. The
+ * memory-only variant remains as a separate type for one compatibility release.
+ */
+type PreCallMemoryResolver = (input: {
+    readonly userId?: UserId;
+    readonly organizationId?: OrganizationId;
+    readonly workflowId?: WorkflowId;
+    readonly sessionId: SessionId;
+    readonly memory: Memory;
+}) => Promise<PreCallMemoryContext>;
+interface PreCallMemoryContext {
+    readonly entries: ReadonlyMap<string, MemoryEntry>;
+    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 finalMemorySnapshot: SessionEndMemorySnapshot;
+    /** Result of the ordered session-memory drain and optional purge. */
+    readonly memoryFinalization: SessionMemoryFinalization;
+    readonly wallClockMs: number;
+}
+type SessionMemoryFinalization = {
+    readonly status: "skipped";
+} | {
+    readonly status: "completed";
+    readonly deletedEntries: number;
+} | {
+    readonly status: "failed";
+    readonly error: NormalizedError;
+} | {
+    readonly status: "timed_out";
+    readonly phase: "drain" | "purge";
+    readonly timeoutMs: number;
+};
+interface SessionEndMemorySnapshot {
+    readonly user?: ReadonlyMap<string, MemoryEntry>;
+    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;
+    onSessionEnd?(event: SessionEndEvent): void;
+}
+interface HealthSnapshot {
+    readonly ok: boolean;
+    readonly checks?: Readonly<Record<string, HealthCheckResult>>;
+}
+interface HealthCheckResult {
+    readonly ok: boolean;
+    readonly latencyMs?: number;
+    readonly message?: string;
+}
+interface DurableRuntimeMetric {
+    readonly name: string;
+    readonly value: number;
+    readonly atMs: number;
+    readonly attributes?: Readonly<Record<string, string | number | boolean>>;
+}
+interface DurableRuntimePolicy {
+    readonly criticalWriteTimeoutMs: number;
+    readonly criticalSessionP50BudgetMs: number;
+    readonly criticalSessionP95BudgetMs: number;
+    readonly criticalSessionP99BudgetMs: number;
+    readonly turnStartP95BudgetMs: number;
+    readonly turnStartP99BudgetMs: number;
+    readonly toolPathP95BudgetMs: number;
+    readonly toolPathP99BudgetMs: number;
+    readonly failoverP95BudgetMs: number;
+    readonly failoverP99BudgetMs: number;
+    readonly failoverAlertBudgetMs: number;
+    readonly bargeCheckpointRetryBudgetMs: number;
+    readonly bargeCheckpointMaxAttempts: number;
+    readonly persistenceRecoveryGraceMs: number;
+    readonly leaseTtlMs: number;
+    readonly leaseHeartbeatMs: number;
+    readonly recoveryPollMs: number;
+    readonly recoveryGraceMs: number;
+    readonly terminalRetentionMs: number;
+}
+declare const DEFAULT_DURABLE_RUNTIME_POLICY: DurableRuntimePolicy;
+type SessionAttachmentHealth = "healthy" | "persistence_degraded" | "lease_lost" | "detached";
+interface StartSessionOptions {
+    readonly channel: ChannelKind;
+    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";
+type EndSessionRequest = {
+    readonly reason: "completed";
+} | {
+    readonly reason: "cancelled";
+    readonly cancelReason: SessionCancellationReason;
+} | {
+    readonly reason: "failed";
+    readonly error: NormalizedError;
+} | {
+    readonly reason: "timeout";
+    readonly error: NormalizedError;
+};
+interface StartTurnRequest {
+    readonly sessionId: SessionId;
+    readonly input?: TurnInput;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+type EndTurnRequest = {
+    readonly reason: "completed";
+    readonly output?: TurnOutput;
+    readonly latency?: TurnLatency;
+    readonly toolCallIds?: readonly ToolCallId[];
+} | {
+    readonly reason: "cancelled";
+    readonly cancelReason: TurnCancellationReason;
+    readonly output?: TurnOutput;
+    readonly latency?: TurnLatency;
+    readonly toolCallIds?: readonly ToolCallId[];
+} | {
+    readonly reason: "failed";
+    readonly error: NormalizedError;
+    readonly output?: TurnOutput;
+    readonly latency?: TurnLatency;
+    readonly toolCallIds?: readonly ToolCallId[];
+};
+interface SessionSnapshot {
+    readonly session: Session;
+    readonly turns: readonly Turn[];
+    readonly toolCalls: readonly ToolCall[];
+}
+interface StartAttachedSessionOptions extends StartSessionOptions {
+    readonly holderId?: string;
+}
+interface SessionAttachment {
+    readonly session: ActiveSession;
+    readonly snapshot: SessionSnapshot;
+    readonly lease: SessionLease | null;
+    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`.
+     */
+    readonly preCallMemory?: PreCallMemoryContext;
+}
+interface RuntimeServiceLifecycle {
+    /** Starts the runtime. A runtime can be started once; create a new runtime after stop. */
+    start(): 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 {
+    startSession(agent: Agent, options: StartSessionOptions): Promise<ActiveSession>;
+    startAttachedSession(agent: Agent, options: StartAttachedSessionOptions): Promise<SessionAttachment>;
+    attachSession(agent: Agent, sessionId: SessionId, options?: {
+        readonly holderId?: string;
+        readonly memoryUserId?: UserId;
+        readonly organizationId?: OrganizationId;
+        readonly workflowId?: WorkflowId;
+    }): Promise<SessionAttachment>;
+    getSession(id: SessionId): Promise<Session | null>;
+    endSession(id: SessionId, request: EndSessionRequest): Promise<TerminalSession>;
+    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;
+    readonly toolIdempotencyStore?: ToolIdempotencyStore;
+    readonly memory?: Memory;
+}
+
+interface TerminalSessionDraft {
+    readonly id: SessionId;
+    readonly agentId: AgentId;
+    readonly channel: ChannelKind;
+    readonly callId?: CallId;
+    /** Reserved; the runtime currently leaves this reference index empty. */
+    readonly memoryRefs: readonly MemoryEntryId[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly createdAt: Timestamp;
+    readonly state: SessionState;
+    readonly startedAt: Timestamp;
+    readonly endedAt: Timestamp;
+}
+declare function terminalSessionFromRequest(draft: TerminalSessionDraft, request: EndSessionRequest): TerminalSession;
+declare function terminalTurnFromRequest(turn: ActiveTurn, request: EndTurnRequest, endedAt: Timestamp, durationMs: number): TerminalTurn;
+declare function isTerminalSession(session: Session): session is TerminalSession;
+declare function isTerminalTurn(turn: Turn): turn is TerminalTurn;
+
+interface ProviderClock {
+    now(): Timestamp;
+}
+
+interface TwilioMediaStreamSocket {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    on(event: "message", handler: (data: WebSocket.RawData) => void): this;
+    on(event: "close", handler: () => void): this;
+    on(event: "error", handler: (error: Error) => void): this;
+}
+interface TwilioMediaStreamCallHandleOptions {
+    readonly socket: TwilioMediaStreamSocket;
+    readonly callId: CallId;
+    readonly sessionId: SessionId;
+    readonly inputFormat?: AudioFormat;
+    readonly outputFormat?: AudioFormat;
+    readonly clock?: ProviderClock;
+}
+declare class TwilioMediaStreamCallHandle implements CallHandle {
+    #private;
+    readonly options: TwilioMediaStreamCallHandleOptions;
+    readonly events: AsyncIterable<InboundMediaEvent>;
+    constructor(options: TwilioMediaStreamCallHandleOptions);
+    readonly callId: CallId;
+    send(event: OutputMediaEvent): Promise<boolean>;
+    clear(): Promise<void>;
+    close(reason: StreamEndReason): Promise<void>;
+    confirmPlayout(markId: string, timeoutMs: number): Promise<boolean>;
+}
+declare class TwilioMediaStreamsProvider implements TelephonyProvider {
+    #private;
+    readonly name: "twilio-media-streams";
+    readonly kind = "telephony";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: true;
+            buffer: true;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            input: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+            output: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        playout: {
+            clearBuffer: true;
+            acknowledgement: true;
+            position: false;
+        };
+    };
+    dial(): Promise<CallHandle>;
+    accept(ctx: Parameters<TelephonyProvider["accept"]>[0]): Promise<CallHandle>;
+    attachWebSocket(socket: TwilioMediaStreamSocket, callId: CallId, sessionId: SessionId): void;
+    acceptWebSocket(socket: TwilioMediaStreamSocket, callId: CallId, sessionId: SessionId): Promise<TwilioMediaStreamCallHandle>;
+    hangup(_callId: CallId): Promise<void>;
+}
+declare function createTwilioMediaStreamsProvider(): TwilioMediaStreamsProvider;
+
+declare const WEB_CLIENT_AUDIO_CLOSE_CODES: {
+    readonly protocol: 4400;
+    readonly heartbeatTimeout: 4408;
+    readonly superseded: 4409;
+    readonly maxDuration: 4410;
+    readonly resourceLimit: 4413;
+    readonly operatorTerminated: 4500;
+};
+declare const WEB_CLIENT_AUDIO_DEFAULTS: {
+    readonly heartbeatIntervalMs: 5000;
+    readonly heartbeatTimeoutMs: 10000;
+    readonly maxSessionDurationMs: number;
+    readonly maxPendingEvents: 512;
+    readonly maxInputFramesPerSecond: 200;
+    readonly maxPendingAcks: 128;
+};
+interface WebClientAudioSocket {
+    readonly readyState: number;
+    send(data: string | Buffer): void;
+    close(code?: number, reason?: string): 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;
+}
+type ConnectionObservabilityEvent = {
+    readonly type: "session_started";
+    readonly callId: CallId;
+    readonly sessionId: SessionId;
+} | {
+    readonly type: "session_ended";
+    readonly callId: CallId;
+    readonly sessionId: SessionId;
+    readonly closeCode: number;
+    readonly reason: string;
+} | {
+    readonly type: "auth_rejected";
+    readonly reason: string;
+} | {
+    readonly type: "reconnect_detected";
+    readonly sessionRef: string;
+    readonly supersedes: string;
+};
+type WebClientAudioConnectionEvent = ConnectionObservabilityEvent;
+interface WebClientAudioCallHandleOptions {
+    readonly socket: WebClientAudioSocket;
+    readonly callId: CallId;
+    readonly sessionId: SessionId;
+    readonly heartbeatIntervalMs?: number;
+    readonly heartbeatTimeoutMs?: number;
+    readonly maxSessionDurationMs?: number;
+    readonly maxBinaryFrameBytes?: number;
+    readonly maxInputBytesPerSecond?: number;
+    readonly maxPendingEvents?: number;
+    readonly maxInputFramesPerSecond?: number;
+    readonly maxPendingAcks?: number;
+    readonly expectedMode?: "push_to_talk" | "continuous";
+    readonly clock?: ProviderClock;
+    readonly nowMs?: () => number;
+    readonly onConnectionEvent?: (event: ConnectionObservabilityEvent) => void;
+    readonly onClosed?: () => void;
+}
+declare class WebClientAudioCallHandle implements CallHandle {
+    #private;
+    readonly callId: CallId;
+    readonly events: AsyncIterable<InboundMediaEvent>;
+    constructor(options: WebClientAudioCallHandleOptions);
+    send(event: OutputMediaEvent): Promise<boolean>;
+    deliverText(turnId: TurnId, sequence: number, text: string): Promise<boolean>;
+    clear(): Promise<void>;
+    close(reason: StreamEndReason): Promise<void>;
+    terminate(code: number, reason: string): void;
+    confirmPlayout(markId: string, timeoutMs: number): Promise<boolean>;
+}
+interface WebClientAudioProviderOptions extends Omit<WebClientAudioCallHandleOptions, "socket" | "callId" | "sessionId" | "onClosed" | "expectedMode"> {
+}
+declare class WebClientAudioProvider implements TelephonyProvider {
+    #private;
+    readonly name: "web-client-audio";
+    readonly kind = "telephony";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: true;
+            buffer: true;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            input: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+            output: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        playout: {
+            clearBuffer: true;
+            acknowledgement: true;
+            position: false;
+        };
+    };
+    constructor(options?: WebClientAudioProviderOptions);
+    dial(): Promise<CallHandle>;
+    accept(ctx: Parameters<TelephonyProvider["accept"]>[0]): Promise<CallHandle>;
+    attachWebSocket(socket: WebClientAudioSocket, callId: CallId, sessionId: SessionId): void;
+    acceptWebSocket(socket: WebClientAudioSocket, callId: CallId, sessionId: SessionId, connectionOptions?: {
+        readonly expectedMode?: "push_to_talk" | "continuous";
+    }): Promise<WebClientAudioCallHandle>;
+    hangup(callId: CallId): Promise<void>;
+    supersede(callId: CallId): Promise<void>;
+}
+declare function createWebClientAudioProvider(options?: WebClientAudioProviderOptions): WebClientAudioProvider;
+
+interface DeepgramSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly clock?: ProviderClock;
+    readonly endpointingMs?: number;
+    readonly vadEvents?: boolean;
+    readonly punctuate?: boolean;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+}
+declare class DeepgramSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "deepgram";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        languages: string[];
+        audio: {
+            input: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly ["nova-3", "nova-2"];
+        turnDetection: ("stt_endpointing" | "vad")[];
+    };
+    constructor(options: DeepgramSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+}
+declare function createDeepgramSttProvider(options: DeepgramSttProviderOptions): DeepgramSttProvider;
+
+type SarvamOutputMode = "transcribe" | "translate" | "verbatim" | "translit" | "codemix";
+interface SarvamSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly mode?: SarvamOutputMode;
+    readonly highVadSensitivity?: boolean;
+    readonly vadSignals?: boolean;
+    readonly flushSignal?: boolean;
+    readonly inputAudioCodec?: "pcm_s16le" | "pcm_l16" | "pcm_raw";
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+}
+declare class SarvamSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "sarvam";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        languages: readonly ["hi-IN", "bn-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "od-IN", "pa-IN", "ta-IN", "te-IN", "as-IN", "ur-IN", "ne-IN", "kok-IN", "ks-IN", "sd-IN", "sa-IN", "sat-IN", "mni-IN", "brx-IN", "mai-IN", "doi-IN", "en-IN"];
+        audio: {
+            input: ({
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            } | {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 8000;
+                readonly channels: 1;
+            })[];
+        };
+        models: readonly ["saaras:v3", "saaras:v4"];
+        turnDetection: ("vad" | "manual")[];
+        metadata: {
+            interimResults: boolean;
+            outputModes: string[];
+        };
+    };
+    constructor(options: SarvamSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+}
+declare function createSarvamSttProvider(options: SarvamSttProviderOptions): SarvamSttProvider;
+
+type ElevenLabsSttCommitStrategy = "manual" | "vad";
+interface ElevenLabsSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly modelId?: string;
+    readonly commitStrategy?: ElevenLabsSttCommitStrategy;
+    readonly includeTimestamps?: boolean;
+    readonly includeLanguageDetection?: boolean;
+    readonly vadThreshold?: number;
+    readonly vadSilenceThresholdSecs?: number;
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+}
+declare class ElevenLabsSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "elevenlabs-stt-realtime";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            input: readonly [{
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 8000;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 22050;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 24000;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 44100;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 48000;
+                readonly channels: 1;
+            }];
+        };
+        models: readonly ["scribe_v2_realtime"];
+        turnDetection: ("vad" | "manual")[];
+        metadata: {
+            realtimeModel: string;
+            partialTranscripts: boolean;
+        };
+    };
+    constructor(options: ElevenLabsSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+}
+declare function createElevenLabsSttProvider(options: ElevenLabsSttProviderOptions): ElevenLabsSttProvider;
+
+interface AssemblyAiSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly modelId?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly formatTurns?: boolean;
+    readonly prompt?: string;
+    readonly languageDetection?: boolean;
+    readonly minTurnSilenceMs?: number;
+    readonly maxTurnSilenceMs?: number;
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+}
+declare class AssemblyAiSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "assemblyai-stt";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            input: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly ["u3-rt-pro"];
+        turnDetection: "stt_endpointing"[];
+        metadata: {
+            realtimeModel: "u3-rt-pro";
+            partialTranscripts: boolean;
+            formattedTurns: boolean;
+        };
+    };
+    constructor(options: AssemblyAiSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+}
+declare function createAssemblyAiSttProvider(options: AssemblyAiSttProviderOptions): AssemblyAiSttProvider;
+
+interface SonioxStructuredContext {
+    readonly general?: readonly Readonly<{
+        key: string;
+        value: string;
+    }>[];
+    readonly text?: string;
+    readonly terms?: readonly string[];
+}
+interface SonioxSttProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly modelId?: string;
+    readonly allowUnknownModel?: boolean;
+    readonly context?: SonioxStructuredContext;
+    readonly enableEndpointDetection?: boolean;
+    readonly maxEndpointDelayMs?: number;
+    readonly endpointSensitivity?: number;
+    readonly endpointLatencyAdjustmentLevel?: number;
+    readonly enableLanguageIdentification?: boolean;
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+}
+declare class SonioxSttProvider implements SpeechToTextProvider {
+    #private;
+    readonly name: "soniox-stt";
+    readonly kind = "stt";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            input: readonly [{
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 8000;
+                readonly channels: 1;
+            }, {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }];
+        };
+        models: readonly ["stt-rt-v5"];
+        turnDetection: ("stt_endpointing" | "manual")[];
+        metadata: {
+            realtimeModel: "stt-rt-v5";
+            partialTranscripts: boolean;
+            tokenFinality: boolean;
+        };
+    };
+    constructor(options: SonioxSttProviderOptions);
+    open(request: SttOpenRequest): Promise<SttStream>;
+}
+declare function createSonioxSttProvider(options: SonioxSttProviderOptions): SonioxSttProvider;
+
+interface OpenAiResponsesLlmProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly clock?: ProviderClock;
+}
+declare class OpenAiResponsesLlmProvider implements LLMProvider {
+    #private;
+    readonly name: "openai-responses";
+    readonly kind = "llm";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: false;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: true;
+            buffer: false;
+            truncation: false;
+        };
+        transports: ("http" | "sse")[];
+        models: readonly ["gpt-5", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini"];
+        tools: {
+            functionCalling: true;
+            parallelCalls: true;
+        };
+    };
+    constructor(options: OpenAiResponsesLlmProviderOptions);
+    complete(request: LlmCompletionRequest): Promise<LlmCompletion>;
+}
+declare function createOpenAiResponsesLlmProvider(options: OpenAiResponsesLlmProviderOptions): OpenAiResponsesLlmProvider;
+
+interface CartesiaTtsProviderOptions {
+    readonly apiKey: string;
+    readonly url?: string;
+    readonly voiceId: string;
+    readonly modelId?: string;
+    readonly language?: string;
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+}
+declare class CartesiaTtsProvider implements IncrementalTextToSpeechProvider {
+    #private;
+    readonly name: "cartesia";
+    readonly kind = "tts";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            output: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly ["sonic-3", "sonic-2"];
+    };
+    constructor(options: CartesiaTtsProviderOptions);
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+    openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
+}
+declare function createCartesiaTtsProvider(options: CartesiaTtsProviderOptions): CartesiaTtsProvider;
+
+/**
+ * Vendor facts that change on the provider's release schedule rather than ours:
+ * model catalogs and wire protocol versions.
+ *
+ * These deliberately live at the adapter edge instead of in `@tvic/core`. A model
+ * list is not a runtime contract, it is dated evidence. Compiling it into core made
+ * two things invisible: how old the claim was, and the fact that a vendor deprecating
+ * a model silently turns `capabilities.models` into a false statement.
+ *
+ * Every entry carries the date it was verified and the document it came from.
+ * Reverify before relying on an entry for a production or purchasing decision, and
+ * treat a stale `verifiedAt` as a reason to omit a capability rather than assert it.
+ */
+interface ProviderCatalogEntry {
+    /** ISO date the model list below was last checked against `source`. */
+    readonly verifiedAt: string;
+    /** Official provider documentation the entry was read from. */
+    readonly source: string;
+    /** Model used when the caller does not choose one. */
+    readonly defaultModel: string;
+    /** Models this adapter is known to work with, not the vendor's full catalog. */
+    readonly models: readonly string[];
+}
+/**
+ * TVIC maturity labels are our release claim, not a vendor guarantee.
+ * `experimental` means the adapter has deterministic contract coverage but
+ * still needs a credential-gated live-service check before it can be called
+ * stable in release notes.
+ */
+type ProviderStability = "stable" | "experimental" | "deferred";
+declare const PROVIDER_STABILITY: Readonly<{
+    readonly deepgram: "experimental";
+    readonly sarvam: "experimental";
+    readonly elevenlabsStt: "experimental";
+    readonly assemblyai: "experimental";
+    readonly soniox: "experimental";
+    readonly openaiResponses: "experimental";
+    readonly cartesia: "experimental";
+    readonly elevenlabs: "experimental";
+    readonly webClientAudio: "stable";
+    readonly twilio: "stable";
+}>;
+declare const PROVIDER_CATALOG: {
+    readonly deepgram: {
+        readonly verifiedAt: "2026-07-24";
+        readonly source: "https://developers.deepgram.com/docs/models-languages-overview";
+        readonly defaultModel: "nova-3";
+        readonly models: readonly ["nova-3", "nova-2"];
+    };
+    readonly sarvam: {
+        readonly verifiedAt: "2026-08-20";
+        readonly source: "https://docs.sarvam.ai/api-reference/legacy/speech-to-text/transcribe/ws";
+        readonly defaultModel: "saaras:v3";
+        readonly models: readonly ["saaras:v3", "saaras:v4"];
+    };
+    readonly cartesia: {
+        readonly verifiedAt: "2026-07-24";
+        readonly source: "https://docs.cartesia.ai/api-reference/tts/tts";
+        readonly defaultModel: "sonic-3";
+        readonly models: readonly ["sonic-3", "sonic-2"];
+    };
+    readonly elevenlabs: {
+        readonly verifiedAt: "2026-07-24";
+        readonly source: "https://elevenlabs.io/docs/models";
+        readonly defaultModel: "eleven_flash_v2_5";
+        readonly models: readonly ["eleven_flash_v2_5", "eleven_turbo_v2_5", "eleven_multilingual_v2"];
+    };
+    readonly elevenlabsStt: {
+        readonly verifiedAt: "2026-08-20";
+        readonly source: "https://elevenlabs.io/docs/api-reference/speech-to-text/v-1-speech-to-text-realtime";
+        readonly defaultModel: "scribe_v2_realtime";
+        readonly models: readonly ["scribe_v2_realtime"];
+    };
+    readonly assemblyai: {
+        readonly verifiedAt: "2026-08-20";
+        readonly source: "https://www.assemblyai.com/docs/streaming/message-sequence";
+        readonly defaultModel: "u3-rt-pro";
+        readonly models: readonly ["u3-rt-pro"];
+    };
+    readonly soniox: {
+        readonly verifiedAt: "2026-08-20";
+        readonly source: "https://soniox.com/docs/api-reference/stt/websocket-api";
+        readonly defaultModel: "stt-rt-v5";
+        readonly models: readonly ["stt-rt-v5"];
+    };
+    readonly openaiResponses: {
+        readonly verifiedAt: "2026-07-24";
+        readonly source: "https://platform.openai.com/docs/models";
+        readonly defaultModel: "gpt-4.1-mini";
+        readonly models: readonly ["gpt-5", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini"];
+    };
+};
+/**
+ * Provider wire protocol versions. Separate from the model catalog because a
+ * protocol version changes adapter parsing, not just which model is selected.
+ */
+declare const PROVIDER_API_VERSIONS: {
+    readonly cartesia: "2026-03-01";
+};
+/**
+ * TVIC's own adapter tuning. These are our decisions about how to drive a provider,
+ * not facts about the provider, so they are not dated catalog entries.
+ */
+declare const ADAPTER_DEFAULTS: {
+    readonly deepgram: {
+        readonly endpointingMs: 300;
+        readonly vadEvents: true;
+        readonly punctuate: true;
+    };
+    readonly sarvam: {
+        readonly mode: "transcribe";
+        readonly highVadSensitivity: true;
+        readonly vadSignals: true;
+        readonly flushSignal: true;
+        readonly inputAudioCodec: "pcm_s16le";
+    };
+    readonly cartesia: {
+        readonly language: "en";
+    };
+};
+
+interface ElevenLabsTtsProviderOptions {
+    readonly apiKey: string;
+    readonly voiceId: string;
+    readonly modelId?: string;
+    readonly language?: string;
+    readonly url?: string;
+    readonly stability?: number;
+    readonly similarityBoost?: number;
+    readonly clock?: ProviderClock;
+    readonly webSocketFactory?: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+}
+declare class ElevenLabsTtsProvider implements IncrementalTextToSpeechProvider {
+    #private;
+    readonly name: "elevenlabs";
+    readonly kind = "tts";
+    readonly version = "0.1.0";
+    readonly capabilities: {
+        streaming: {
+            input: true;
+            output: true;
+            native: true;
+        };
+        cancellation: {
+            request: true;
+            output: false;
+            buffer: false;
+            truncation: false;
+        };
+        transports: "websocket"[];
+        audio: {
+            output: {
+                readonly encoding: "pcm_s16le";
+                readonly sampleRateHz: 16000;
+                readonly channels: 1;
+            }[];
+        };
+        models: readonly ["eleven_flash_v2_5", "eleven_turbo_v2_5", "eleven_multilingual_v2"];
+    };
+    constructor(options: ElevenLabsTtsProviderOptions);
+    synthesize(request: TtsSynthesisRequest): Promise<TtsStream>;
+    openSession(request: TtsSessionOpenRequest): Promise<TtsSession>;
+}
+declare function createElevenLabsTtsProvider(options: ElevenLabsTtsProviderOptions): ElevenLabsTtsProvider;
+
+/**
+ * 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;
+    /**
+     * When true, return true unconditionally. Use this ONLY in tests, never
+     * in production. Defaults to false.
+     */
+    readonly skipVerification?: boolean;
+}
+declare function canonicalizeTwilioData(url: string, params: TwilioFlatParams | TwilioParams): Buffer;
+/**
+ * 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;
+    /**
+     * When true, return true unconditionally. Use ONLY in tests.
+     */
+    readonly skipVerification?: boolean;
+}
+/**
+ * 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;
+type ProviderForKind<K extends ProviderKind> = Extract<RuntimeProvider, {
+    readonly kind: K;
+}>;
+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 supportsModel(provider: Provider, model: string): boolean;
+declare function requireProviderKind<K extends ProviderKind>(provider: RuntimeProvider, kind: K): ProviderForKind<K>;
+
+interface DefineToolInput<TInput, TOutput> {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly version?: string;
+    readonly inputSchema: JsonSchemaDocument;
+    readonly outputSchema?: JsonSchemaDocument;
+    readonly timeout?: TimeoutPolicy;
+    readonly retry?: RetryPolicy;
+    readonly idempotency?: IdempotencyPolicy;
+    readonly authScope?: readonly string[];
+    readonly tags?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly execute: ToolExecutor<TInput, TOutput>;
+}
+declare function defineTool<TInput = unknown, TOutput = unknown>(input: DefineToolInput<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
+
+interface DefineAgentInput {
+    readonly id: string;
+    readonly name: string;
+    readonly version?: string;
+    readonly instructions: string;
+    readonly tools: readonly ToolDefinition[];
+    readonly providers: AgentProviders;
+    readonly audioPolicy: AgentAudioPolicy;
+    readonly memoryPolicy?: AgentMemoryPolicy;
+    readonly contextPolicy?: AgentContextPolicy;
+    readonly interruptionPolicy?: InterruptionPolicy;
+    readonly timeoutPolicy?: TimeoutPolicy;
+    /** Per-tenant context resolution. Optional. */
+    readonly persona?: PersonaConfig;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+declare function defineAgent(input: DefineAgentInput): Agent;
+
+declare function createRuntime(options?: RuntimeOptions): Runtime;
+
+interface ResolvePreCallContextInput {
+    readonly memory: Memory;
+    readonly resolver?: PreCallContextResolver;
+    readonly userId?: UserId;
+    readonly organizationId?: OrganizationId;
+    readonly workflowId?: WorkflowId;
+    readonly sessionId: SessionId;
+    readonly clock: () => number;
+    readonly timeoutMs?: number;
+    /** Scopes permitted by the agent's memory policy. Omit to use all non-session scopes. */
+    readonly scopes?: readonly MemoryScope[];
+    /** Optional kind filter from `memoryPolicy.preCallLoad`. */
+    readonly kind?: MemoryKind;
+    /** Maximum entries read from each memory scope. */
+    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.
+ */
+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;
+
+interface SessionActivator {
+    activate(input: {
+        readonly sessionId: SessionId;
+        readonly agent: Agent;
+        readonly attachment: SessionAttachment;
+    }): Promise<void>;
+}
+interface SessionRecoveryCoordinatorOptions {
+    readonly runtime: Runtime;
+    readonly durableStore: DurableRuntimeStore;
+    readonly resolveAgent: (agentId: AgentId) => Promise<Agent | null>;
+    readonly hasReconnectableTransport: (sessionId: SessionId) => Promise<boolean>;
+    readonly activator: SessionActivator;
+    readonly holderId: string;
+    readonly policy?: Partial<DurableRuntimePolicy>;
+    readonly pageSize?: number;
+    readonly nowMs?: () => number;
+    readonly onMetric?: (metric: {
+        readonly name: string;
+        readonly value: number;
+    }) => void;
+}
+interface RecoveryPollResult {
+    readonly candidates: number;
+    readonly attached: number;
+    readonly failed: number;
+}
+declare class SessionRecoveryCoordinator {
+    #private;
+    constructor(options: SessionRecoveryCoordinatorOptions);
+    start(): void;
+    stop(): void;
+    pollOnce(): Promise<RecoveryPollResult>;
+}
+interface SessionReaperOptions {
+    readonly runtime: Runtime;
+    readonly durableStore: DurableRuntimeStore;
+    readonly resolveAgent: (agentId: AgentId) => Promise<Agent | null>;
+    readonly holderId: string;
+    readonly hasReconnectableTransport: (sessionId: SessionId) => Promise<boolean>;
+    readonly policy?: Partial<DurableRuntimePolicy>;
+    readonly pageSize?: number;
+    readonly nowMs?: () => number;
+    readonly onMetric?: (metric: {
+        readonly name: string;
+        readonly value: number;
+    }) => void;
+}
+declare class SessionReaper {
+    #private;
+    constructor(options: SessionReaperOptions);
+    start(): void;
+    stop(): void;
+    reapOnce(): Promise<number>;
+}
+
+interface ConversationPolicyOptions {
+    readonly agent: Agent;
+    /**
+     * Pre-call context loaded from the runtime before the call starts.
+     * Contains both the caller's prior memory (rendered as
+     * `<memory>...</memory>`) and any non-memory static context like
+     * CRM records and feature flags (rendered as `<context>...</context>`).
+     */
+    readonly preCallContext?: PreCallContext;
+    /** Optional per-instance override for the agent's live context byte limit. */
+    readonly maxHistoryBytes?: number;
+    /** Optional per-instance override for the agent's live context message limit. */
+    readonly maxHistoryMessages?: number;
+    /** Optional per-instance override for the pre-call context byte limit. */
+    readonly maxPreCallBytes?: number;
+}
+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[]): readonly LlmMessage[];
+    recordTurn(transcript: string, assistantText: string): void;
+    recordInterruptedTurn(transcript: string, assistantText: string): void;
+    findTool(call: LlmInlineToolCall): ToolDefinition | null;
+}
+
+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>;
+}
+
+type SttRecoveryState = "healthy" | "recovering" | "opening" | "probationary" | "failed" | "closed";
+interface SttRecoveryControl {
+    readonly controller: SttCommandController;
+    readonly state: () => SttRecoveryState;
+    subscribe(listener: (state: SttRecoveryState) => void): () => void;
+}
+declare function getSttRecoveryControl(stream: SttStream): SttRecoveryControl | undefined;
+
+interface SttReconnectOptions {
+    readonly maxAttempts?: number;
+    readonly connectTimeoutMs?: number;
+    readonly maxRecoveryDurationMs?: number;
+    readonly initialBackoffMs?: number;
+    readonly maxBackoffMs?: number;
+    readonly jitter?: boolean;
+    readonly stableUptimeMs?: number;
+    readonly maxQuickFailures?: number;
+    readonly uncertainWindowMs?: number;
+    readonly maxBufferedBytes?: number;
+    readonly maxBufferedCommands?: number;
+    readonly commitTimeoutMs?: 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 {
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly sequence: number;
+    readonly status: "completed" | "cancelled" | "failed";
+    readonly text: string;
+    readonly delivered?: boolean;
+    readonly audioError?: NormalizedError;
+}
+
+type TextDeliveryMode = "auto" | "always" | "never";
+interface TextDeliveryDecision {
+    readonly mode?: TextDeliveryMode;
+    readonly audioDelivered: boolean;
+    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;
+    readonly turn: Turn;
+    readonly text: string;
+    readonly mode?: TextDeliveryMode;
+    readonly audioDelivered: boolean;
+    readonly cancelledByBargeIn: boolean;
+}): 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;
+    readonly turnId: TurnId;
+    readonly isFinal: boolean;
+} | {
+    readonly kind: "audio_output";
+    readonly bytes: Uint8Array;
+    readonly turnId: TurnId;
+    readonly sequence: number;
+} | {
+    readonly kind: "turn_started";
+    readonly turnId: TurnId;
+    readonly turnSequence: number;
+} | {
+    readonly kind: "turn_completed";
+    readonly turnId: TurnId;
+    readonly status: "completed" | "cancelled" | "failed";
+    readonly latencyMs: number;
+} | {
+    readonly kind: "tool_call";
+    readonly toolCallId: ToolCallId;
+    readonly toolName: string;
+    readonly input: unknown;
+} | {
+    readonly kind: "tool_result";
+    readonly toolCallId: ToolCallId;
+    readonly output: unknown;
+    readonly latencyMs: number;
+} | {
+    readonly kind: "error";
+    readonly error: NormalizedError;
+    readonly recoverable: boolean;
+} | {
+    readonly kind: "call_ended";
+    readonly reason: "completed" | "cancelled" | "failed" | "remote_hangup";
+    readonly totalTurns: number;
+};
+/**
+ * The result of starting a `PipelineVoiceLoop`. Dual-protocol: awaits
+ * to a final `PipelineVoiceLoopResult` 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;
+}
+/**
+ * Backward-compat alias. Older callers reference `PipelineVoiceLoopResultLike`
+ * directly; new callers should use `PipelineVoiceLoopResult`.
+ *
+ * @deprecated Use `PipelineVoiceLoopResult` from `@tvic/runtime` instead.
+ */
+type PipelineVoiceLoopResultLike = PipelineVoiceLoopResult;
+
+/**
+ * Fluent builder returned by {@link PipelineVoiceLoop.start}. Supports
+ * `.abortSignal(sig)` to attach a per-call cancellation signal. Awaiting
+ * the builder yields the final {@link PipelineVoiceLoopResult}; iterating
+ * it exposes the per-event stream.
+ *
+ * Multiple `then` / `catch` / `finally` / `await` calls share a single
+ * underlying run. Breaking out of the iteration cancels the run via the
+ * supervisor controller.
+ *
+ * The double-set guard rejects a second `abortSignal` call. To compose
+ * multiple signals, use `AbortSignal.any([a, b])` (Node 20+) before
+ * passing them in.
+ */
+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>;
+    finally(onfinally?: (() => void) | null | undefined): PromiseLike<PipelineVoiceLoopResultLike>;
+    [Symbol.asyncIterator](): AsyncIterator<VoiceEvent>;
+}
+/**
+ * Subset of the `PipelineVoiceLoop` API the builder needs. Declared as
+ * a structural type so the builder can live in its own file without
+ * creating a circular import. The full `PipelineVoiceLoop` class
+ * implements this.
+ */
+interface PipelineVoiceLoopLike {
+    _startInternal(options: {
+        readonly overrideSignal?: AbortSignal;
+    }): DualProtocolResult;
+}
+
+interface TurnLatencyRecord {
+    readonly sessionId: SessionId;
+    readonly turnId: TurnId;
+    readonly sequence: number;
+    readonly status: "completed" | "cancelled" | "failed";
+    readonly latency: TurnLatency;
+}
+
+interface PipelineVoiceLoopOptions {
+    readonly runtime: Runtime;
+    readonly session: ActiveSession;
+    readonly attachment?: SessionAttachment;
+    readonly agent: Agent;
+    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;
+    readonly ttsVoice?: string;
+    readonly ttsModel?: string;
+    readonly idGenerator?: IdGenerator;
+    readonly conversationPolicy?: ConversationPolicy;
+    readonly memory?: Memory;
+    readonly memoryUserId?: UserId;
+    readonly organizationId?: OrganizationId;
+    readonly workflowId?: WorkflowId;
+    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;
+    /**
+     * 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;
+}
+interface PipelineVoiceLoopResult {
+    readonly session: ActiveSession;
+    readonly turnsHandled: number;
+    readonly interruptions: number;
+    readonly turnsFailed: number;
+    readonly firstTurnError: NormalizedError | null;
+}
+/**
+ * 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;
+    }): DualProtocolResult;
+}
+
+type AudioNormalizationMode = "auto" | "never";
+interface SttSessionInputOptions {
+    readonly format: AudioFormat;
+    readonly normalization?: AudioNormalizationMode;
+}
+interface SttSessionOptions {
+    readonly provider: SpeechToTextProvider;
+    readonly sessionId?: SessionId;
+    /** The exact format opened with the provider. */
+    readonly format: AudioFormat;
+    /** Optional source format. Source bytes are normalized to `format` when enabled. */
+    readonly input?: SttSessionInputOptions;
+    readonly model?: string;
+    /** Allows a custom/self-hosted STT endpoint to accept a model outside the dated catalog. */
+    readonly allowUnknownModel?: boolean;
+    readonly language?: string;
+    readonly interimResults?: boolean;
+    readonly vocabulary?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly openTimeoutMs?: number;
+    readonly signal?: AbortSignal;
+    readonly clock?: Clock;
+    readonly idGenerator?: IdGenerator;
+    readonly sttReconnect?: boolean | SttReconnectOptions;
+}
+interface SttSession {
+    readonly sessionId: SessionId;
+    readonly format: AudioFormat;
+    readonly inputFormat: AudioFormat;
+    readonly events: AsyncIterable<TranscriptEvent>;
+    pushAudioChunk(chunk: InputAudioChunk): Promise<void>;
+    pushAudio(bytes: Uint8Array, format: AudioFormat, options?: {
+        readonly monotonicOffsetMs?: number;
+    }): Promise<void>;
+    pushPcm16(bytes: Uint8Array, options?: {
+        readonly monotonicOffsetMs?: number;
+    }): Promise<void>;
+    commit(): Promise<void>;
+    close(): Promise<void>;
+}
+declare function createSttSession(options: SttSessionOptions): Promise<SttSession>;
+
+type UpgradeAuthorization<TContext> = {
+    readonly ok: true;
+    readonly context: TContext;
+} | {
+    readonly ok: false;
+    readonly statusCode: number;
+    readonly reason?: string;
+};
+interface NodeMediaPlaneConnection<TContext = unknown> {
+    readonly socket: WebSocket;
+    readonly request: IncomingMessage;
+    readonly url: URL;
+    readonly params: Readonly<Record<string, string>>;
+    readonly upgradeContext?: TContext;
+}
+type NodeMediaPlaneConnectionHandler<TContext = unknown> = (connection: NodeMediaPlaneConnection<TContext>) => Promise<void> | void;
+type NodeMediaPlaneRequestHandler = (request: IncomingMessage, response: ServerResponse) => boolean | Promise<boolean>;
+type NodeMediaPlaneConnectionErrorHandler = (error: unknown, socket: WebSocket) => void | Promise<void>;
+interface NodeMediaPlaneOptions<TContext = unknown> {
+    readonly host?: string;
+    readonly port: number;
+    readonly path: string;
+    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 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;
+}
+declare class NodeMediaPlane<TContext = unknown> {
+    #private;
+    constructor(options: NodeMediaPlaneOptions<TContext>);
+    get isRunning(): boolean;
+    get address(): AddressInfo | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+declare function createNodeMediaPlane<TContext = unknown>(options: NodeMediaPlaneOptions<TContext>): NodeMediaPlane<TContext>;
+declare function matchPath(pattern: string, pathname: string): Readonly<Record<string, string>> | null;
+
+type WithoutApiKey<T> = Omit<T, "apiKey">;
+type DeepgramProviderConfig = WithoutApiKey<DeepgramSttProviderOptions> & {
+    readonly provider: "deepgram";
+    readonly apiKey?: string;
+    readonly model?: string;
+};
+type SarvamProviderConfig = WithoutApiKey<SarvamSttProviderOptions> & {
+    readonly provider: "sarvam";
+    readonly apiKey?: string;
+    readonly model?: string;
+};
+type ElevenLabsSttProviderConfig = Omit<ElevenLabsSttProviderOptions, "apiKey" | "modelId"> & {
+    readonly provider: "elevenlabs";
+    readonly apiKey?: string;
+    readonly model?: string;
+};
+type AssemblyAiProviderConfig = Omit<AssemblyAiSttProviderOptions, "apiKey" | "modelId"> & {
+    readonly provider: "assemblyai";
+    readonly apiKey?: string;
+    readonly model?: string;
+};
+type SonioxProviderConfig = Omit<SonioxSttProviderOptions, "apiKey" | "modelId"> & {
+    readonly provider: "soniox";
+    readonly apiKey?: string;
+    readonly model?: string;
+};
+type SttProviderConfig = DeepgramProviderConfig | SarvamProviderConfig | ElevenLabsSttProviderConfig | AssemblyAiProviderConfig | SonioxProviderConfig;
+type 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 LlmProviderConfig = OpenAiProviderConfig;
+type CartesiaProviderConfig = Omit<CartesiaTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
+    readonly provider: "cartesia";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+};
+type ElevenLabsTtsProviderConfig = Omit<ElevenLabsTtsProviderOptions, "apiKey" | "voiceId" | "modelId"> & {
+    readonly provider: "elevenlabs";
+    readonly apiKey?: string;
+    readonly model?: string;
+    readonly voiceId?: string;
+};
+type TtsProviderConfig = CartesiaProviderConfig | ElevenLabsTtsProviderConfig;
+type TelephonyProviderConfig = {
+    readonly provider: "web-client-audio";
+    readonly options?: WebClientAudioProviderOptions;
+} | {
+    readonly provider: "twilio";
+};
+type VoiceAgentProviders = {
+    readonly telephony: TelephonyProvider | TelephonyProviderConfig;
+    readonly stt: SpeechToTextProvider | SttProviderConfig;
+    readonly llm: LLMProvider | LlmProviderConfig;
+    readonly tts: TextToSpeechProvider | TtsProviderConfig;
+};
+interface VoiceAgentModels {
+    readonly stt?: string;
+    readonly llm?: string;
+    readonly tts?: string;
+    readonly ttsVoice?: string;
+}
+interface CreateVoiceAgentOptions {
+    readonly prompt: string;
+    readonly id?: string;
+    readonly name?: string;
+    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;
+    readonly contextPolicy?: AgentContextPolicy;
+    readonly interruptionPolicy?: InterruptionPolicy;
+    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>>;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly memoryUserId?: UserId;
+    readonly organizationId?: OrganizationId;
+    readonly workflowId?: WorkflowId;
+    readonly signal?: AbortSignal;
+    readonly safetyIdentifier?: string;
+    readonly sttReconnect?: boolean | SttReconnectOptions;
+    readonly sttLanguage?: string;
+    readonly textDelivery?: TextDeliveryMode;
+    readonly streamStallTimeoutMs?: number;
+    readonly turnEndpointTimeoutMs?: number;
+    readonly turnMaxDurationMs?: number;
+}
+interface VoiceAgentCallHandleContext {
+    readonly sessionId: SessionId;
+    readonly call: Call;
+    readonly channel: ChannelKind;
+}
+type VoiceAgentCallHandleFactory = (context: VoiceAgentCallHandleContext) => CallHandle | PromiseLike<CallHandle>;
+interface VoiceAgentRun extends DualProtocolResult {
+}
+interface VoiceAgentSession {
+    readonly sessionId: SessionId;
+    readonly run: VoiceAgentRun;
+}
+interface VoiceAgentProviderNames {
+    readonly telephony: string;
+    readonly stt: string;
+    readonly llm: string;
+    readonly tts: string;
+}
+interface VoiceAgent {
+    readonly id: string;
+    readonly name: string;
+    readonly prompt: string;
+    readonly providers: VoiceAgentProviderNames;
+    start(options: VoiceAgentRunOptions): Promise<VoiceAgentSession>;
+    run(options: VoiceAgentRunOptions): Promise<PipelineVoiceLoopResult>;
+    stop(): Promise<void>;
+    healthCheck(): Promise<HealthSnapshot>;
+}
+declare function createVoiceAgent(options: CreateVoiceAgentOptions): VoiceAgent;
+
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(value: string): Uint8Array;
+declare function mulawToPcm16le(mulaw: Uint8Array): Uint8Array;
+declare function pcm16leToMulaw(pcm: Uint8Array): Uint8Array;
+/**
+ * v0.1 normalized audio is frozen to **pcm_s16le, mono**. The frame/duration/
+ * resample helpers below compute on interleaved-sample assumptions that only hold
+ * for a single channel, so a stereo format would silently corrupt timing. We
+ * reject it at the boundary rather than miscompute.
+ */
+declare function assertPcm16leFormat(format: AudioFormat): void;
+declare function resamplePcm16le(pcm: Uint8Array, fromSampleRateHz: number, toSampleRateHz: number): Uint8Array;
+declare function frameCountForPcm16le(bytes: Uint8Array): number;
+declare function durationMsForPcm16le(bytes: Uint8Array, sampleRateHz: number): number;
+declare function splitPcm16leFrames(bytes: Uint8Array, format: AudioFormat, frameDurationMs: number): readonly Uint8Array[];
+
+/**
+ * A deliberately unbounded, single-consumer async queue: exactly one iterator
+ * may drain it, and pushed values resolve waiters in FIFO order. Lives in
+ * `@tvic/media` because it is the one package both `@tvic/providers` and
+ * `@tvic/runtime` are allowed to depend on (see `scripts/check-architecture.mjs`),
+ * so provider adapters and the runtime's own session/stream wrappers share this
+ * one implementation instead of each keeping a private copy.
+ */
+declare class AsyncQueue<T> implements AsyncIterable<T> {
+    #private;
+    constructor(options?: {
+        readonly maxBuffered?: number;
+    });
+    push(value: T): boolean;
+    fail(error: unknown): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+interface AudioNormalizerOptions {
+    readonly inputFormat: AudioFormat;
+    readonly outputFormat?: AudioFormat;
+    readonly channelPolicy?: "average" | "left";
+}
+interface AudioNormalizer {
+    readonly inputFormat: AudioFormat;
+    readonly outputFormat: AudioFormat;
+    push(bytes: Uint8Array): Uint8Array;
+    finishSegment(): Uint8Array;
+    finish(): Uint8Array;
+}
+/**
+ * Converts supported PCM source frames into PCM16LE mono while preserving
+ * sample-clock phase across arbitrary realtime chunk boundaries.
+ *
+ * The FIR is intentionally small and deterministic. It is causal with a
+ * bounded look-ahead: ordinary pushes emit only samples whose filter support is
+ * present, while an explicit segment/stream finish uses the final source sample
+ * as the endpoint. This prevents packet boundaries from becoming resampling
+ * boundaries.
+ */
+declare function createAudioNormalizer(options: AudioNormalizerOptions): AudioNormalizer;
+
+declare function isInputMediaEvent(event: MediaEvent): event is InputMediaEvent;
+declare function isOutputMediaEvent(event: MediaEvent): event is OutputMediaEvent;
+
+declare class InMemorySessionStore implements SessionStore {
+    #private;
+    get(id: SessionId): Promise<StoredSessionRecord | null>;
+    list(): Promise<readonly StoredSessionRecord[]>;
+    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;
+declare class InMemoryTurnStore implements TurnStore {
+    #private;
+    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>;
+    /** Internal aggregate-transaction rollback hook. */
+    restore(sessionId: SessionId, records: readonly StoredTurnRecord[]): void;
+}
+declare function createInMemoryTurnStore(): InMemoryTurnStore;
+declare class InMemoryToolCallStore implements ToolCallStore {
+    #private;
+    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>;
+    /** Internal aggregate-transaction rollback hook. */
+    restore(sessionId: SessionId, records: readonly StoredToolCallRecord[]): void;
+}
+declare function createInMemoryToolCallStore(): InMemoryToolCallStore;
+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>;
+    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>;
+}
+
+interface InMemoryDurableRuntimeStore extends DurableRuntimeStore {
+    readonly outbox: readonly DurableOutboxEvent[];
+}
+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;
+}
+declare function createInMemoryDurableRuntimeStore(options?: InMemoryDurableRuntimeStoreOptions): InMemoryDurableRuntimeStore;
+
+interface InMemoryMemoryOptions {
+    readonly now?: () => Date;
+    readonly idPrefix?: string;
+    /** Hard cap on the UTF-8 serialized memory value. Throws MemoryEntryTooLargeError. */
+    readonly maxEntryBytes?: number;
+}
+declare class InMemoryMemory implements Memory {
+    #private;
+    readonly name = "in-memory";
+    readonly version = "0.1.0";
+    readonly capabilities: MemoryCapabilities;
+    constructor(options?: InMemoryMemoryOptions);
+    get<T = unknown>(ref: MemoryRef, key: string, kind?: MemoryKind): Promise<MemoryEntry<T> | null>;
+    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>;
+    deleteAll(ref: MemoryRef): Promise<number>;
+    deleteForUser(userId: UserId): Promise<number>;
+}
+declare function createInMemoryMemory(options?: InMemoryMemoryOptions): InMemoryMemory;
+
+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;
+
+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>;
+
+declare class PostgresToolIdempotencyStore implements ToolIdempotencyStore {
+    readonly client: SqlClient$1;
+    constructor(client: SqlClient$1);
+    lookup(key: string, requestHash: string): Promise<ToolIdempotencyRecord | null>;
+    claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
+    complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
+}
+
+interface PostgresOutboxWorkerOptions {
+    readonly pool: SqlPool$1;
+    readonly workerId: string;
+    readonly deliver: (event: DurableOutboxEvent) => Promise<void>;
+    readonly batchSize?: number;
+    readonly claimTtlMs?: number;
+    readonly onMetric?: (metric: {
+        readonly name: string;
+        readonly value: number;
+    }) => void;
+}
+
+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>> {
+    readonly rows: readonly Row[];
+    readonly rowCount?: number | null;
+}
+interface SqlClient$1 {
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(text: string, values?: readonly unknown[]): Promise<SqlResult<Row>>;
+}
+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 PostgresDurableStoreOptions {
+    readonly pool: SqlPool$1;
+}
+declare class PostgresSessionStore implements SessionStore {
+    readonly client: SqlClient$1;
+    constructor(client: SqlClient$1);
+    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 PostgresTurnStore implements TurnStore {
+    readonly client: SqlClient$1;
+    constructor(client: SqlClient$1);
+    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 PostgresToolCallStore implements ToolCallStore {
+    readonly client: SqlClient$1;
+    constructor(client: SqlClient$1);
+    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 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;
+    readonly sessions: PostgresSessionStore;
+    readonly turns: PostgresTurnStore;
+    readonly toolCalls: PostgresToolCallStore;
+    readonly leases: PostgresSessionLeaseStore;
+    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>;
+    runUnfencedSessionTransaction<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+declare function createPostgresDurableRuntimeStore(options: PostgresDurableStoreOptions): PostgresDurableRuntimeStore;
+
+declare class RedisToolIdempotencyStore implements ToolIdempotencyStore {
+    #private;
+    readonly client: RedisClient;
+    constructor(client: RedisClient, options?: RedisStoreOptions);
+    lookup(key: string, _requestHash: string): Promise<ToolIdempotencyRecord | null>;
+    claim(input: ToolIdempotencyClaim): Promise<ToolIdempotencyClaimResult>;
+    complete(key: string, requestHash: string, outcome: ToolIdempotencyOutcome): Promise<void>;
+}
+
+/**
+ * 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 RedisOutboxCacheProjector {
+    readonly client: RedisClient;
+    readonly options: RedisStoreOptions;
+    constructor(client: RedisClient, options?: RedisStoreOptions);
+    apply(event: DurableOutboxEvent): Promise<void>;
+}
+
+type RedisSetResult = "OK" | "ok" | boolean | null;
+interface RedisScanOptions {
+    readonly MATCH?: string;
+    readonly COUNT?: number;
+}
+interface RedisClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        readonly NX?: boolean;
+    }): Promise<RedisSetResult>;
+    del(...keys: readonly string[]): Promise<number>;
+    eval(script: string, keys: readonly string[], args: readonly string[]): Promise<unknown>;
+    scan(cursor: string, options?: RedisScanOptions): Promise<readonly [string, readonly string[]]>;
+    zrange(key: string, start: number, stop: number): Promise<readonly string[]>;
+    zrangebyscore(key: string, min: number, max: number): Promise<readonly string[]>;
+    time(): Promise<readonly [string, string]>;
+    watch(...keys: readonly string[]): Promise<void>;
+    unwatch(): Promise<void>;
+    multi(): RedisMulti;
+    quit?(): Promise<void>;
+}
+interface RedisMulti {
+    set(key: string, value: string): RedisMulti;
+    del(...keys: readonly string[]): RedisMulti;
+    exec(): Promise<readonly unknown[] | null>;
+}
+interface RedisStoreOptions {
+    readonly prefix?: string;
+    readonly nowMs?: () => number;
+    readonly maxTransactionRetries?: number;
+    readonly closeClient?: boolean;
+}
+
+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>;
+    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 RedisDurableRuntimeStore implements DurableRuntimeStore {
+    #private;
+    readonly sessions: RedisSessionStore;
+    readonly turns: RedisTurnStore;
+    readonly toolCalls: RedisToolCallStore;
+    readonly leases: RedisSessionLeaseStore;
+    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>;
+    runUnfencedSessionTransaction<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+declare function createRedisDurableRuntimeStore(client: RedisClient, options?: RedisStoreOptions): RedisDurableRuntimeStore;
+
+interface PostgresRedisDurableStoreOptions {
+    readonly pool: SqlPool$1;
+    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;
+    readonly cacheProjector: RedisOutboxCacheProjector;
+    readonly sessions: SessionStore;
+    readonly turns: TurnStore;
+    readonly toolCalls: ToolCallStore;
+    readonly leases: PostgresSessionLeaseStore;
+    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>;
+    runUnfencedSessionTransaction<T>(sessionId: SessionId, operation: (tx: DurableSessionTransaction) => Promise<T>): Promise<T>;
+    startOutboxWorker(options: Omit<PostgresOutboxWorkerOptions, "pool" | "deliver">): void;
+    stopOutboxWorker(): Promise<void>;
+    close(): Promise<void>;
+}
+declare function createPostgresRedisDurableRuntimeStore(options: PostgresRedisDurableStoreOptions): PostgresRedisDurableRuntimeStore;
+
+/**
+ * The minimum SQL surface a Postgres driver must provide for this package.
+ * Drivers are injected — this package never imports `pg` directly. Matches
+ * the contract used by `@tvic/dal-postgres` so a single shared `pg` pool can
+ * be passed to both packages.
+ */
+interface SqlClient {
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(text: string, params?: readonly unknown[]): Promise<{
+        rows: readonly TRow[];
+        rowCount: number;
+    }>;
+}
+interface SqlPool {
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(text: string, params?: readonly unknown[]): Promise<{
+        rows: readonly TRow[];
+        rowCount: number;
+    }>;
+    connect(): Promise<SqlClient & {
+        readonly release: () => void;
+    }>;
+    end?(): Promise<void>;
+}
+
+interface PostgresMigration {
+    readonly version: number;
+    readonly name: string;
+    readonly sql: string;
+}
+declare function runPostgresMemoryMigrations(pool: SqlPool, migrations?: readonly PostgresMigration[]): Promise<readonly number[]>;
+
+interface PostgresMemoryOptions {
+    readonly pool: SqlPool;
+    /** UTF-8 serialized memory-value cap; throws MemoryEntryTooLargeError. */
+    readonly maxEntryBytes?: number;
+}
+declare class PostgresMemory implements Memory {
+    readonly pool: SqlPool;
+    readonly name = "postgres";
+    readonly version = "0.1.0";
+    readonly capabilities: MemoryCapabilities;
+    constructor(pool: SqlPool, options?: Omit<PostgresMemoryOptions, "pool">);
+    get<T = unknown>(ref: MemoryRef, key: string, kind?: MemoryKind): Promise<MemoryEntry<T> | null>;
+    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>;
+    deleteAll(ref: MemoryRef): Promise<number>;
+    deleteForUser(userIdValue: UserId): Promise<number>;
+}
+declare function createPostgresMemory(options: PostgresMemoryOptions): PostgresMemory;
+
+export { ADAPTER_DEFAULTS, AssemblyAiSttProvider, AsyncQueue, BackendUnavailableError, CartesiaTtsProvider, ConversationPolicy, CorruptRecordError, DEFAULT_DURABLE_RUNTIME_POLICY, DTMF_DIGITS, DeepgramSttProvider, DurableError, EVENT_KIND_MAP, ElevenLabsSttProvider, ElevenLabsTtsProvider, InMemoryMemory, InMemorySessionLeaseStore, InMemorySessionStore, InMemoryToolCallStore, InMemoryToolIdempotencyStore, InMemoryTurnStore, InvalidArgumentError, LeaseLostError, LeaseUnavailableError, MemoryBackendUnavailableError, MemoryEntryTooLargeError, MemorySessionQuotaExceededError, NodeMediaPlane, PCM16_16K_MONO, PCM16_8K_MONO, PROVIDER_API_VERSIONS, PROVIDER_CATALOG, PROVIDER_ERROR_CODES, PROVIDER_NAMES, PROVIDER_STABILITY, PipelineVoiceLoop, PipelineVoiceLoopBuilder, RUNTIME_SAMPLE_RATE_HZ, RecordConflictError, RecordNotFoundError, STT_ERROR_CODES, STT_STREAM_ENDED_REASON, SarvamSttProvider, SessionReaper, SessionRecoveryCoordinator, SonioxSttProvider, TELEPHONY_SAMPLE_RATE_HZ, TVIC_ERROR_MARKER, TVIC_ERROR_NAMES, TvicThrowableError, TwilioMediaStreamCallHandle, TwilioMediaStreamsProvider, WEB_CLIENT_AUDIO_CLOSE_CODES, WEB_CLIENT_AUDIO_DEFAULTS, WebClientAudioCallHandle, WebClientAudioProvider, assertMemoryCapability, assertMemoryPolicySupported, assertPcm16leFormat, authError, base64ToBytes, bytesToBase64, cancelledError, canonicalizeTwilioData, computeTwilioSignature, connectionError, counterIdGenerator, createAssemblyAiSttProvider, createAudioNormalizer, createCartesiaTtsProvider, createDeepgramSttProvider, createDefaultIdGenerator, createElevenLabsSttProvider, createElevenLabsTtsProvider, createInMemoryDurableRuntimeStore, createInMemoryMemory, createInMemorySessionStore, createInMemoryToolCallStore, createInMemoryTurnStore, createMediaEvent, createNodeMediaPlane, createOpenAiResponsesLlmProvider, createPostgresDurableRuntimeStore, createPostgresMemory, createPostgresRedisDurableRuntimeStore, createRedisDurableRuntimeStore, createRuntime, createSarvamSttProvider, createSonioxSttProvider, createSttSession, createSystemClock, createToolRegistry, createTwilioMediaStreamsProvider, createVoiceAgent, createWebClientAudioProvider, defineAgent, defineTool, deliverAssistantText, durationMsForPcm16le, evaluateProviderCompatibility, executeTool, formatMemoryContextAsSystemBlock, formatPreCallContextAsSystemBlock, frameCountForPcm16le, getSttRecoveryControl, idempotencyKeyFor, idempotencyRequestHashFor, internalError, interruptedError, isDtmfDigit, isIncrementalTextToSpeechProvider, isInputMediaEvent, isNormalizedError, isOutputMediaEvent, isProviderKind, isReconstructableAudioFormat, isSampleRateHz, isTerminalSession, isTerminalTurn, isTranscriptSegmentEvent, isTvicError, isTvicErrorName, kindForMediaEvent, matchPath, mediaError, monotonicOffsetMs, mulawToPcm16le, normalizeLegacyError, normalizeUnknownError, normalizedError, nowTimestamp, pcm16leToMulaw, providerError, rateLimitError, requireProviderKind, resamplePcm16le, resolvePreCallContext, resolvePreCallMemory, runPostgresMemoryMigrations, runPostgresMigrations, sameAudioFormat, shouldDeliverText, signVoiceSessionToken, signatureError, splitPcm16leFrames, stableStringify, supportsAudioFormat, supportsLanguage, supportsModel, terminalSessionFromRequest, terminalTurnFromRequest, timeoutError, toTimestamp, toolError, toolInputError, tvicErrorFromJSON, unknownErrorMessage, validateJsonSchemaSubset, validationError, verifyTwilioSignature, verifyVoiceSessionToken, withSttReconnect };
+export type { ActiveSession, ActiveTurn, Agent, AgentAudioPolicy, AgentContextPolicy, AgentId, AgentMemoryPolicy, AgentProviders, AnyMediaEventInit, AssemblyAiProviderConfig, AssemblyAiSttProviderOptions, AssistantTextRecord, AudioFormat, AudioNormalizationMode, AudioNormalizer, AudioNormalizerOptions, AudioPayload, BackoffStrategy, Brand, Call, CallControlCapability, CallDirection, CallHandle, CallId, CallStatus, CancelledSession, CancelledTurn, CartesiaProviderConfig, CartesiaTtsProviderOptions, ChannelKind, ChannelLayout, Clock, CompletedSession, CompletedTurn, ConnectedCall, ConnectionObservabilityEvent, ConversationPolicyOptions, CounterIdGenerator, CreateVoiceAgentOptions, CreatedCall, CreatedSession, DeepgramProviderConfig, DeepgramSttProviderOptions, DefineAgentInput, DefineToolInput, DtmfDigit, DtmfReceivedEvent, DualProtocolResult, DurableErrorCode, DurableOutboxEvent, DurableRuntimeMetric, DurableRuntimePolicy, DurableRuntimeStore, DurableSessionTransaction, ElevenLabsSttCommitStrategy, ElevenLabsSttProviderConfig, ElevenLabsSttProviderOptions, ElevenLabsTtsProviderConfig, ElevenLabsTtsProviderOptions, EndSessionReason, EndSessionRequest, EndTurnRequest, EndedCall, ErrorCategory, ExecuteToolInput, FailedCall, FailedSession, FailedToolCall, FailedToolCallStatus, FailedTurn, HealthCheckResult, HealthSnapshot, IdGenerator, IdempotencyPolicy, InMemoryDurableRuntimeStore, InMemoryDurableRuntimeStoreOptions, InMemoryMemoryOptions, InboundCallContext, InboundMediaEvent, IncrementalTextToSpeechProvider, InputAudioChunk, InputMediaEvent, InternalMediaEvent, InterruptRequestedEvent, InterruptionMode, InterruptionPolicy, JsonSchemaDocument, JsonValue, LLMProvider, LlmCompletion, LlmCompletionRequest, LlmInlineToolCall, LlmMessage, LlmMessageRole, LlmProviderConfig, LlmStreamEvent, LlmUsage, MediaAudioChunkEvent, MediaAudioCommittedEvent, MediaDirection, MediaErrorEvent, MediaEvent, MediaEventId, MediaEventKind, MediaEventType, MediaStreamEndedEvent, MediaStreamStartedEvent, MediaTransport, MediaTransportKind, Memory, MemoryCapabilities, MemoryEntry, MemoryEntryId, MemoryKind, MemoryPutOptions, MemoryQuery, MemoryRef, MemoryScope, NodeMediaPlaneConnection, NodeMediaPlaneConnectionErrorHandler, NodeMediaPlaneConnectionHandler, NodeMediaPlaneOptions, NodeMediaPlaneRequestHandler, NormalizedAudioEncoding, NormalizedError, OpenAiProviderConfig, OpenAiResponsesLlmProviderOptions, OrganizationId, OutboundCallRequest, OutputAudioChunk, OutputMediaEvent, PersonaConfig, PipelineVoiceLoopOptions, PipelineVoiceLoopResult, PostgresDurableStoreOptions, PostgresMemoryOptions, PostgresMigration, PostgresRedisDurableStoreOptions, PreCallContext, PreCallContextResolver, PreCallMemoryContext, PreCallMemoryResolver, Provider, ProviderAudioCapabilities, ProviderCancellationCapabilities, ProviderCapabilities, ProviderCatalogEntry, ProviderCompatibility, ProviderCompatibilityIssue, ProviderCompatibilityIssueCode, ProviderDataPolicy, ProviderEventId, ProviderForKind, ProviderKind, ProviderPlayoutCapabilities, ProviderRequirements, ProviderStability, ProviderStreamingCapabilities, ProviderToolCapabilities, ProviderTransport, QueuedToolCall, RecoveryPollResult, RedisClient, RedisMulti, RedisScanOptions, RedisSetResult, RedisStoreOptions, RequiredProviderCapabilities, RetryPolicy, RingingCall, RunningToolCall, Runtime, RuntimeOptions, RuntimeProvider, RuntimeServiceLifecycle, SampleRateHz, SarvamOutputMode, SarvamProviderConfig, SarvamSttProviderOptions, SchemaValidationResult, Session, SessionAttachment, SessionAttachmentHealth, SessionCancellationReason, SessionEndEvent, SessionEndMemorySnapshot, SessionId, SessionLease, SessionLeaseStore, SessionMemoryFinalization, SessionMetricsRecorder, SessionReaperOptions, SessionRecoveryCoordinatorOptions, SessionRuntimeMetadata, SessionSnapshot, SessionState, SessionStatus, SessionStore, SonioxProviderConfig, SonioxStructuredContext, SonioxSttProviderOptions, SpeechToTextProvider, SqlClient$1 as SqlClient, SqlPool$1 as SqlPool, SqlResult, StartAttachedSessionOptions, StartSessionOptions, StartTurnRequest, StartingSession, StoredSessionRecord, StoredToolCallRecord, StoredTurnRecord, StreamEndReason, SttCommitMode, SttOpenRequest, SttProviderConfig, SttReconnectOptions, SttRecoveryControl, SttRecoveryState, SttSession, SttSessionInputOptions, SttSessionOptions, SttStream, SttTimestampOrigin, SucceededToolCall, TelephonyProvider, TelephonyProviderConfig, TerminalSession, TerminalSessionDraft, TerminalSessionStatus, TerminalToolCall, TerminalTurn, TextDeliveryMode, TextToSpeechProvider, TimeoutAction, TimeoutPolicy, Timestamp, ToolCall, ToolCallId, ToolCallRuntimeMetadata, ToolCallStatus, ToolCallStore, ToolDefinition, ToolExecutionContext, ToolExecutor, ToolId, ToolIdempotencyClaim, ToolIdempotencyClaimResult, ToolIdempotencyLease, ToolIdempotencyOutcome, ToolIdempotencyRecord, ToolIdempotencyStatus, ToolIdempotencyStore, ToolLogger, ToolName, ToolRegistry, ToolTenant, TranscriptEndpointEvent, TranscriptEndpointReason, TranscriptEvent, TranscriptEventType, TranscriptSegmentEvent, TranscriptSegmentEventType, TranscriptSpeechStartedEvent, TransportAudioEncoding, TransportAudioFormat, TtsAlignmentEvent, TtsAlignmentUnit, TtsEvent, TtsFlushAcknowledgement, TtsFlushCompletedEvent, TtsFlushId, TtsFlushResult, TtsProviderConfig, TtsSession, TtsSessionOpenRequest, TtsStream, TtsSynthesisRequest, Turn, TurnCancellationReason, TurnCommitRequestedEvent, TurnDetectionMode, TurnId, TurnInput, TurnLatency, TurnLatencyRecord, TurnOutput, TurnRuntimeMetadata, TurnStatus, TurnStore, TvicErrorName, TwilioFlatParams, TwilioMediaStreamCallHandleOptions, TwilioMediaStreamSocket, TwilioParamValue, TwilioParams, UserId, VerifyTwilioOptions, VerifyVoiceSessionTokenOptions, VoiceAgent, VoiceAgentCallHandleContext, VoiceAgentCallHandleFactory, VoiceAgentModels, VoiceAgentProviderNames, VoiceAgentProviders, VoiceAgentRun, VoiceAgentRunOptions, VoiceAgentSession, VoiceEvent, WebClientAudioCallHandleOptions, WebClientAudioConnectionEvent, WebClientAudioProviderOptions, WebClientAudioSocket, WorkflowId };