twilio-agent-connect 2.2.0 → 2.4.0

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export { z } from 'zod';
 import pino from 'pino';
 import { AxiosInstance } from 'axios';
 import { WebSocket } from 'ws';
+import Twilio from 'twilio';
 import VoiceResponse from 'twilio/lib/twiml/VoiceResponse.js';
 import { CallListInstanceCreateOptions } from 'twilio/lib/rest/api/v2010/account/call.js';
 import { FastifyInstance, FastifyServerOptions } from 'fastify';
@@ -1649,6 +1650,19 @@ declare const InterruptMessageSchema: z.ZodObject<{
     durationUntilInterruptMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type InterruptMessage = z.infer<typeof InterruptMessageSchema>;
+/**
+ * WebSocket DTMF message (caller pressed a key).
+ *
+ * Only sent when `dtmfDetection` is enabled on `<ConversationRelay>`, and one
+ * message per keypress — digits are never batched.
+ *
+ * @see https://www.twilio.com/docs/voice/conversationrelay/websocket-messages#dtmf-message
+ */
+declare const DtmfMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"dtmf">;
+    digit: z.ZodString;
+}, z.core.$strip>;
+type DtmfMessage = z.infer<typeof DtmfMessageSchema>;
 /**
  * Union of all WebSocket message types
  */
@@ -1676,6 +1690,9 @@ declare const WebSocketMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"interrupt">;
     utteranceUntilInterrupt: z.ZodOptional<z.ZodString>;
     durationUntilInterruptMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"dtmf">;
+    digit: z.ZodString;
 }, z.core.$strip>]>;
 type WebSocketMessage = z.infer<typeof WebSocketMessageSchema>;
 /**
@@ -1721,7 +1738,8 @@ type InterruptMode = z.infer<typeof InterruptModeSchema>;
  *
  * Distinct from {@link LanguageAttributes} (the Twilio-SDK-shaped type used by
  * `connectConversationRelay`): this is the customization-facing model used in
- * {@link TwiMLOptions}, mirroring the Python SDK's `LanguageConfig`.
+ * {@link VoiceTwiMLOptionsConversationRelay}, mirroring the Python SDK's
+ * `LanguageConfig`.
  */
 declare const LanguageConfigSchema: z.ZodObject<{
     code: z.ZodString;
@@ -1731,6 +1749,25 @@ declare const LanguageConfigSchema: z.ZodObject<{
     speechModel: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type LanguageConfig = z.infer<typeof LanguageConfigSchema>;
+/**
+ * Provider-agnostic base for a voice provider's inbound-call TwiML
+ * customization options.
+ *
+ * Each provider answers the inbound-call webhook with its own TwiML shape
+ * ({@link VoiceTwiMLOptionsConversationRelaySchema} for `<ConversationRelay>`,
+ * {@link VoiceTwiMLOptionsMediaStreamsSchema} for `<Connect><Stream>`), so
+ * `VoiceProvider.handleIncomingCall`'s
+ * `hostTwimlOptions` is typed against this base rather than a specific
+ * provider's options. It carries only what every provider shares: the
+ * `<Connect action>` URL, the transport URL, and `<Parameter>` children.
+ *
+ * Mirrors the Python SDK's `VoiceTwiMLOptions`.
+ */
+declare const VoiceTwiMLOptionsSchema: z.ZodObject<{
+    customParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    actionUrl: z.ZodOptional<z.ZodString>;
+    websocketUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 /**
  * Options for the TwiML inside `<ConversationRelay>` (plus the
  * `<Connect action>` URL).
@@ -1743,10 +1780,12 @@ type LanguageConfig = z.infer<typeof LanguageConfigSchema>;
  *
  * This is the customization-facing counterpart to {@link ConversationRelayConfig}
  * (which is the Twilio-SDK-shaped emit model and carries the required `url`).
- * Mirrors the Python SDK's `TwiMLOptions`.
+ * Mirrors the Python SDK's `VoiceTwiMLOptionsConversationRelay`.
  */
-declare const TwiMLOptionsSchema: z.ZodObject<{
+declare const VoiceTwiMLOptionsConversationRelaySchema: z.ZodObject<{
     customParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    actionUrl: z.ZodOptional<z.ZodString>;
+    websocketUrl: z.ZodOptional<z.ZodString>;
     welcomeGreeting: z.ZodOptional<z.ZodString>;
     welcomeGreetingInterruptible: z.ZodOptional<z.ZodEnum<{
         any: "any";
@@ -1754,9 +1793,108 @@ declare const TwiMLOptionsSchema: z.ZodObject<{
         none: "none";
         dtmf: "dtmf";
     }>>;
-    actionUrl: z.ZodOptional<z.ZodString>;
     conversationConfiguration: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    ttsLanguage: z.ZodOptional<z.ZodString>;
+    transcriptionLanguage: z.ZodOptional<z.ZodString>;
+    voice: z.ZodOptional<z.ZodString>;
+    ttsProvider: z.ZodOptional<z.ZodString>;
+    transcriptionProvider: z.ZodOptional<z.ZodString>;
+    speechModel: z.ZodOptional<z.ZodString>;
+    elevenlabsTextNormalization: z.ZodOptional<z.ZodEnum<{
+        on: "on";
+        auto: "auto";
+        off: "off";
+    }>>;
+    eotThreshold: z.ZodOptional<z.ZodNumber>;
+    partialPrompts: z.ZodOptional<z.ZodBoolean>;
+    deepgramSmartFormat: z.ZodOptional<z.ZodBoolean>;
+    speechTimeout: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"auto">]>>;
+    interruptible: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        any: "any";
+        speech: "speech";
+        none: "none";
+        dtmf: "dtmf";
+    }>, z.ZodBoolean]>>;
+    interruptSensitivity: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    reportInputDuringAgentSpeech: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        speech: "speech";
+        none: "none";
+        dtmf: "dtmf";
+    }>>;
+    ignoreBackchannel: z.ZodOptional<z.ZodBoolean>;
+    preemptible: z.ZodOptional<z.ZodBoolean>;
+    dtmfDetection: z.ZodOptional<z.ZodBoolean>;
+    hints: z.ZodOptional<z.ZodString>;
+    events: z.ZodOptional<z.ZodString>;
+    debug: z.ZodOptional<z.ZodString>;
+    intelligenceService: z.ZodOptional<z.ZodString>;
+    languages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        voice: z.ZodOptional<z.ZodString>;
+        ttsProvider: z.ZodOptional<z.ZodString>;
+        transcriptionProvider: z.ZodOptional<z.ZodString>;
+        speechModel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+}, z.core.$strict>;
+type VoiceTwiMLOptions = z.infer<typeof VoiceTwiMLOptionsSchema>;
+type VoiceTwiMLOptionsConversationRelay = z.infer<typeof VoiceTwiMLOptionsConversationRelaySchema>;
+/**
+ * Options for the TwiML inside `<Connect><Stream>`.
+ *
+ * Fields map to the attributes documented at
+ * https://www.twilio.com/docs/voice/twiml/stream (the `<Stream>` verb) and
+ * https://www.twilio.com/docs/voice/twiml/connect (the `<Connect>` verb it is
+ * nested in). `track` is deliberately absent: a bidirectional `<Connect>`
+ * stream only ever carries `inbound_track`, so it is not settable.
+ *
+ * Inherits `customParameters`, `actionUrl` and `websocketUrl` from the shared
+ * base. Mirrors the Python SDK's `VoiceTwiMLOptionsMediaStreams`.
+ */
+declare const VoiceTwiMLOptionsMediaStreamsSchema: z.ZodObject<{
+    customParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    actionUrl: z.ZodOptional<z.ZodString>;
+    websocketUrl: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    statusCallback: z.ZodOptional<z.ZodString>;
+    statusCallbackMethod: z.ZodOptional<z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+    }>>;
+    actionMethod: z.ZodOptional<z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+    }>>;
+}, z.core.$strict>;
+type VoiceTwiMLOptionsMediaStreams = z.infer<typeof VoiceTwiMLOptionsMediaStreamsSchema>;
+/** @deprecated Use {@link VoiceTwiMLOptionsConversationRelay} instead. */
+type TwiMLOptions = VoiceTwiMLOptionsConversationRelay;
+/**
+ * Unlike Python, this emits no runtime warning. It is a plain alias so that
+ * `TwiMLOptionsSchema === VoiceTwiMLOptionsConversationRelaySchema`; wrapping it
+ * in a warning proxy would break that identity, and callers commonly compare or
+ * `.extend()` the schema.
+ *
+ * @deprecated Use {@link VoiceTwiMLOptionsConversationRelaySchema} instead.
+ */
+declare const TwiMLOptionsSchema: z.ZodObject<{
+    customParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    actionUrl: z.ZodOptional<z.ZodString>;
     websocketUrl: z.ZodOptional<z.ZodString>;
+    welcomeGreeting: z.ZodOptional<z.ZodString>;
+    welcomeGreetingInterruptible: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        speech: "speech";
+        none: "none";
+        dtmf: "dtmf";
+    }>>;
+    conversationConfiguration: z.ZodOptional<z.ZodString>;
     language: z.ZodOptional<z.ZodString>;
     ttsLanguage: z.ZodOptional<z.ZodString>;
     transcriptionLanguage: z.ZodOptional<z.ZodString>;
@@ -1806,13 +1944,12 @@ declare const TwiMLOptionsSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
 }, z.core.$strict>;
-type TwiMLOptions = z.infer<typeof TwiMLOptionsSchema>;
 /**
  * Framework-neutral view of the Twilio TwiML webhook form.
  *
  * Populated by `TACServer` from the incoming Twilio webhook, then passed to a
  * customizer registered via `VoiceChannel.onInboundCallTwiml(...)` so the
- * application can produce per-call {@link TwiMLOptions} overrides without
+ * application can produce per-call {@link VoiceTwiMLOptions} overrides without
  * depending on Fastify types. Mirrors the Python SDK's `TwiMLRequest`.
  */
 declare const TwiMLRequestSchema: z.ZodObject<{
@@ -1871,6 +2008,12 @@ declare const ConversationRelayCallbackPayloadSchema: z.ZodObject<{
     SessionDuration: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type ConversationRelayCallbackPayload = z.infer<typeof ConversationRelayCallbackPayloadSchema>;
+/** HTTP response a provider's out-of-band lifecycle webhook handler produces. */
+interface TwilioProviderCallbackResponse {
+    status: number;
+    content: string;
+    contentType: string;
+}
 /**
  * A Twilio `statusCallback` webhook — call progress and disposition.
  *
@@ -2105,10 +2248,17 @@ interface InitiateVoiceConversationOptions {
      */
     websocketUrl?: string | undefined;
     /**
-     * Per-call overrides for the TwiML inside `<ConversationRelay>`. Merged over
+     * Per-call overrides for the outbound TwiML. Merged over
      * `VoiceChannelConfig.defaultTwimlOptions` and TAC defaults.
+     *
+     * A union of the provider subtypes rather than the provider-agnostic base:
+     * the base type carries only the three shared fields, so TypeScript's
+     * excess-property check would reject a fresh object literal carrying any
+     * provider-specific field. Each provider still parses this against its own
+     * schema at the channel boundary, so passing the wrong subtype for the
+     * configured provider fails at runtime.
      */
-    twimlOptions?: TwiMLOptions | undefined;
+    twimlOptions?: VoiceTwiMLOptionsConversationRelay | VoiceTwiMLOptionsMediaStreams | undefined;
     /**
      * Parameters for Twilio's `calls.create()` — AMD, recording, status
      * callbacks, timeout (see {@link CallOptions}). Callback URLs auto-wire when
@@ -2116,7 +2266,94 @@ interface InitiateVoiceConversationOptions {
      */
     callOptions?: CallOptions | undefined;
 }
+/**
+ * Validates outbound options for `ConversationRelayProvider`.
+ *
+ * Despite the union on {@link InitiateVoiceConversationOptions.twimlOptions},
+ * this schema accepts only the ConversationRelay subtype — use
+ * {@link InitiateVoiceConversationOptionsOpenAIRealtimeSchema} for
+ * `<Connect><Stream>`.
+ */
 declare const InitiateVoiceConversationOptionsSchema: z.ZodType<InitiateVoiceConversationOptions>;
+/**
+ * Outbound options for `OpenAIRealtimeProvider`, adding a per-call
+ * `sessionConfig` on top of {@link InitiateVoiceConversationOptionsSchema}.
+ * Also narrows `twimlOptions` to {@link VoiceTwiMLOptionsMediaStreamsSchema}.
+ *
+ * Mirrors the Python SDK's `InitiateVoiceConversationOptionsOpenAIRealtime`.
+ */
+declare const InitiateVoiceConversationOptionsOpenAIRealtimeSchema: z.ZodObject<{
+    to: z.ZodString;
+    websocketUrl: z.ZodOptional<z.ZodURL>;
+    callOptions: z.ZodOptional<z.ZodType<CallOptions, unknown, z.core.$ZodTypeInternals<CallOptions, unknown>>>;
+    twimlOptions: z.ZodOptional<z.ZodObject<{
+        customParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        actionUrl: z.ZodOptional<z.ZodString>;
+        websocketUrl: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        statusCallback: z.ZodOptional<z.ZodString>;
+        statusCallbackMethod: z.ZodOptional<z.ZodEnum<{
+            POST: "POST";
+            GET: "GET";
+        }>>;
+        actionMethod: z.ZodOptional<z.ZodEnum<{
+            POST: "POST";
+            GET: "GET";
+        }>>;
+    }, z.core.$strict>>;
+    sessionConfig: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+type InitiateVoiceConversationOptionsOpenAIRealtime = z.infer<typeof InitiateVoiceConversationOptionsOpenAIRealtimeSchema>;
+/**
+ * Outbound options for `GPTLiveProvider`, adding a per-call `sessionConfig` on
+ * top of {@link InitiateVoiceConversationOptionsSchema}. Also narrows
+ * `twimlOptions` to {@link VoiceTwiMLOptionsMediaStreamsSchema}.
+ *
+ * Mirrors the Python SDK's `InitiateVoiceConversationOptionsGPTLive`.
+ */
+declare const InitiateVoiceConversationOptionsGPTLiveSchema: z.ZodObject<{
+    to: z.ZodString;
+    websocketUrl: z.ZodOptional<z.ZodURL>;
+    callOptions: z.ZodOptional<z.ZodType<CallOptions, unknown, z.core.$ZodTypeInternals<CallOptions, unknown>>>;
+    twimlOptions: z.ZodOptional<z.ZodObject<{
+        customParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        actionUrl: z.ZodOptional<z.ZodString>;
+        websocketUrl: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        statusCallback: z.ZodOptional<z.ZodString>;
+        statusCallbackMethod: z.ZodOptional<z.ZodEnum<{
+            POST: "POST";
+            GET: "GET";
+        }>>;
+        actionMethod: z.ZodOptional<z.ZodEnum<{
+            POST: "POST";
+            GET: "GET";
+        }>>;
+    }, z.core.$strict>>;
+    sessionConfig: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+type InitiateVoiceConversationOptionsGPTLive = z.infer<typeof InitiateVoiceConversationOptionsGPTLiveSchema>;
+
+/**
+ * The `start` field of Twilio's Media Stream `start` event.
+ *
+ * This is an inbound, read-only message Twilio pushes over the
+ * `<Connect><Stream>` WebSocket, so unlike the outbound TwiML options it
+ * carries no snake_case alias layer — the wire names are parsed directly.
+ *
+ * Mirrors the Python SDK's `StreamStartMessage`. Python exposes a
+ * `conversation_id` property aliasing `call_sid`; here callers read `callSid`
+ * directly.
+ *
+ * @see https://www.twilio.com/docs/voice/media-streams/websocket-messages
+ */
+declare const StreamStartMessageSchema: z.ZodObject<{
+    streamSid: z.ZodString;
+    callSid: z.ZodString;
+    mediaFormat: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    customParameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type StreamStartMessage = z.infer<typeof StreamStartMessageSchema>;
 
 /**
  * Structured payload generated during a handoff.
@@ -2215,6 +2452,33 @@ declare const AnthropicToolSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 type AnthropicTool = z.infer<typeof AnthropicToolSchema>;
+/**
+ * OpenAI Realtime tool format.
+ *
+ * Realtime's `session.tools` expects the fields flat on the tool object,
+ * unlike Chat Completions ({@link OpenAIToolSchema}), which nests them under a
+ * `function` key.
+ */
+declare const OpenAIRealtimeToolSchema: z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        items: z.ZodOptional<z.ZodAny>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type OpenAIRealtimeTool = z.infer<typeof OpenAIRealtimeToolSchema>;
 /**
  * Tool execution context
  */
@@ -3166,6 +3430,22 @@ declare class TAC {
     shutdown(): void;
 }
 
+type EventProperties = {
+    account_sid: string;
+} & Record<string, unknown>;
+/**
+ * Record a telemetry event. Never throws.
+ *
+ * @internal
+ */
+declare function trackEvent(event: string, properties: EventProperties): void;
+/**
+ * Flush pending events and close the client. Called by `TAC.shutdown()`.
+ *
+ * @internal
+ */
+declare function shutdownAnalytics(): Promise<void>;
+
 /**
  * Messaging channel configuration options.
  * Alias for BaseChannelOptions that can be extended by specific channel implementations.
@@ -3222,6 +3502,14 @@ declare abstract class MessagingChannel extends BaseChannel {
      * per-conversation channelId) to build the address.
      */
     protected abstract getAgentAddress(conversationId: ConversationId): ConversationAddress;
+    /**
+     * Report a delivered response.
+     *
+     * Each channel calls this from its own `sendResponse` rather than the base
+     * wrapping the call: `sendResponse` is the public extension point, so making
+     * it a template method would break subclasses defined outside this package.
+     */
+    protected trackResponseSent(conversationId: ConversationId): void;
     /**
      * Check if a message is from the bot itself (2-tier).
      *
@@ -3491,15 +3779,154 @@ declare class ChatChannel extends MessagingChannel {
 }
 
 /**
- * Configuration for the Voice channel.
+ * Base class for a {@link VoiceChannel}'s real-time media provider.
+ *
+ * Holds the owning `channel` (Calls API lifecycle, conversation bookkeeping,
+ * `TAC`). Every method here has a default that either declines the capability
+ * or does nothing, so a provider only implements the transport it actually
+ * supports — ConversationRelay serves inbound TwiML and a WebSocket, while a
+ * provider with no inbound story simply inherits the refusal.
+ */
+declare class VoiceProvider {
+    /** The `VoiceChannel` that owns this provider. */
+    readonly channel: VoiceChannel;
+    /** Logger named after the concrete provider class. */
+    protected readonly logger: Logger;
+    constructor(channel: VoiceChannel);
+    /**
+     * Stable snake_case identifier for this provider, reported on voice
+     * telemetry events so emissions from different transports are
+     * distinguishable. Built-in providers override it; a provider defined outside
+     * the SDK inherits `"custom"`.
+     *
+     * @internal
+     */
+    get providerId(): string;
+    /**
+     * Channel name identifier, e.g. `"VOICE"`.
+     *
+     * A label for this provider's transport; it does not change how
+     * `VoiceChannel` reports its `ChannelType`.
+     */
+    get channelName(): string;
+    /**
+     * Build the response for an inbound call. Default: not supported.
+     *
+     * @param _twimlRequest - Parsed Twilio webhook fields for the inbound call.
+     * @param _options - Additional per-call inputs.
+     * @param _options.hostTwimlOptions - Per-call TwiML supplied by a custom
+     *   in-process host.
+     */
+    handleIncomingCall(_twimlRequest?: TwiMLRequest, _options?: {
+        hostTwimlOptions?: VoiceTwiMLOptions;
+    }): Promise<string>;
+    /**
+     * Handle this provider's own out-of-band lifecycle webhook, if it has one.
+     *
+     * Not every provider has an equivalent — Twilio's ConversationRelay posts to
+     * `<Connect action=...>` when the session ends (`ConversationRelayProvider`
+     * uses this as a WebSocket-disconnect backup); Media Streams instead has its
+     * own independent `statusCallback` (`stream-started` / `stream-stopped` /
+     * `stream-error`), which is purely informational and doesn't gate call flow.
+     * Default acknowledges with an empty 200 for providers with nothing to do
+     * here.
+     */
+    handleTwilioProviderCallback(_payload: Record<string, unknown>): Promise<TwilioProviderCallbackResponse>;
+    /**
+     * Drive one WebSocket connection from accept to disconnect.
+     *
+     * Implementations may be synchronous or asynchronous: a provider that only
+     * attaches event handlers can return `void`, while one that awaits an
+     * upstream handshake before serving traffic returns a `Promise<void>`. The
+     * owning `VoiceChannel` is responsible for handling a returned promise's
+     * rejection, so an async override never produces an unhandled rejection.
+     */
+    handleWebSocket(_websocket: WebSocket): void | Promise<void>;
+    /** Place an outbound call. Default: not supported. */
+    initiateOutboundConversation(_options: InitiateVoiceConversationOptions): Promise<InitiateVoiceConversationResult>;
+    /** Send a text response back through this provider's transport, if supported. */
+    sendResponse(_conversationId: ConversationId, _message: string, _metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Stream a text response back through this provider's transport, token by
+     * token, if supported. Default: not supported.
+     *
+     * @param _conversationId - Conversation whose transport receives the tokens.
+     * @param _stream - Async iterable of text chunks to relay as they arrive.
+     * @param _options - Additional per-call inputs.
+     * @param _options.signal - Aborts the stream mid-flight, e.g. when the caller
+     *   interrupts.
+     * @returns The accumulated response text.
+     */
+    sendStreamingResponse(_conversationId: ConversationId, _stream: AsyncIterable<string>, _options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /** Return the Twilio-facing WebSocket for a conversation, if tracked. */
+    getWebSocket(_conversationId: ConversationId): WebSocket | null;
+    /**
+     * Drop this provider's transport state on channel shutdown.
+     *
+     * Called by {@link VoiceChannel.shutdown} before the channel clears its own
+     * conversation bookkeeping. Default no-op — providers override this to drop
+     * whatever transport state they track. Live WebSocket connections are owned
+     * and closed by the server, so an override only clears in-process tracking.
+     */
+    shutdown(): void;
+    /**
+     * Set callback URLs on `callParams` for every registered call-event handler.
+     *
+     * A URL is derived only when its handler is registered — an unwanted
+     * call-event URL would otherwise surface as silent 11200 alerts for a
+     * feature nobody asked for. If TAC isn't serving these routes, set the URLs
+     * explicitly via `CallOptions` (or the provider config's default call
+     * options, where available). An explicit URL from either options layer is
+     * never overwritten.
+     */
+    protected applyCallEventCallbacks(callParams: Record<string, unknown>): Record<string, unknown>;
+}
+/**
+ * Base configuration for a {@link VoiceChannel}'s real-time media provider.
+ *
+ * Subclasses add their provider's own settings and implement
+ * {@link VoiceProviderConfig.createProvider} to build the provider they
+ * configure.
+ */
+declare class VoiceProviderConfig {
+    /** Memory retrieval mode for this channel. Defaults to `'never'`. */
+    memoryMode: MemoryMode;
+    /**
+     * The {@link BaseChannelOptions} this config was constructed with, retained
+     * verbatim so `VoiceChannel` can hand them to `BaseChannel`.
+     *
+     * A provider config carries channel-level options (`dedupCapacity` and
+     * friends) alongside its own provider settings; without this they would be
+     * dropped on the config path while still applying on the plain-object path,
+     * which is the same channel configured two ways.
+     *
+     * @internal
+     */
+    readonly channelOptions: BaseChannelOptions;
+    constructor(options?: BaseChannelOptions);
+    /**
+     * Build the {@link VoiceProvider} this config configures.
+     *
+     * @param _channel - The owning `VoiceChannel`.
+     * @param _tacConfig - `TACConfig` — providers that talk TwiML need it to
+     *   derive default URLs (`voicePublicDomain` etc.).
+     */
+    createProvider(_channel: VoiceChannel, _tacConfig: TACConfig): VoiceProvider;
+}
+
+/**
+ * Options accepted by {@link ConversationRelayProviderConfig}.
  *
  * `defaultTwimlOptions` is one of several TwiML layers that merge per-field;
- * see `handleIncomingCall` (inbound) and `initiateOutboundConversation`
- * (outbound) for the full precedence order.
+ * see `ConversationRelayProvider.handleIncomingCall` (inbound) and
+ * `ConversationRelayProvider.initiateOutboundConversation` (outbound) for the
+ * full precedence order.
  */
-interface VoiceChannelConfig extends BaseChannelOptions {
+interface ConversationRelayProviderConfigOptions extends BaseChannelOptions {
     /**
-     * Static `TwiMLOptions` applied to every call (inbound and outbound).
+     * Static `VoiceTwiMLOptionsConversationRelay` applied to every call (inbound and outbound).
      * Controls the TwiML inside `<ConversationRelay>` — voice, language,
      * transcription provider, welcomeGreeting, `<Language>` children, etc. Use
      * this when the same ConversationRelay configuration is correct for every call.
@@ -3510,7 +3937,7 @@ interface VoiceChannelConfig extends BaseChannelOptions {
      * Note: `customParameters` and `languages` replace wholesale when a
      * higher-priority layer sets them.
      */
-    defaultTwimlOptions?: TwiMLOptions;
+    defaultTwimlOptions?: VoiceTwiMLOptionsConversationRelay;
     /**
      * Static {@link CallOptions} applied to every outbound call — the
      * `calls.create` parameters, including the call-event callback URLs. This is
@@ -3521,200 +3948,95 @@ interface VoiceChannelConfig extends BaseChannelOptions {
     defaultCallOptions?: CallOptions;
 }
 /**
- * Callback that produces per-call overrides for the TwiML inside
- * `<ConversationRelay>` on inbound calls. Receives a framework-neutral
- * {@link TwiMLRequest} and returns {@link TwiMLOptions}.
- */
-type InboundCallTwimlHandler = (req: TwiMLRequest) => Promise<TwiMLOptions>;
-/** Handler for Twilio `statusCallback` webhooks. */
-type CallStatusHandler = (event: CallStatusEvent) => Promise<void> | void;
-/** Handler for Twilio `asyncAmdStatusCallback` webhooks. */
-type AmdHandler = (event: AmdEvent) => Promise<void> | void;
-/** Handler for Twilio `recordingStatusCallback` webhooks. */
-type RecordingHandler = (event: RecordingEvent) => Promise<void> | void;
-/**
- * Voice channel event callbacks extending base callbacks
+ * Configuration for {@link ConversationRelayProvider}, the default
+ * {@link VoiceChannel} provider.
+ *
+ * TwiML configuration layers (highest precedence first):
+ *
+ *   Inbound calls (`handleIncomingCall`):
+ *     1. Output of the customizer registered via
+ *        `VoiceChannel.onInboundCallTwiml(...)`  [optional]
+ *     2. `defaultTwimlOptions`                   [optional]
+ *     3. `handleIncomingCall(hostTwimlOptions)`  [optional]
+ *     4. TAC defaults
+ *
+ *   Outbound calls (`initiateOutboundConversation`):
+ *     1. `InitiateVoiceConversationOptions.twimlOptions` [optional]
+ *     2. `defaultTwimlOptions`                           [optional]
+ *     3. TAC defaults
+ *
+ *   Calls-API parameters (`initiateOutboundConversation`):
+ *     1. `InitiateVoiceConversationOptions.callOptions` [optional]
+ *     2. `defaultCallOptions`                          [optional]
+ *     3. Callback URLs derived from `TACConfig.voicePublicDomain` +
+ *        `voiceCallEventPath`, for handlers that are registered
+ *
+ * All layers merge per-field via key presence — only fields a layer explicitly
+ * sets override lower layers. Arrays (`languages`) and nested objects
+ * (`customParameters`) replace wholesale when set.
+ *
+ * Per-call inbound customization is registered via
+ * `VoiceChannel.onInboundCallTwiml(...)` (not on this config).
  */
-interface VoiceChannelEvents extends BaseChannelEvents {
-    onSetup?: (data: {
-        callSid: string;
-        from: string;
-        to: string;
-        customParameters: Record<string, unknown> | undefined;
-    }) => void;
-    onPrompt?: (data: {
-        conversationId: ConversationId;
-        transcript: string;
-        userMemory?: TACMemoryResponse;
-        session?: ConversationSession;
-        abortSignal: AbortSignal;
-    }) => Promise<void> | void;
-    onInterrupt?: (data: {
-        conversationId: ConversationId;
-        utteranceUntilInterrupt: string | undefined;
-        durationUntilInterruptMs: number | undefined;
-    }) => void;
+declare class ConversationRelayProviderConfig extends VoiceProviderConfig {
     /**
-     * Fired once the session and WebSocket registration exist — in orchestrated
-     * mode possibly before the first prompt, since the lookup starts at setup.
+     * Static `VoiceTwiMLOptionsConversationRelay` for the TwiML inside `<ConversationRelay>`, applied
+     * to every call (inbound and outbound).
      */
-    onWebSocketConnected?: (data: {
-        conversationId: ConversationId;
-    }) => void;
-    onWebSocketDisconnected?: (data: {
-        conversationId: ConversationId;
-    }) => void;
+    readonly defaultTwimlOptions?: VoiceTwiMLOptionsConversationRelay;
+    /** Static {@link CallOptions} applied to every outbound call. */
+    readonly defaultCallOptions?: CallOptions;
+    constructor(options?: ConversationRelayProviderConfigOptions);
+    createProvider(channel: VoiceChannel, tacConfig: TACConfig): VoiceProvider;
 }
 /**
- * Voice Channel implementation for Twilio ConversationRelay
+ * Pre-provider-split name for {@link ConversationRelayProviderConfigOptions} —
+ * the shape `new VoiceChannel(tac, {...})` accepts. Kept so the shipped public
+ * export stays valid across the provider refactor.
  *
- * Handles voice conversations through WebSocket connections.
- * Manages real-time audio streaming and conversation state.
+ * @deprecated Use {@link ConversationRelayProviderConfigOptions} instead.
+ */
+type VoiceChannelConfig = ConversationRelayProviderConfigOptions;
+
+/**
+ * A single in-flight streaming response, with the {@link AbortController} that
+ * cancels it and whether any token has been written to the transport yet.
  */
 interface StreamTask {
     controller: AbortController;
     hasSentTokens: boolean;
 }
-declare class VoiceChannel extends BaseChannel {
+/**
+ * Twilio ConversationRelay: Twilio handles ASR/TTS and exchanges JSON
+ * `setup`/`prompt`/`interrupt` messages over one WebSocket.
+ *
+ * This is the default provider {@link VoiceChannel} builds when none is passed
+ * explicitly.
+ */
+declare class ConversationRelayProvider extends VoiceProvider {
+    /** @internal */
+    get providerId(): string;
+    /**
+     * The owning channel's logger, so relocated ConversationRelay logic keeps
+     * logging exactly as it did when it lived on `VoiceChannel`.
+     */
+    protected readonly logger: Logger;
+    /** In-flight streaming responses, keyed by conversation. */
+    protected readonly streamTasks: Map<ConversationId, StreamTask>;
+    private readonly config;
+    private readonly tacConfig;
+    private readonly twimlBuilder;
     private readonly webSocketConnections;
-    private readonly voiceCallbacks;
-    private readonly streamTasks;
     private readonly promptQueues;
     private readonly initializationRetries;
     private readonly callSidToConversationId;
     private readonly MAX_INITIALIZATION_RETRIES;
-    private twilioClient;
-    private readonly voiceConfig;
-    private onInboundCallTwimlHandler;
-    private onCallStatusHandler;
-    private onAmdHandler;
-    private onRecordingHandler;
-    constructor(tac: TAC, options?: VoiceChannelConfig);
-    /**
-     * Register a callback that produces per-call overrides for the TwiML inside
-     * `<ConversationRelay>` on inbound calls.
-     *
-     * The callback receives a framework-neutral {@link TwiMLRequest} (parsed from
-     * the Twilio webhook form) and returns {@link TwiMLOptions}. Fields the
-     * callback explicitly sets override `defaultTwimlOptions` and TAC defaults;
-     * unset fields fall through.
-     *
-     * @example
-     * ```typescript
-     * voiceChannel.onInboundCallTwiml(async req => {
-     *   if (req.callerCountry === 'MX') {
-     *     return { language: 'es-MX', welcomeGreeting: '¡Hola!' };
-     *   }
-     *   return {};
-     * });
-     * ```
-     *
-     * Outbound calls don't use this — pass per-call TwiML via
-     * `InitiateVoiceConversationOptions.twimlOptions` directly.
-     */
-    onInboundCallTwiml(callback: InboundCallTwimlHandler): void;
-    /**
-     * Register a handler for Twilio `statusCallback` webhooks.
-     *
-     * This is the Calls-API status callback (call disposition), not the
-     * ConversationRelay session callback — see
-     * {@link handleConversationRelayCallback}.
-     *
-     * Registering does two things: it stores the handler, and it makes later
-     * outbound calls pass `statusCallback` to `calls.create`. With no handler
-     * registered TAC omits that parameter, so Twilio has nowhere to post and the
-     * event never arrives.
-     *
-     * Twilio reports only the terminal event by default, which covers every
-     * disposition; set `CallOptions.statusCallbackEvent` for ringing/answered.
-     *
-     * @example
-     * ```typescript
-     * voiceChannel.onCallStatus(async event => {
-     *   if (event.isUnreached) {
-     *     // queue a retry
-     *   }
-     * });
-     * ```
-     */
-    onCallStatus(callback: CallStatusHandler): void;
-    /**
-     * Register a handler for Twilio `asyncAmdStatusCallback` webhooks.
-     *
-     * Registering makes later outbound calls pass `asyncAmdStatusCallback` to
-     * `calls.create`; without a handler TAC omits it and Twilio has nowhere to
-     * post the result. It does not enable detection — that's per-call, via
-     * `CallOptions.machineDetection` and `asyncAmd`, both of which are required
-     * for this to fire (at most once per call).
-     *
-     * @example
-     * ```typescript
-     * voiceChannel.onAmd(async event => {
-     *   if (event.isMachine) {
-     *     await voiceChannel.endCall(event.callSid); // voicemail → hang up
-     *   }
-     * });
-     * ```
-     */
-    onAmd(callback: AmdHandler): void;
-    /**
-     * Register a handler for Twilio `recordingStatusCallback` webhooks.
-     *
-     * Registering makes later outbound calls pass `recordingStatusCallback` to
-     * `calls.create`; without a handler TAC omits it and Twilio has nowhere to
-     * post. It does not start recording — that's `CallOptions.record`, which is
-     * required for this to fire.
-     *
-     * @example
-     * ```typescript
-     * voiceChannel.onRecording(async event => {
-     *   if (event.recordingStatus === 'completed') {
-     *     // store event.recordingUrl
-     *   }
-     * });
-     * ```
-     */
-    onRecording(callback: RecordingHandler): void;
-    /**
-     * Resolve the public WebSocket URL from `TACConfig.voicePublicDomain` +
-     * `TACConfig.voiceWebsocketPath`. Throws if `voicePublicDomain` isn't set.
-     */
-    private resolveWebsocketUrl;
-    /**
-     * Resolve the default `<Connect action=...>` cleanup URL.
-     *
-     * Returns undefined if `voicePublicDomain` isn't set; that's fine because
-     * actionUrl has higher-priority layers (customizer, twimlOptions, Studio
-     * handoff) above this fallback.
-     */
-    private resolveDefaultActionUrl;
-    private getTwilioClient;
-    get channelType(): ChannelType;
-    /**
-     * Register event callbacks (override for Voice-specific events)
-     */
-    on(event: string, callback: (...args: any[]) => void): void;
-    /**
-     * Process conversation webhooks for cleanup.
-     *
-     * Voice channel processes CONVERSATION_UPDATED events:
-     * - CLOSED status: Clean up local session state
-     *
-     * Note: Conversation tracking uses instance-local memory. In multi-instance
-     * deployments, webhooks may route to a different instance, preventing cleanup.
-     *
-     * @param payload - Raw webhook event data from Twilio
-     * @param idempotencyToken - Optional Twilio idempotency token from request headers
-     */
-    processWebhook(payload: unknown, idempotencyToken?: string): Promise<void>;
-    /**
-     * Handle conversation updated event
-     */
-    private handleConversationUpdated;
+    constructor(channel: VoiceChannel, tacConfig: TACConfig, config: ConversationRelayProviderConfig);
+    get channelName(): string;
     /**
      * Get active WebSocket connection for a conversation
      */
-    getWebsocket(conversationId: ConversationId): WebSocket | null;
+    getWebSocket(conversationId: ConversationId): WebSocket | null;
     /**
      * Poll Conversation Orchestrator for the conversation ConversationRelay
      * created for `callSid`, then register the local session and WebSocket.
@@ -3725,7 +4047,7 @@ declare class VoiceChannel extends BaseChannel {
     /**
      * Handle WebSocket connection from ConversationRelay
      */
-    handleWebSocketConnection(ws: WebSocket): void;
+    handleWebSocket(ws: WebSocket): void;
     /**
      * Handle WebSocket prompt message (user speech)
      */
@@ -3734,6 +4056,10 @@ declare class VoiceChannel extends BaseChannel {
      * Handle WebSocket interrupt message
      */
     private handleInterruptMessage;
+    /**
+     * Handle WebSocket DTMF message (caller keypress)
+     */
+    private handleDtmfMessage;
     /**
      * Handle WebSocket disconnection. In orchestrated mode the conversation stays
      * tracked until the CLOSED webhook (so a follow-up call can reuse it); in
@@ -3758,6 +4084,33 @@ declare class VoiceChannel extends BaseChannel {
     sendStreamingResponse(conversationId: ConversationId, stream: AsyncIterable<string>, options?: {
         signal?: AbortSignal;
     }): Promise<string>;
+    /**
+     * Start tracking a streaming task for a conversation
+     *
+     * @param conversationId - The conversation ID
+     * @returns The stream task with its AbortController
+     */
+    startStreamTask(conversationId: ConversationId): StreamTask;
+    /**
+     * Cancel an active streaming task
+     *
+     * @param conversationId - The conversation ID
+     * @returns true if a task was cancelled, false otherwise
+     */
+    cancelStreamTask(conversationId: ConversationId): boolean;
+    /**
+     * Complete a streaming task (remove from tracking)
+     *
+     * @param conversationId - The conversation ID
+     */
+    completeStreamTask(conversationId: ConversationId): void;
+    /**
+     * Check if a stream task is active
+     *
+     * @param conversationId - The conversation ID
+     * @returns true if an active task exists
+     */
+    hasActiveStreamTask(conversationId: ConversationId): boolean;
     /**
      * Generate the TwiML response for an incoming voice call.
      *
@@ -3772,7 +4125,8 @@ declare class VoiceChannel extends BaseChannel {
      *   1. Output of the customizer registered via
      *      `VoiceChannel.onInboundCallTwiml(...)` if configured and `twimlRequest`
      *      is given. (Application-owned.)
-     *   2. `VoiceChannelConfig.defaultTwimlOptions` — per-channel defaults.
+     *   2. `ConversationRelayProviderConfig.defaultTwimlOptions` — per-channel
+     *      defaults.
      *   3. `hostTwimlOptions` — per-call transport facts supplied by the host (the
      *      code owning the route), e.g. a per-call `websocketUrl` with an affinity
      *      token.
@@ -3795,73 +4149,42 @@ declare class VoiceChannel extends BaseChannel {
      *   `websocketUrl`), layered below `defaultTwimlOptions` and the application
      *   customizer but above the TAC defaults.
      * @returns TwiML XML string for call connection.
+     * @throws {Error} if either options layer isn't a
+     *   {@link VoiceTwiMLOptionsConversationRelay}.
      */
     handleIncomingCall(twimlRequest?: TwiMLRequest, options?: {
-        hostTwimlOptions?: TwiMLOptions;
+        hostTwimlOptions?: VoiceTwiMLOptions;
     }): Promise<string>;
     /**
-     * Layer TwiML options, lowest precedence first: TAC defaults → `host`
-     * (calling host's per-call values) → channel `defaultTwimlOptions` → `perCall`
-     * (application customizer output for inbound, or
-     * `InitiateVoiceConversationOptions.twimlOptions` for outbound).
-     */
-    private buildTwimlOptions;
-    /**
-     * Apply fields explicitly present on `source` onto `target`.
-     *
-     * Nested objects (`customParameters`), arrays (`languages`), and dicts
-     * (`extra`) replace wholesale — there's no per-key merging.
-     *
-     * `actionUrl` is skipped here on purpose — it's resolved once via
-     * `resolveActionUrl` looking at every layer at once, and that resolved value
-     * is written into `target` before this overlay runs. Letting it through here
-     * would let a higher-priority layer that didn't set actionUrl silently clobber
-     * a lower layer that did.
-     *
-     * "Explicitly present" is detected via key presence (`key in source`), which
-     * mirrors Python's `model_fields_set`: a key set to `undefined` is still
-     * "present" and overrides lower layers, while an absent key falls through.
-     */
-    private overlayFields;
-    /**
-     * Resolve the TwiML `<Connect action=...>` URL.
+     * Narrow provider-agnostic {@link VoiceTwiMLOptions} to this provider's
+     * concrete shape. `VoiceProvider.handleIncomingCall` is typed against the
+     * base so every provider can accept its own TwiML options, so the
+     * ConversationRelay shape has to be established at runtime.
      *
-     * Precedence (highest to lowest):
-     *   1. application customizer
-     *   2. channel `defaultTwimlOptions`
-     *   3. `host` (calling host's per-call options)
-     *   4. Studio handoff (when `studioHandoffFlowSid` is configured)
-     *   5. Channel default — derived from `TACConfig.voicePublicDomain` +
-     *      `TACConfig.voiceActionPath`.
-     *
-     * User-expressed intent (Studio handoff is configured explicitly on
-     * `TACConfig`) beats the SDK's generated cleanup default.
-     *
-     * Explicit `actionUrl: undefined` on a layer (key present, value undefined)
-     * suppresses `<Connect action=...>` entirely — all lower layers are skipped.
-     * `actionUrl` left absent (key not present) falls through to the next layer.
+     * @param value - Options from a caller or the application customizer.
+     * @param label - What produced `value`, for the error message.
      */
-    private resolveActionUrl;
+    private narrowTwimlOptions;
     /**
-     * Overlay `perCall` onto `VoiceChannelConfig.defaultCallOptions`.
+     * Overlay `perCall` onto `ConversationRelayProviderConfig.defaultCallOptions`.
      *
-     * Per-field via key presence, the same convention {@link overlayFields} uses
-     * for TwiML options — so a per-call `{ machineDetection: undefined }`
+     * Per-field via key presence, the same convention `TwiMLBuilderBase.overlayFields`
+     * uses for TwiML options — so a per-call `{ machineDetection: undefined }`
      * explicitly clears the channel default rather than falling through to it.
      *
      * The result is always validated, for two reasons: a combination only
      * reachable by layering — per-call clearing `machineDetection` while the
      * default set `asyncAmd` — must still fail instead of reaching Twilio, and
-     * `VoiceChannelConfig` is a plain interface, so `defaultCallOptions` has had
-     * no runtime validation of its own.
+     * `ConversationRelayProviderConfigOptions` is a plain interface, so
+     * `defaultCallOptions` has had no runtime validation of its own.
      */
     private mergeCallOptions;
     /**
      * Build the extra arguments for `client.calls.create`.
      *
      * Layers, highest precedence first: this call's `callOptions`,
-     * `VoiceChannelConfig.defaultCallOptions`, then callback URLs derived from
-     * `voicePublicDomain` + `voiceCallEventPath`.
+     * `ConversationRelayProviderConfig.defaultCallOptions`, then callback URLs
+     * derived from `voicePublicDomain` + `voiceCallEventPath`.
      *
      * A URL is derived only when its handler is registered. That's a deliberate
      * deviation from `websocketUrl` / `actionUrl`, which derive unconditionally:
@@ -3881,14 +4204,16 @@ declare class VoiceChannel extends BaseChannel {
      *
      * TwiML fields are merged per-field, highest precedence first:
      *   1. `options.twimlOptions` — per-call overrides
-     *   2. `VoiceChannelConfig.defaultTwimlOptions` — channel-wide defaults
+     *   2. `ConversationRelayProviderConfig.defaultTwimlOptions` — channel-wide
+     *      defaults
      *   3. TAC defaults: welcome greeting, `conversationConfiguration` from
      *      `TACConfig`, and `actionUrl` from Studio handoff (if configured), else
      *      derived from `TACConfig.voicePublicDomain` + `voiceActionPath`.
      *
      * Calls-API parameters merge the same way:
      *   1. `options.callOptions` — per-call overrides
-     *   2. `VoiceChannelConfig.defaultCallOptions` — channel-wide defaults
+     *   2. `ConversationRelayProviderConfig.defaultCallOptions` — channel-wide
+     *      defaults
      *   3. Callback URLs derived from `TACConfig.voicePublicDomain` +
      *      `voiceCallEventPath`, for handlers that are registered
      *
@@ -3901,203 +4226,1849 @@ declare class VoiceChannel extends BaseChannel {
      * Handle ConversationRelay callback from Twilio. Cleans up on call completion
      * in voice-only mode; in orchestrated mode the CO webhook owns cleanup.
      *
-     * @param payload - Callback payload from Twilio
+     * @param rawPayload - Callback payload from Twilio
      * @returns Response with status, content, and content type
      */
-    handleConversationRelayCallback(payload: ConversationRelayCallbackPayload): Promise<{
-        status: number;
-        content: string;
-        contentType: string;
-    }>;
+    handleTwilioProviderCallback(rawPayload: Record<string, unknown>): Promise<TwilioProviderCallbackResponse>;
     /**
-     * Whether a call-webhook payload belongs to the configured account.
-     *
-     * Twilio signature validation already gates the route; this is defense in
-     * depth. A payload with no `AccountSid` is allowed through.
+     * Generate TwiML to connect a call to ConversationRelay.
+     * Validates configuration with Zod before generating TwiML.
      *
-     * Subaccounts: events carry the SID the call was placed on, so configure TAC
-     * with that account or its events get dropped here.
+     * @param config - ConversationRelay configuration (url, transcription, TTS, etc.)
+     * @param options - Optional settings for parameters and the Connect verb
+     * @returns TwiML XML string
+     * @throws {Error} if config validation fails
      */
-    private callEventAccountOk;
+    connectConversationRelay(config: ConversationRelayConfig, options?: {
+        parameters?: CustomParameters;
+        actionUrl?: string;
+    }): string;
     /**
-     * Parse a call-event webhook form and dispatch it to its handler.
+     * Drop this provider's ConversationRelay transport state on channel shutdown.
      *
-     * Returns 400 when the payload can't be parsed (no `CallSid`) or the handler
-     * throws — better than handing Twilio a 200 for an event that wasn't
-     * processed. Everything else, including no handler registered and an
-     * account mismatch, is a 200 no-op.
+     * Note: WebSocket connections are managed by the server and closed there.
+     * This method only cleans up internal provider state.
      */
-    private dispatchCallEvent;
+    shutdown(): void;
+}
+
+/**
+ * Callback that produces per-call overrides for the TwiML inside
+ * `<ConversationRelay>` on inbound calls. Receives a framework-neutral
+ * {@link TwiMLRequest} and returns {@link VoiceTwiMLOptionsConversationRelay}.
+ *
+ * Stays typed against the ConversationRelay subtype rather than the
+ * provider-agnostic base ({@link VoiceProvider.handleIncomingCall} is widened
+ * to the base, this consumer-facing surface is not): the base has only
+ * optional shared fields, so TypeScript's object-literal freshness check
+ * rejects the documented inline form `async () => ({ voice: '...' })` for
+ * having no properties in common with it. It widens once a second
+ * inbound-capable provider exists.
+ */
+type InboundCallTwimlHandler = (req: TwiMLRequest) => Promise<VoiceTwiMLOptionsConversationRelay>;
+/** Handler for Twilio `statusCallback` webhooks. */
+type CallStatusHandler = (event: CallStatusEvent) => Promise<void> | void;
+/** Handler for Twilio `asyncAmdStatusCallback` webhooks. */
+type AmdHandler = (event: AmdEvent) => Promise<void> | void;
+/** Handler for Twilio `recordingStatusCallback` webhooks. */
+type RecordingHandler = (event: RecordingEvent) => Promise<void> | void;
+/** One ConversationRelay keypress, as delivered to a {@link DtmfHandler}. */
+interface DtmfEvent {
+    /**
+     * Undefined only when the keypress beat conversation setup: `dtmf` before
+     * ConversationRelay's `setup`, or an orchestrated-mode lookup that failed.
+     */
+    conversationId: ConversationId | undefined;
+    /** Undefined only before ConversationRelay's `setup` message. */
+    callSid: string | undefined;
+    /** The key pressed: `0`-`9`, `*`, `#`, or `A`-`D`. */
+    digit: string;
+    /** Present whenever `conversationId` is. */
+    session?: ConversationSession;
+}
+/** Handler for ConversationRelay `dtmf` messages (caller keypresses). */
+type DtmfHandler = (event: DtmfEvent) => Promise<void> | void;
+/**
+ * Voice channel event callbacks extending base callbacks
+ */
+interface VoiceChannelEvents extends BaseChannelEvents {
+    onSetup?: (data: {
+        callSid: string;
+        from: string;
+        to: string;
+        customParameters: Record<string, unknown> | undefined;
+    }) => void;
+    onPrompt?: (data: {
+        conversationId: ConversationId;
+        transcript: string;
+        userMemory?: TACMemoryResponse;
+        session?: ConversationSession;
+        abortSignal: AbortSignal;
+    }) => Promise<void> | void;
+    onInterrupt?: (data: {
+        conversationId: ConversationId;
+        utteranceUntilInterrupt: string | undefined;
+        durationUntilInterruptMs: number | undefined;
+    }) => void;
+    /** Caller keypress. See {@link VoiceChannel.onDtmf}. */
+    onDtmf?: DtmfHandler;
     /**
-     * Handle a Twilio `statusCallback` webhook.
-     *
-     * The developer routes the request here (`TACServer` does this automatically
-     * for its `/status` call-event route). Parsed into a {@link CallStatusEvent}
-     * and dispatched to the {@link onCallStatus} handler. No-op if no handler is
-     * registered.
-     *
-     * @param form - Raw form data from the webhook request.
+     * Fired once the session and WebSocket registration exist — in orchestrated
+     * mode possibly before the first prompt, since the lookup starts at setup.
      */
-    handleCallStatusEvent(form: Record<string, string>): Promise<{
-        status: number;
-        content: string;
-        contentType: string;
-    }>;
-    /**
-     * Handle a Twilio `asyncAmdStatusCallback` webhook.
-     *
-     * The developer routes the request here (`TACServer` does this automatically
-     * for its `/amd` call-event route). Parsed into an {@link AmdEvent} and
-     * dispatched to the {@link onAmd} handler. No-op if no handler is registered.
-     *
-     * @param form - Raw form data from the webhook request.
+    onWebSocketConnected?: (data: {
+        conversationId: ConversationId;
+    }) => void;
+    onWebSocketDisconnected?: (data: {
+        conversationId: ConversationId;
+    }) => void;
+}
+/**
+ * Voice Channel for handling voice-based conversations over a WebSocket.
+ *
+ * The real-time media transport lives on a {@link VoiceProvider} — by default
+ * {@link ConversationRelayProvider}. `VoiceChannel` keeps the Calls-API
+ * lifecycle (call events, hangup), conversation bookkeeping and webhook
+ * processing, and delegates everything transport-shaped to the provider.
+ */
+declare class VoiceChannel extends BaseChannel {
+    private readonly provider;
+    private readonly voiceCallbacks;
+    private twilioClient;
+    private onInboundCallTwimlHandler;
+    private onCallStatusHandler;
+    private onAmdHandler;
+    private onRecordingHandler;
+    /**
+     * @param tac - The owning {@link TAC} instance.
+     * @param options - Either a {@link VoiceProviderConfig} selecting the media
+     *   provider, or a plain object — shorthand for
+     *   {@link ConversationRelayProviderConfig}, which is what TAC builds when no
+     *   provider config is given.
      */
-    handleAmdEvent(form: Record<string, string>): Promise<{
-        status: number;
-        content: string;
-        contentType: string;
-    }>;
+    constructor(tac: TAC, options?: VoiceProviderConfig | ConversationRelayProviderConfigOptions);
     /**
-     * Handle a Twilio `recordingStatusCallback` webhook.
+     * The {@link BaseChannelOptions} to hand `BaseChannel`. A provider config
+     * replays the options it retained (with its resolved `memoryMode`, which is
+     * writable after construction); a plain options object is passed through. Both
+     * paths therefore honour `dedupCapacity` and friends identically.
+     */
+    private static toBaseOptions;
+    /**
+     * Resolve the provider config: an explicit {@link VoiceProviderConfig} as-is,
+     * anything else wrapped as a {@link ConversationRelayProviderConfig}.
+     */
+    private static toProviderConfig;
+    /**
+     * Register a callback that produces per-call overrides for the TwiML inside
+     * `<ConversationRelay>` on inbound calls.
      *
-     * The developer routes the request here (`TACServer` does this automatically
-     * for its `/recording` call-event route). Parsed into a
-     * {@link RecordingEvent} and dispatched to the {@link onRecording} handler.
-     * No-op if no handler is registered.
+     * The callback receives a framework-neutral {@link TwiMLRequest} (parsed from
+     * the Twilio webhook form) and returns
+     * {@link VoiceTwiMLOptionsConversationRelay}. Fields the
+     * callback explicitly sets override `defaultTwimlOptions` and TAC defaults;
+     * unset fields fall through.
      *
-     * @param form - Raw form data from the webhook request.
+     * @example
+     * ```typescript
+     * voiceChannel.onInboundCallTwiml(async req => {
+     *   if (req.callerCountry === 'MX') {
+     *     return { language: 'es-MX', welcomeGreeting: '¡Hola!' };
+     *   }
+     *   return {};
+     * });
+     * ```
+     *
+     * Outbound calls don't use this — pass per-call TwiML via
+     * `InitiateVoiceConversationOptions.twimlOptions` directly.
      */
-    handleRecordingEvent(form: Record<string, string>): Promise<{
-        status: number;
-        content: string;
-        contentType: string;
-    }>;
+    onInboundCallTwiml(callback: InboundCallTwimlHandler): void;
     /**
-     * Hang up a call and clean up its ConversationRelay session.
+     * Register a handler for Twilio `statusCallback` webhooks.
      *
-     * Works on `callSid` alone, whether or not a session exists yet. No-ops the
-     * session cleanup if none is tracked.
+     * This is the Calls-API status callback (call disposition), not the
+     * ConversationRelay session callback — see
+     * {@link handleTwilioProviderCallback}.
      *
-     * Does not throw — hanging up an already-ended call is routine (the callee
-     * hangs up while AMD is still resolving), and handlers shouldn't have to
-     * guard against it.
+     * Registering does two things: it stores the handler, and it makes later
+     * outbound calls pass `statusCallback` to `calls.create`. With no handler
+     * registered TAC omits that parameter, so Twilio has nowhere to post and the
+     * event never arrives.
      *
-     * @param callSid - Twilio Call SID (from a call event, the outbound result, or
-     *   `ConversationSession.callSid`).
-     * @returns True if Twilio accepted the hangup, false if it failed (logged).
-     *   Session cleanup runs either way.
+     * Twilio reports only the terminal event by default, which covers every
+     * disposition; set `CallOptions.statusCallbackEvent` for ringing/answered.
+     *
+     * @example
+     * ```typescript
+     * voiceChannel.onCallStatus(async event => {
+     *   if (event.isUnreached) {
+     *     // queue a retry
+     *   }
+     * });
+     * ```
      */
-    endCall(callSid: string): Promise<boolean>;
+    onCallStatus(callback: CallStatusHandler): void;
     /**
-     * Look up the active voice session for a Twilio Call SID.
+     * Register a handler for Twilio `asyncAmdStatusCallback` webhooks.
      *
-     * Out-of-band code holding a CallSid — a dashboard route, an operator action,
-     * a call-event handler — can't reach the session-facing methods, which are
-     * keyed by conversation id: the Orchestrator conversation id in orchestrator
-     * mode, the CallSid only in ConversationRelay-only mode.
+     * Registering makes later outbound calls pass `asyncAmdStatusCallback` to
+     * `calls.create`; without a handler TAC omits it and Twilio has nowhere to
+     * post the result. It does not enable detection — that's per-call, via
+     * `CallOptions.machineDetection` and `asyncAmd`, both of which are required
+     * for this to fire (at most once per call).
      *
-     * Relay-only mode creates the session on the first prompt; orchestrated
-     * mode creates it when the lookup started at setup finishes, so it may
-     * exist before the caller speaks — including before `onAmd` fires. Treat it
-     * as racy and hang up with {@link endCall}, which needs no session.
+     * @example
+     * ```typescript
+     * voiceChannel.onAmd(async event => {
+     *   if (event.isMachine) {
+     *     await voiceChannel.endCall(event.callSid); // voicemail → hang up
+     *   }
+     * });
+     * ```
+     */
+    onAmd(callback: AmdHandler): void;
+    /**
+     * Register a handler for Twilio `recordingStatusCallback` webhooks.
      *
-     * At the other end, orchestrator mode keeps the session until Conversation
-     * Orchestrator's CLOSED webhook, so it outlives the call and `onCallStatus` /
-     * `onRecording` do resolve. Relay-only mode tears down on the
-     * ConversationRelay callback instead, which races them.
+     * Registering makes later outbound calls pass `recordingStatusCallback` to
+     * `calls.create`; without a handler TAC omits it and Twilio has nowhere to
+     * post. It does not start recording — that's `CallOptions.record`, which is
+     * required for this to fire.
      *
      * @example
      * ```typescript
-     * async function nudge(callSid: string): Promise<void> {
-     *   const session = voiceChannel.getConversationSessionByCallSid(callSid);
-     *   if (session) {
-     *     await voiceChannel.sendResponse(session.conversationId, 'Still there?');
+     * voiceChannel.onRecording(async event => {
+     *   if (event.recordingStatus === 'completed') {
+     *     // store event.recordingUrl
      *   }
-     * }
+     * });
      * ```
+     */
+    onRecording(callback: RecordingHandler): void;
+    /**
+     * Register a handler for DTMF keypresses, called once per key in order.
      *
-     * @param callSid - Twilio Call SID, e.g. from
-     *   `InitiateVoiceConversationResult.callSid` or a call event.
-     * @returns The session, or `undefined` — not created yet, the call ended, or
-     *   it landed on another instance (see the horizontal-scaling note in
-     *   CLAUDE.md).
+     * Requires `dtmfDetection: true` on the ConversationRelay config — without it
+     * Twilio sends nothing and this never fires. Digits aren't buffered, so
+     * accumulating a multi-digit entry is the handler's job.
+     *
+     * A keypress initializes the conversation just as a prompt does, since a
+     * caller can type without ever speaking; if that fails the digit still
+     * arrives, with `conversationId` and `session` undefined. Keypresses don't
+     * cancel in-flight streaming on their own — that's a separate `interrupt`
+     * message, sent when `interruptible` includes `dtmf`.
+     *
+     * @example
+     * ```typescript
+     * const digits = new Map<string, string>();
+     *
+     * voiceChannel.onDtmf(({ conversationId, digit }) => {
+     *   if (!conversationId) return;
+     *   digits.set(conversationId, (digits.get(conversationId) ?? '') + digit);
+     * });
+     * ```
      */
-    getConversationSessionByCallSid(callSid: string): ConversationSession | undefined;
+    onDtmf(callback: DtmfHandler): void;
     /**
-     * Start tracking a streaming task for a conversation
+     * The registered call-event handlers, for a `VoiceProvider` deciding which
+     * callback URLs to derive. A provider is not a subclass of `VoiceChannel`,
+     * so the `private` fields are genuinely out of reach without this.
      *
-     * @param conversationId - The conversation ID
-     * @returns The stream task with its AbortController
+     * @internal
      */
-    startStreamTask(conversationId: ConversationId): StreamTask;
+    getCallEventHandlers(): {
+        status: CallStatusHandler | undefined;
+        amd: AmdHandler | undefined;
+        recording: RecordingHandler | undefined;
+    };
     /**
-     * Cancel an active streaming task
+     * This channel's `TACConfig`, for a `VoiceProvider` deriving default URLs.
+     * `BaseChannel.config` is `protected`, and a provider is not a subclass.
      *
-     * @param conversationId - The conversation ID
-     * @returns true if a task was cancelled, false otherwise
+     * @internal
      */
-    cancelStreamTask(conversationId: ConversationId): boolean;
+    getTacConfig(): TACConfig;
     /**
-     * Complete a streaming task (remove from tracking)
+     * This channel's logger, so a provider's relocated logic keeps logging under
+     * the same name it did when it lived on `VoiceChannel`.
      *
-     * @param conversationId - The conversation ID
+     * @internal
      */
-    completeStreamTask(conversationId: ConversationId): void;
+    getLoggerInternal(): Logger;
     /**
-     * Check if a stream task is active
+     * The Conversation Orchestrator client, or `null` in ConversationRelay-only
+     * mode.
+     *
+     * @internal
+     */
+    getConversationClientInternal(): ConversationClient | null;
+    /**
+     * The lazily built Twilio REST client, for a provider placing outbound calls.
+     *
+     * @internal
+     */
+    getTwilioClientInternal(): ReturnType<typeof Twilio>;
+    /**
+     * Whether Conversation Orchestrator is configured. Providers branch on this
+     * to decide who owns conversation cleanup.
+     *
+     * @internal
+     */
+    isOrchestratorEnabledInternal(): boolean;
+    /**
+     * Voice event callbacks registered via {@link on}, for a provider to fire.
+     *
+     * @internal
+     */
+    getVoiceCallbacks(): VoiceChannelEvents;
+    /**
+     * The inbound-TwiML customizer registered via {@link onInboundCallTwiml}, for
+     * a provider building the inbound response.
+     *
+     * @internal
+     */
+    getInboundCallTwimlHandler(): InboundCallTwimlHandler | undefined;
+    /**
+     * Start tracking a conversation session. Forwards to
+     * `BaseChannel.startConversation`.
+     *
+     * @internal
+     */
+    startConversationInternal(conversationId: ConversationId, profileId?: ProfileId): ConversationSession;
+    /**
+     * End a tracked conversation session. Forwards to
+     * `BaseChannel.endConversation`.
+     *
+     * @internal
+     */
+    endConversationInternal(conversationId: ConversationId): Promise<void>;
+    /**
+     * Retrieve memory when `memoryMode` calls for it. Forwards to
+     * `BaseChannel.retrieveMemoryIfEnabled`.
+     *
+     * @internal
+     */
+    retrieveMemoryInternal(session: ConversationSession, query?: string): Promise<TACMemoryResponse | undefined>;
+    /**
+     * Report an error through the channel's `onError` callback and logger.
+     * Forwards to `BaseChannel.handleError`.
+     *
+     * @internal
+     */
+    handleErrorInternal(error: Error, context?: Record<string, unknown>): void;
+    private getTwilioClient;
+    get channelType(): ChannelType;
+    /**
+     * Register event callbacks (override for Voice-specific events)
+     */
+    on(event: string, callback: (...args: any[]) => void): void;
+    /**
+     * Process conversation webhooks for cleanup.
+     *
+     * Voice channel processes CONVERSATION_UPDATED events:
+     * - CLOSED status: Clean up local session state
+     *
+     * Note: Conversation tracking uses instance-local memory. In multi-instance
+     * deployments, webhooks may route to a different instance, preventing cleanup.
+     *
+     * @param payload - Raw webhook event data from Twilio
+     * @param idempotencyToken - Optional Twilio idempotency token from request headers
+     */
+    processWebhook(payload: unknown, idempotencyToken?: string): Promise<void>;
+    /**
+     * Handle conversation updated event
+     */
+    private handleConversationUpdated;
+    /**
+     * Get active WebSocket connection for a conversation
+     */
+    getWebsocket(conversationId: ConversationId): WebSocket | null;
+    /**
+     * Hand one WebSocket connection to the active provider, which drives its
+     * lifecycle from accept to disconnect.
+     *
+     * @param ws - The accepted WebSocket, from ConversationRelay or whatever
+     *   transport the active provider serves.
+     */
+    handleWebSocketConnection(ws: WebSocket): void;
+    /**
+     * Send voice response via WebSocket
+     */
+    sendResponse(conversationId: ConversationId, message: string, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Send a streaming voice response through the active provider's transport,
+     * token by token. Delegates to the active provider — see
+     * {@link ConversationRelayProvider.sendStreamingResponse} for the token
+     * protocol and abort semantics.
+     *
+     * @param conversationId - Conversation whose transport receives the tokens.
+     * @param stream - Async iterable of text chunks to relay as they arrive.
+     * @param options - Additional per-call inputs.
+     * @param options.signal - Aborts the stream mid-flight, e.g. when the caller
+     *   interrupts.
+     * @returns The accumulated full response text.
+     */
+    sendStreamingResponse(conversationId: ConversationId, stream: AsyncIterable<string>, options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /**
+     * Generate the response for an incoming voice call. Delegates to the active
+     * provider — see {@link ConversationRelayProvider.handleIncomingCall} for the
+     * full TwiML merge/precedence rules (only meaningful for that provider; a
+     * provider with no inbound story declines instead).
+     *
+     * @param twimlRequest - Parsed Twilio webhook fields. Passed to the customizer
+     *   registered via {@link onInboundCallTwiml}, if one is configured.
+     * @param options - Additional per-call inputs.
+     * @param options.hostTwimlOptions - Per-call TwiML supplied by a custom
+     *   in-process host (e.g. an affinity-routed deployment injecting a per-call
+     *   `websocketUrl`). Typed against the ConversationRelay subtype for the same
+     *   reason as {@link InboundCallTwimlHandler}.
+     * @returns TwiML XML string for call connection.
+     */
+    handleIncomingCall(twimlRequest?: TwiMLRequest, options?: {
+        hostTwimlOptions?: VoiceTwiMLOptionsConversationRelay;
+    }): Promise<string>;
+    /**
+     * Initiate an outbound voice conversation. Delegates to the active provider —
+     * see {@link ConversationRelayProvider.initiateOutboundConversation} for the
+     * TwiML and Calls-API merge/precedence rules.
+     *
+     * {@link ConversationRelayProvider} and `OpenAIRealtimeProvider` place
+     * outbound calls; any other provider declines.
+     *
+     * @param options - Destination, per-call TwiML and Calls-API overrides.
+     *   `OpenAIRealtimeProvider` additionally accepts a per-call `sessionConfig`.
+     *   Each provider validates against its own schema and rejects the other's.
+     * @returns The placed call's `callSid`.
+     */
+    initiateOutboundConversation(options: InitiateVoiceConversationOptions): Promise<InitiateVoiceConversationResult>;
+    /**
+     * Handle the provider's own out-of-band lifecycle webhook from Twilio.
+     *
+     * Not every provider has one; those that don't inherit a plain 200
+     * acknowledgement. ConversationRelay posts here when a session ends, and
+     * cleans up on call completion in voice-only mode — in orchestrated mode the
+     * CO webhook owns cleanup.
+     *
+     * @param payload - Raw callback payload from Twilio; the provider validates it.
+     * @returns Response with status, content, and content type
+     */
+    handleTwilioProviderCallback(payload: Record<string, unknown>): Promise<TwilioProviderCallbackResponse>;
+    /**
+     * @deprecated Use {@link VoiceChannel.handleTwilioProviderCallback} instead.
+     */
+    handleConversationRelayCallback(payload: ConversationRelayCallbackPayload): Promise<TwilioProviderCallbackResponse>;
+    /**
+     * Whether a call-webhook payload belongs to the configured account.
+     *
+     * Twilio signature validation already gates the route; this is defense in
+     * depth. A payload with no `AccountSid` is allowed through.
+     *
+     * Subaccounts: events carry the SID the call was placed on, so configure TAC
+     * with that account or its events get dropped here.
+     */
+    private callEventAccountOk;
+    /**
+     * Parse a call-event webhook form and dispatch it to its handler.
+     *
+     * Returns 400 when the payload can't be parsed (no `CallSid`) or the handler
+     * throws — better than handing Twilio a 200 for an event that wasn't
+     * processed. Everything else, including no handler registered and an
+     * account mismatch, is a 200 no-op.
+     */
+    private dispatchCallEvent;
+    /**
+     * Handle a Twilio `statusCallback` webhook.
+     *
+     * The developer routes the request here (`TACServer` does this automatically
+     * for its `/status` call-event route). Parsed into a {@link CallStatusEvent}
+     * and dispatched to the {@link onCallStatus} handler. No-op if no handler is
+     * registered.
+     *
+     * @param form - Raw form data from the webhook request.
+     */
+    handleCallStatusEvent(form: Record<string, string>): Promise<{
+        status: number;
+        content: string;
+        contentType: string;
+    }>;
+    /**
+     * Handle a Twilio `asyncAmdStatusCallback` webhook.
+     *
+     * The developer routes the request here (`TACServer` does this automatically
+     * for its `/amd` call-event route). Parsed into an {@link AmdEvent} and
+     * dispatched to the {@link onAmd} handler. No-op if no handler is registered.
+     *
+     * @param form - Raw form data from the webhook request.
+     */
+    handleAmdEvent(form: Record<string, string>): Promise<{
+        status: number;
+        content: string;
+        contentType: string;
+    }>;
+    /**
+     * Handle a Twilio `recordingStatusCallback` webhook.
+     *
+     * The developer routes the request here (`TACServer` does this automatically
+     * for its `/recording` call-event route). Parsed into a
+     * {@link RecordingEvent} and dispatched to the {@link onRecording} handler.
+     * No-op if no handler is registered.
+     *
+     * @param form - Raw form data from the webhook request.
+     */
+    handleRecordingEvent(form: Record<string, string>): Promise<{
+        status: number;
+        content: string;
+        contentType: string;
+    }>;
+    /**
+     * Hang up a call and clean up its ConversationRelay session.
+     *
+     * Works on `callSid` alone, whether or not a session exists yet. No-ops the
+     * session cleanup if none is tracked.
+     *
+     * Does not throw — hanging up an already-ended call is routine (the callee
+     * hangs up while AMD is still resolving), and handlers shouldn't have to
+     * guard against it.
+     *
+     * @param callSid - Twilio Call SID (from a call event, the outbound result, or
+     *   `ConversationSession.callSid`).
+     * @returns True if Twilio accepted the hangup, false if it failed (logged).
+     *   Session cleanup runs either way.
+     */
+    endCall(callSid: string): Promise<boolean>;
+    /**
+     * Look up the active voice session for a Twilio Call SID.
+     *
+     * Out-of-band code holding a CallSid — a dashboard route, an operator action,
+     * a call-event handler — can't reach the session-facing methods, which are
+     * keyed by conversation id: the Orchestrator conversation id in orchestrator
+     * mode, the CallSid only in ConversationRelay-only mode.
+     *
+     * Relay-only mode creates the session on the first prompt; orchestrated
+     * mode creates it when the lookup started at setup finishes, so it may
+     * exist before the caller speaks — including before `onAmd` fires. Treat it
+     * as racy and hang up with {@link endCall}, which needs no session.
+     *
+     * At the other end, orchestrator mode keeps the session until Conversation
+     * Orchestrator's CLOSED webhook, so it outlives the call and `onCallStatus` /
+     * `onRecording` do resolve. Relay-only mode tears down on the
+     * ConversationRelay callback instead, which races them.
+     *
+     * @example
+     * ```typescript
+     * async function nudge(callSid: string): Promise<void> {
+     *   const session = voiceChannel.getConversationSessionByCallSid(callSid);
+     *   if (session) {
+     *     await voiceChannel.sendResponse(session.conversationId, 'Still there?');
+     *   }
+     * }
+     * ```
+     *
+     * @param callSid - Twilio Call SID, e.g. from
+     *   `InitiateVoiceConversationResult.callSid` or a call event.
+     * @returns The session, or `undefined` — not created yet, the call ended, or
+     *   it landed on another instance (see the horizontal-scaling note in
+     *   CLAUDE.md).
+     */
+    getConversationSessionByCallSid(callSid: string): ConversationSession | undefined;
+    /**
+     * Narrow `provider` to the ConversationRelay implementation for the
+     * ConversationRelay-only forwarders on this channel.
+     *
+     * Throws whenever a consumer supplies a non-ConversationRelay provider, which
+     * is the point of the guard. The provider callback used to narrow here too; it
+     * now rides {@link VoiceProvider.handleTwilioProviderCallback}'s
+     * base-compatible signature instead, which is the eventual shape for these
+     * forwarders.
+     *
+     * @throws {Error} if this channel's provider is not ConversationRelay-based.
+     */
+    private requireConversationRelayProvider;
+    /**
+     * Start tracking a streaming task for a conversation
+     *
+     * @param conversationId - The conversation ID
+     * @returns The stream task with its AbortController
+     */
+    startStreamTask(conversationId: ConversationId): StreamTask;
+    /**
+     * Cancel an active streaming task
+     *
+     * @param conversationId - The conversation ID
+     * @returns true if a task was cancelled, false otherwise
+     */
+    cancelStreamTask(conversationId: ConversationId): boolean;
+    /**
+     * Complete a streaming task (remove from tracking)
+     *
+     * @param conversationId - The conversation ID
+     */
+    completeStreamTask(conversationId: ConversationId): void;
+    /**
+     * Check if a stream task is active
+     *
+     * @param conversationId - The conversation ID
+     * @returns true if an active task exists
+     */
+    hasActiveStreamTask(conversationId: ConversationId): boolean;
+    /**
+     * Generate TwiML to connect a call to ConversationRelay. Delegates to
+     * {@link ConversationRelayProvider.connectConversationRelay}, which validates
+     * the configuration with Zod before generating TwiML.
+     *
+     * @param config - ConversationRelay configuration (url, transcription, TTS, etc.)
+     * @param options - Optional settings for parameters and the Connect verb
+     * @returns TwiML XML string
+     * @throws {Error} if config validation fails, or if this channel's provider is
+     *   not ConversationRelay-based.
+     */
+    connectConversationRelay(config: ConversationRelayConfig, options?: {
+        parameters?: CustomParameters;
+        actionUrl?: string;
+    }): string;
+    /**
+     * Cleanup channel state on shutdown
+     *
+     * Note: WebSocket connections are managed by the server and closed there.
+     * This method only cleans up internal channel state.
+     */
+    shutdown(): void;
+}
+
+/**
+ * Common construction and option-layering helpers shared by every provider's
+ * TwiML builder.
+ *
+ * Subclasses take `TACConfig` and their provider's channel config wholesale
+ * (not individual derived values) so a later change to either — a new field, a
+ * new default — is a change to the builder alone, not a change to what
+ * `VoiceChannel` has to compute and hand over.
+ *
+ * @internal
+ */
+declare abstract class TwiMLBuilderBase<TChannelConfig = unknown> {
+    protected readonly tacConfig: TACConfig;
+    protected readonly channelConfig: TChannelConfig;
+    protected readonly logger: Logger;
+    constructor(tacConfig: TACConfig, channelConfig: TChannelConfig, logger: Logger);
+    /**
+     * Apply fields explicitly present on `source` onto `target`, except those
+     * named in `skip`.
+     *
+     * Nested objects, arrays, and dicts replace wholesale — there's no per-key
+     * merging.
+     *
+     * "Explicitly present" is detected via key presence (`Object.keys`), which
+     * mirrors Python's `model_fields_set`: a key set to `undefined` is still
+     * "present" and overrides lower layers, while an absent key falls through.
+     */
+    protected overlayFields(target: Record<string, unknown>, source: Record<string, unknown>, skip?: readonly string[]): void;
+    /**
+     * The error thrown when no layer and no `TACConfig`-derived default supplies
+     * a WebSocket URL. `caller` names the API the developer actually called.
+     */
+    protected missingWebsocketUrlError(caller: string): Error;
+    /**
+     * The WebSocket URL derived from `TACConfig.voicePublicDomain` +
+     * `TACConfig.voiceWebsocketPath`, or undefined when `voicePublicDomain` is
+     * unset.
+     */
+    protected defaultWebsocketUrl(): string | undefined;
+    /**
+     * Resolve the default `<Connect action=...>` cleanup URL from
+     * `TACConfig.voicePublicDomain` + `TACConfig.voiceActionPath`.
+     *
+     * Returns undefined if `voicePublicDomain` isn't set; that's fine because
+     * actionUrl has higher-priority layers (customizer, twimlOptions, Studio
+     * handoff) above this fallback.
+     */
+    protected defaultActionUrl(): string | undefined;
+}
+
+/**
+ * The slice of a Media Streams provider's config this builder reads. Declared
+ * structurally rather than importing the provider's config class, so the
+ * builder does not depend on which Media Streams provider owns it.
+ */
+interface MediaStreamsTwiMLBuilderConfig {
+    defaultTwimlOptions?: VoiceTwiMLOptionsMediaStreams | undefined;
+}
+/**
+ * Generate TwiML that connects the call to a bidirectional Media Stream.
+ *
+ * See https://www.twilio.com/docs/voice/twiml/stream for the `<Stream>` verb.
+ *
+ * The WebSocket URL may be passed positionally or as `options.websocketUrl`
+ * (positional wins when both are given), so a caller can pass everything in one
+ * object: `generateStreamTwiml(undefined, { websocketUrl: ... })`.
+ *
+ * @param websocketUrl - Public `wss://` URL of the WebSocket endpoint Twilio
+ *   should stream call audio to (the `<Stream url=...>` attribute). Optional if
+ *   `options.websocketUrl` is set.
+ * @param options - Optional Media Streams TwiML options.
+ * @returns TwiML XML string ready to return to Twilio.
+ * @throws {Error} if no WebSocket URL is provided via either source.
+ */
+declare function generateStreamTwiml(websocketUrl?: string, options?: VoiceTwiMLOptionsMediaStreams): string;
+/** Per-call inputs to {@link TwiMLBuilderMediaStreams.build}. */
+interface BuildStreamTwiMLInputs {
+    /**
+     * Per-call overrides from the host owning the route (e.g. a per-call
+     * `websocketUrl` with an affinity token). Lowest of the option layers.
+     */
+    host?: VoiceTwiMLOptionsMediaStreams | undefined;
+    /**
+     * Per-call overrides — the `onInboundCallTwiml` customizer's output for
+     * inbound, or `InitiateVoiceConversationOptions.twimlOptions` for outbound.
+     * Highest layer.
+     */
+    perCall?: VoiceTwiMLOptionsMediaStreams | undefined;
+    /**
+     * Dedicated per-call WebSocket override that wins over any `websocketUrl`
+     * coming through the option layers. Used by outbound, which takes it as its
+     * own argument.
+     */
+    websocketUrl?: string | undefined;
+}
+/**
+ * Builds the TwiML for a Media Streams call, owning the layering and WebSocket
+ * URL resolution so the provider doesn't have to.
+ */
+declare class TwiMLBuilderMediaStreams extends TwiMLBuilderBase<MediaStreamsTwiMLBuilderConfig> {
+    /**
+     * Build the TwiML XML for one call.
+     *
+     * TwiML fields are merged per-field, highest precedence first:
+     *   1. `perCall` — the `onInboundCallTwiml` customizer's output for inbound,
+     *      or `InitiateVoiceConversationOptions.twimlOptions` for outbound
+     *   2. the provider config's `defaultTwimlOptions` — channel-wide defaults
+     *   3. `host` — per-call transport facts supplied by the host
+     *   4. TAC defaults: the WebSocket URL derived from
+     *      `TACConfig.voicePublicDomain` + `voiceWebsocketPath`
+     *
+     * @param caller - Name of the calling method, used in the "no WebSocket URL"
+     *   error so it points at the API the developer actually called.
+     * @param options - Per-call option layers and WebSocket override.
+     * @throws {Error} if no layer and no `TACConfig`-derived default supplies a
+     *   WebSocket URL.
+     */
+    build(caller: string, options?: BuildStreamTwiMLInputs): string;
+    /**
+     * Layer TwiML options, lowest precedence first: `host` →
+     * `defaultTwimlOptions` → `perCall`.
+     *
+     * `customParameters` replaces wholesale when set at a higher-priority layer —
+     * there's no per-key merging.
+     */
+    protected buildTwimlOptions(host: VoiceTwiMLOptionsMediaStreams | undefined, perCall: VoiceTwiMLOptionsMediaStreams | undefined): VoiceTwiMLOptionsMediaStreams;
+}
+
+/** Options accepted by {@link MediaStreamsProviderConfig}. */
+interface MediaStreamsProviderConfigOptions extends BaseChannelOptions {
+    /**
+     * Static `VoiceTwiMLOptionsMediaStreams` applied to every inbound call.
+     * Per-call customization is registered via
+     * `VoiceChannel.onInboundCallTwiml(...)`, which takes precedence over this.
+     */
+    defaultTwimlOptions?: VoiceTwiMLOptionsMediaStreams;
+}
+/**
+ * Base configuration for a Media Streams (`<Connect><Stream>`) provider.
+ *
+ * Holds the transport-level settings every Media Streams provider shares,
+ * independent of which model or protocol runs over the stream.
+ */
+declare class MediaStreamsProviderConfig extends VoiceProviderConfig {
+    /**
+     * Static `VoiceTwiMLOptionsMediaStreams` applied to every inbound call.
+     * Per-call customization is registered via
+     * `VoiceChannel.onInboundCallTwiml(...)`, which takes precedence over this.
+     */
+    readonly defaultTwimlOptions?: VoiceTwiMLOptionsMediaStreams;
+    constructor(options?: MediaStreamsProviderConfigOptions);
+}
+
+/**
+ * TAC Tool class with helper methods for LLM integration
+ *
+ * Matches Python's TACTool dataclass with conversion methods.
+ */
+declare class TACTool<TParams = unknown, TResult = unknown> {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: JSONSchema;
+    readonly implementation: ToolFunction<TParams, TResult>;
+    constructor(name: string, description: string, parameters: JSONSchema, implementation: ToolFunction<TParams, TResult>);
+    /**
+     * Convert to OpenAI function calling format
+     */
+    toOpenAIFormat(): OpenAITool;
+    /**
+     * Convert to OpenAI Realtime function calling format.
+     *
+     * Unlike {@link TACTool.toOpenAIFormat} (Chat Completions, which nests the
+     * schema under a `function` key), Realtime's `session.tools` expects the
+     * fields flat on the tool object.
+     */
+    toRealtimeFormat(): OpenAIRealtimeTool;
+    /**
+     * Convert to Anthropic tool calling format
+     */
+    toAnthropicFormat(): AnthropicTool;
+    /**
+     * Convert to JSON string (OpenAI format by default)
+     */
+    toJSON(): string;
+    /**
+     * Convert this tool to an OpenAI Agents SDK `FunctionTool` instance.
+     *
+     * Unlike `toOpenAIFormat` and `toAnthropicFormat` (which return plain
+     * objects consumed by HTTP APIs), the OpenAI Agents SDK dispatches on tool
+     * *type*, so this returns a live `tool(...)` object with an invoke callback
+     * that calls this tool and JSON-encodes the result.
+     *
+     * Requires the `@openai/agents` package:
+     *
+     *     npm install @openai/agents
+     *
+     * @returns A FunctionTool ready to pass to `new Agent({ tools: [...] })`.
+     */
+    toOpenAIAgentsSDKTool(): Promise<any>;
+}
+/**
+ * Create a tool directly with all parameters
+ *
+ * Simplified approach matching Python's create_tool function.
+ * No builder pattern - just a simple function call.
+ */
+declare function defineTool<TParams = unknown, TResult = unknown>(name: string, description: string, parameters: JSONSchema, implementation: ToolFunction<TParams, TResult>): TACTool<TParams, TResult>;
+
+/**
+ * Parameters for memory retrieval tool
+ */
+interface MemoryRetrievalParams {
+    query?: string;
+    beginDate?: string;
+    endDate?: string;
+    observationsLimit?: number;
+    summariesLimit?: number;
+    communicationsLimit?: number;
+    relevanceThreshold?: number;
+}
+/**
+ * Create memory retrieval tool.
+ *
+ * @param memoryClient - Memory client instance (must be initialized with storeId)
+ * @param profileId - Optional profile ID for memory retrieval
+ * @param conversationId - Optional conversation ID for memory retrieval
+ * @param options - Optional overrides for tool metadata.
+ * @param options.name - Tool name exposed to the LLM. Defaults to `retrieve_profile_memory`.
+ * @param options.description - Tool description exposed to the LLM. Defaults to a
+ *   generic "retrieve memories" prompt.
+ */
+declare function createMemoryRetrievalTool(memoryClient: MemoryClient, profileId?: string, conversationId?: string, options?: {
+    name?: string;
+    description?: string;
+}): TACTool<MemoryRetrievalParams, MemoryRetrievalResponse>;
+/**
+ * Create factory function for memory tools
+ *
+ * @param memoryClient - Memory client instance (must be initialized with storeId)
+ */
+declare function createMemoryTools(memoryClient: MemoryClient): {
+    forProfile: (profileId: string, conversationId?: string) => TACTool<MemoryRetrievalParams, MemoryRetrievalResponse>;
+    forSession: (profileId?: string, conversationId?: string) => TACTool<MemoryRetrievalParams, MemoryRetrievalResponse>;
+};
+
+/**
+ * Parameters for send message tool
+ */
+interface SendMessageParams {
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result from send message tool
+ */
+interface SendMessageResult {
+    success: boolean;
+    message_id?: string;
+    error?: string;
+}
+/**
+ * Create send message tool
+ */
+declare function createSendMessageTool(channel: BaseChannel, conversationId: ConversationId): TACTool<SendMessageParams, SendMessageResult>;
+/**
+ * Create factory function for messaging tools
+ */
+declare function createMessagingTools(): {
+    forConversation: (channel: BaseChannel, conversationId: ConversationId) => TACTool<SendMessageParams, SendMessageResult>;
+};
+
+/**
+ * Handoff tool for the Twilio Agent Connect.
+ *
+ * Generic Studio-backed handoff that routes a conversation to a human agent.
+ * Produces a structured HandoffPayload and delivers it as a Twilio Studio
+ * Execution (voice via `<Connect action>`, digital channels via direct POST).
+ */
+
+/**
+ * Build a HandoffPayload from session context and attributes.
+ *
+ * Useful for custom handoff tools that want TAC's payload shape without
+ * the Studio-specific delivery in `postStudioHandoff`.
+ */
+declare function buildHandoffPayload(session: ConversationSession, memoryStoreId: string, attributes: Record<string, unknown>): HandoffPayload;
+/**
+ * POST a handoff payload to a Twilio Studio Flow Executions endpoint.
+ *
+ * Emits the Twilio Studio Executions API wire format: form-encoded
+ * `To` / `From` / `Parameters` fields with HTTP Basic auth.
+ * `Parameters` is a JSON string keyed under `HandoffData` so Studio
+ * can reference it via `{{flow.data.HandoffData.*}}`.
+ */
+declare function postStudioHandoff(payload: HandoffPayload, session: ConversationSession, options: {
+    handoffUrl: string;
+    fromAddress: string;
+    apiKey: string;
+    apiSecret: string;
+}): Promise<void>;
+/**
+ * Result returned by the handoff tool.
+ */
+interface HandoffResult {
+    status: 'handoff_initiated' | 'handoff_failed';
+    channel: string;
+    error?: string;
+}
+interface HandoffParams {
+    reason: string;
+}
+/**
+ * Create a handoff tool that delivers in the Twilio Studio Executions API shape.
+ *
+ * The returned tool exposes only `handoff({ reason })` to the LLM. All other
+ * dependencies (TAC instance, session, static attributes) are captured in the
+ * closure.
+ *
+ * On digital channels, the tool POSTs to the Studio Flow Executions endpoint
+ * derived from `tac.getConfig().studioHandoffFlowSid`. For voice channels,
+ * the payload is stored on the session and the voice channel automatically
+ * sends the WS `end` message with `handoffData` after the LLM's final
+ * response is delivered.
+ *
+ * The tool also sets the conversation to INACTIVE and clears status callbacks
+ * to prevent further webhook events from being routed to TAC.
+ *
+ * **Not available in voice-only mode.** This tool requires Conversation
+ * Orchestrator for conversation state management and Conversation Memory for
+ * the handoff payload. In voice-only mode, implement your own handoff by
+ * setting `session.pendingHandoffData` directly — the voice channel will
+ * send the WS `end` message with your payload, and your `<Connect action>`
+ * URL handler can route the call accordingly.
+ *
+ * @throws Error if `tac.getConfig().studioHandoffFlowSid` is unset, if
+ *   Conversation Orchestrator is not configured (voice-only mode), or if
+ *   the memory store ID was not resolved at startup.
+ */
+declare function createStudioHandoffTool(tac: TAC, session: ConversationSession, options?: {
+    attributes?: Record<string, unknown>;
+    name?: string;
+    description?: string;
+}): TACTool<HandoffParams, HandoffResult>;
+
+/**
+ * Parameters for knowledge search tool (visible to LLM)
+ */
+interface KnowledgeSearchParams {
+    query: string;
+}
+/**
+ * Configuration for knowledge search tool
+ */
+interface KnowledgeToolConfig {
+    name?: string;
+    description?: string;
+    topK?: number;
+}
+/**
+ * Create knowledge search tool with explicit name and description
+ *
+ * @param knowledgeClient - The Knowledge client instance
+ * @param knowledgeBaseId - The knowledge base ID to search
+ * @param config - Configuration with required name and description
+ * @returns TACTool configured for knowledge search
+ */
+declare function createKnowledgeSearchTool(knowledgeClient: KnowledgeClient, knowledgeBaseId: string, config: {
+    name: string;
+    description: string;
+    topK?: number;
+}): TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>;
+/**
+ * Create knowledge search tool with auto-fetched metadata from knowledge base
+ *
+ * This async version fetches the knowledge base metadata to auto-generate
+ * the tool name and description if not provided.
+ *
+ * @param knowledgeClient - The Knowledge client instance
+ * @param knowledgeBaseId - The knowledge base ID to search
+ * @param config - Optional configuration (name/description auto-generated if not provided)
+ * @returns Promise containing TACTool configured for knowledge search
+ */
+declare function createKnowledgeSearchToolAsync(knowledgeClient: KnowledgeClient, knowledgeBaseId: string, config?: KnowledgeToolConfig): Promise<TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>>;
+/**
+ * Create factory for knowledge tools
+ *
+ * @param knowledgeClient - The Knowledge client instance
+ * @returns Factory object with methods to create knowledge tools
+ */
+declare function createKnowledgeTools(knowledgeClient: KnowledgeClient): {
+    forKnowledgeBase: (knowledgeBaseId: string, config: {
+        name: string;
+        description: string;
+        topK?: number;
+    }) => TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>;
+    forKnowledgeBaseAsync: (knowledgeBaseId: string, config?: KnowledgeToolConfig) => Promise<TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>>;
+};
+
+/**
+ * Options accepted by {@link MediaStreamsOpenAIProviderConfig}.
+ */
+interface MediaStreamsOpenAIProviderConfigOptions extends MediaStreamsProviderConfigOptions {
+    /**
+     * OpenAI API key. Defaults to the `OPENAI_API_KEY` environment variable.
+     */
+    openaiApiKey?: string;
+    /**
+     * Executable `TACTool` implementations, looked up by name to run mid-call
+     * tool requests. This alone does not tell the model these tools exist — the
+     * session config sent to OpenAI must separately declare each tool's schema.
+     */
+    tools?: TACTool<never, unknown>[];
+    /**
+     * Session configuration sent to OpenAI once the model connects — used for any
+     * call that doesn't supply its own via
+     * {@link MediaStreamsOpenAIProviderConfigOptions.onInboundCallSessionConfig}
+     * or per-call outbound options.
+     *
+     * If using {@link MediaStreamsOpenAIProviderConfigOptions.tools}, this config
+     * must separately list each tool's schema — it is passed to OpenAI as-is,
+     * with no tool schemas merged in.
+     */
+    defaultSessionConfig?: Record<string, unknown>;
+    /**
+     * Per-inbound-call override for
+     * {@link MediaStreamsOpenAIProviderConfigOptions.defaultSessionConfig},
+     * called with the `TwiMLRequest`. Its return value is used verbatim (not
+     * merged with `defaultSessionConfig`); return `null` to fall back to it.
+     * Outbound calls don't use this — they pass their session config per call.
+     */
+    onInboundCallSessionConfig?: (req: TwiMLRequest) => Promise<Record<string, unknown> | null>;
+}
+/**
+ * Base configuration for an OpenAI-backed Media Streams provider.
+ *
+ * Holds what every OpenAI-backed Media Streams provider needs — credentials,
+ * executable tools, and the session config sent when the model connects —
+ * independent of which OpenAI API runs over the stream.
+ */
+declare class MediaStreamsOpenAIProviderConfig extends MediaStreamsProviderConfig {
+    /** OpenAI API key. Defaults to the `OPENAI_API_KEY` environment variable. */
+    readonly openaiApiKey: string;
+    /**
+     * Executable `TACTool` implementations, looked up by name to run mid-call
+     * tool requests. This alone does not tell the model these tools exist — the
+     * session config sent to OpenAI must separately declare each tool's schema.
+     */
+    readonly tools: TACTool<never, unknown>[];
+    /**
+     * Session configuration sent to OpenAI once the model connects — used for any
+     * call that doesn't supply its own via
+     * {@link MediaStreamsOpenAIProviderConfig.onInboundCallSessionConfig} or
+     * per-call outbound options.
+     *
+     * If using {@link MediaStreamsOpenAIProviderConfig.tools}, this config must
+     * separately list each tool's schema — it is passed to OpenAI as-is, with no
+     * tool schemas merged in.
+     */
+    readonly defaultSessionConfig?: Record<string, unknown>;
+    /**
+     * Per-inbound-call override for
+     * {@link MediaStreamsOpenAIProviderConfig.defaultSessionConfig}, called with
+     * the `TwiMLRequest`. Its return value is used verbatim (not merged with
+     * `defaultSessionConfig`); return `null` to fall back to it. Outbound calls
+     * don't use this — they pass their session config per call.
+     */
+    readonly onInboundCallSessionConfig?: (req: TwiMLRequest) => Promise<Record<string, unknown> | null>;
+    constructor(options?: MediaStreamsOpenAIProviderConfigOptions);
+}
+
+/**
+ * Both legs of one call's audio bridge — the Twilio-facing socket and the
+ * model-facing socket — live here together, rather than in two parallel maps
+ * keyed by conversation id that could drift out of sync.
+ *
+ * `streamSid` and `transcript` live on `ConversationSession.metadata` instead,
+ * not here: this map is deleted before `onConversationEnded` fires, so anything
+ * a handler needs to read after the call ends must survive on the session.
+ *
+ * @internal
+ */
+declare class MediaStreamsOpenAICallState {
+    twilioWs: WebSocket | null;
+    modelWs: WebSocket | null;
+    /**
+     * Resolves `true` once this call's model socket is open and its session
+     * config has been sent, or `false` if that handshake failed. `null` until the
+     * handshake has been started.
+     *
+     * Twilio begins streaming caller audio as soon as the media stream opens,
+     * which is well before the OpenAI handshake completes. Caller audio waits on
+     * this promise rather than being written to a socket that does not exist
+     * yet, so a caller who speaks the instant the call connects is not clipped.
+     * Every frame awaits this same promise, so the frames resume in the order
+     * they arrived.
+     *
+     * It resolves rather than rejects: a failed handshake is reported once, by
+     * the code that opened the socket, not once per waiting frame.
+     */
+    modelReady: Promise<boolean> | null;
+}
+
+/**
+ * Identifies this SDK to OpenAI on every WebSocket connection, per OpenAI's
+ * requested User-Agent pattern: [Company/Library name]/[Language] [Version].
+ *
+ * Deliberately unlike the Twilio-facing User-Agent in `clients/base.ts`, which
+ * follows Twilio's own convention instead.
+ */
+declare const OPENAI_USER_AGENT: string;
+/**
+ * Shared scaffolding for a {@link VoiceProvider} bridging Twilio Media Streams
+ * to an OpenAI real-time voice API.
+ *
+ * Holds only what's identical across every such provider; each subclass still
+ * owns its own `initiateOutboundConversation`, `handleWebSocket`,
+ * `registerCall`, `connectModel`, {@link dispatchModelEvent},
+ * `handleFunctionCall`, and `cleanupCall`.
+ *
+ * Generic over `TCallState` (bound to `MediaStreamsOpenAICallState`) so
+ * {@link calls} keeps each subclass's own call-state shape instead of widening
+ * to the shared base everywhere it's read.
+ */
+declare abstract class MediaStreamsOpenAIProvider<TCallState extends MediaStreamsOpenAICallState> extends VoiceProvider {
+    /**
+     * The owning channel's logger, so this provider logs under the same name the
+     * rest of the voice channel does.
+     */
+    protected readonly logger: Logger;
+    /** Executable tools from the config, looked up by the name the model sends. */
+    protected readonly toolsByName: Map<string, TACTool>;
+    /** Per-call transport state, keyed by conversation id. */
+    protected readonly calls: Map<ConversationId, TCallState>;
+    protected readonly config: MediaStreamsOpenAIProviderConfig;
+    protected readonly tacConfig: TACConfig;
+    protected readonly twimlBuilder: TwiMLBuilderMediaStreams;
+    /**
+     * Session config overrides awaiting the call they belong to.
+     *
+     * Inbound entries are keyed by call SID (known when the TwiML webhook is
+     * answered); a subclass keys its outbound entries by whatever token it round
+     * trips through the stream's custom parameters.
+     */
+    protected readonly pendingSessionConfigs: Map<string, Record<string, unknown>>;
+    /**
+     * Expiry timers for the inbound {@link pendingSessionConfigs} entries, keyed
+     * by the same call SID. Each fires once to purge a stash whose Media Stream
+     * never connected; a normal connect cancels it in the subclass's
+     * `registerCall`. Outbound entries are keyed by token instead and are not
+     * tracked here.
+     */
+    private readonly pendingInboundExpiries;
+    constructor(channel: VoiceChannel, tacConfig: TACConfig, config: MediaStreamsOpenAIProviderConfig);
+    /** The Twilio-facing WebSocket for a conversation, if one is tracked. */
+    getWebSocket(conversationId: ConversationId): WebSocket | null;
+    /**
+     * Open a WebSocket and resolve once it is ready to carry traffic.
+     *
+     * Isolated from each subclass's `connectModel` so tests can substitute a
+     * socket without reaching the network.
+     *
+     * A resolved socket always carries at least one `'error'` listener, whatever
+     * the caller does with it next.
+     *
+     * @internal
+     */
+    openModelSocket(url: string, headers: Record<string, string>): Promise<WebSocket>;
+    /**
+     * The transcript captured so far for an in-progress call.
+     *
+     * It lives on `ConversationSession.metadata.transcript`, so once the call
+     * ends and the session is dropped it is no longer reachable here — read it
+     * from the session an `onConversationEnded` handler receives instead.
+     */
+    getTranscript(conversationId: ConversationId): Record<string, string>[];
+    /**
+     * The session config stashed for `key` — a call SID for inbound calls, a
+     * token for outbound ones.
+     *
+     * @internal
+     */
+    peekPendingSessionConfig(key: string): Record<string, unknown> | undefined;
+    /**
+     * How many session config overrides are waiting for their call.
+     *
+     * @internal
+     */
+    pendingSessionConfigCount(): number;
+    /**
+     * Start the clock on an inbound stash, so a call whose Media Stream never
+     * connects cannot strand its override in {@link pendingSessionConfigs} until
+     * shutdown.
+     *
+     * Unref'd: a two-minute timer must not be what keeps the process alive after
+     * the call it belongs to is long over. Re-arming replaces any prior timer for
+     * the same call SID, so a duplicate inbound webhook can't orphan one.
+     */
+    private armInboundConfigExpiry;
+    /**
+     * Stop the clock on an inbound stash, once the call it belongs to has
+     * connected and is about to consume the entry. A no-op for outbound calls,
+     * which key their stash by token and never arm one — the subclass calls this
+     * with the call SID for every `start`, inbound or not.
+     *
+     * @internal
+     */
+    protected cancelInboundConfigExpiry(callSid: string): void;
+    /**
+     * The executable tool the model would run for `name`, if the config supplied
+     * one.
+     *
+     * @internal
+     */
+    peekTool(name: string): TACTool | undefined;
+    /**
+     * Build the `<Connect><Stream>` TwiML for an inbound call.
+     *
+     * TwiML fields are merged per-field, highest precedence first:
+     *   1. Output of the customizer registered via
+     *      `VoiceChannel.onInboundCallTwiml(...)`, if configured and
+     *      `twimlRequest` is given
+     *   2. `MediaStreamsProviderConfig.defaultTwimlOptions` — channel-wide
+     *      defaults
+     *   3. `options.hostTwimlOptions` — per-call transport facts supplied by the
+     *      host
+     *   4. TAC defaults: the WebSocket URL derived from
+     *      `TACConfig.voicePublicDomain` + `voiceWebsocketPath`
+     *
+     * Also runs `MediaStreamsOpenAIProviderConfig.onInboundCallSessionConfig`, if
+     * set, and stashes its result for the call to pick up once it connects. The
+     * hook runs only after the TwiML builds, so a call that never connects
+     * leaves nothing stashed behind it.
+     *
+     * @param twimlRequest - Parsed Twilio webhook fields for the inbound call.
+     * @param options - Additional per-call inputs.
+     * @param options.hostTwimlOptions - Per-call TwiML supplied by a custom
+     *   in-process host.
+     * @throws {TypeError} if either the host options or the customizer's output
+     *   is not a `VoiceTwiMLOptionsMediaStreams`.
+     * @throws {Error} if no WebSocket URL can be resolved — none of the TwiML
+     *   layers set one and `TACConfig.voicePublicDomain` is unset.
+     */
+    handleIncomingCall(twimlRequest?: TwiMLRequest, options?: {
+        hostTwimlOptions?: VoiceTwiMLOptions;
+    }): Promise<string>;
+    /**
+     * Narrow provider-agnostic {@link VoiceTwiMLOptions} to this provider's
+     * concrete shape. `VoiceProvider.handleIncomingCall` is typed against the
+     * base so every provider can accept its own TwiML options, so the Media
+     * Streams shape has to be established at runtime.
+     *
+     * @param value - Options from a caller or the application customizer.
+     * @param caller - Name of the calling method, for the error message.
+     * @param label - What produced `value`, for the error message.
+     */
+    protected narrowTwimlOptions(value: VoiceTwiMLOptions | undefined, caller: string, label: string): VoiceTwiMLOptionsMediaStreams | undefined;
+    /**
+     * Parse one frame off the model socket and hand it to
+     * {@link dispatchModelEvent}.
+     *
+     * A failure here is logged and skipped rather than ending the call: one
+     * malformed delta must not hang up on the caller.
+     *
+     * @internal
+     */
+    handleModelMessage(conversationId: ConversationId, raw: Buffer | string): Promise<void>;
+    /**
+     * Interpret one event received from the model. Protocol-specific —
+     * implemented by each subclass.
+     */
+    protected abstract dispatchModelEvent(conversationId: ConversationId, session: ConversationSession, event: Record<string, unknown>): Promise<void>;
+    /**
+     * Look up a model-requested tool by name, run it, and return its output.
+     *
+     * Errors are returned as part of the output rather than thrown, so a bad
+     * tool call does not kill the call.
+     *
+     * @internal
+     */
+    runToolCall(conversationId: ConversationId, name: string, argumentsJson: unknown): Promise<unknown>;
+    /** Write one event to this call's model socket, if it still has one. */
+    protected modelSend(conversationId: ConversationId, payload: Record<string, unknown>): void;
+    /** Write one message to this call's Twilio socket, if it still has one. */
+    protected twilioSend(conversationId: ConversationId, payload: Record<string, unknown>): void;
+    /**
+     * Always throws: the model streams its reply as audio straight to Twilio, so
+     * this transport has no text response to send.
+     */
+    sendResponse(_conversationId: ConversationId, _message: string, _metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Drop this provider's Media Streams transport state on channel shutdown.
+     *
+     * Note: WebSocket connections are managed by the server and closed there.
+     * This method only cleans up internal provider state — including session
+     * config overrides stashed for calls that were placed but never connected.
+     */
+    shutdown(): void;
+}
+
+/**
+ * Options accepted by {@link OpenAIRealtimeProviderConfig}.
+ */
+interface OpenAIRealtimeProviderConfigOptions extends MediaStreamsOpenAIProviderConfigOptions {
+    /**
+     * Executable `TACTool` implementations, looked up by name to run mid-call
+     * tool requests. This alone does not tell the model these tools exist — also
+     * add each tool's `toRealtimeFormat()` schema to
+     * {@link OpenAIRealtimeProviderConfigOptions.defaultSessionConfig}'s `tools`
+     * entry.
+     */
+    tools?: TACTool<never, unknown>[];
+    /**
+     * If set, sent verbatim as `response.create`'s `response` payload when the
+     * call connects — e.g. `{ instructions: 'Hi there!' }`. No SDK-added wrapping
+     * text or language assumption.
+     */
+    welcomeGreetingResponse?: Record<string, unknown>;
+    /**
+     * The `session.update` payload's `session` body, sent once the model connects
+     * — used for any call that doesn't supply its own via
+     * {@link OpenAIRealtimeProviderConfigOptions.onInboundCallSessionConfig} or
+     * `InitiateVoiceConversationOptionsOpenAIRealtime`.
+     *
+     * See
+     * https://developers.openai.com/api/reference/resources/realtime/client-events#session.update
+     * for the schema. If using {@link OpenAIRealtimeProviderConfigOptions.tools},
+     * its `tools` entry must separately list each tool's `toRealtimeFormat()`
+     * schema — this config is passed to OpenAI as-is, with no tool schemas merged
+     * in.
+     */
+    defaultSessionConfig?: Record<string, unknown>;
+    /**
+     * Per-inbound-call override for
+     * {@link OpenAIRealtimeProviderConfigOptions.defaultSessionConfig}, called
+     * with the `TwiMLRequest`. Its return value is used verbatim (not merged with
+     * `defaultSessionConfig`); return `null` to fall back to it. Outbound calls
+     * don't use this — see `InitiateVoiceConversationOptionsOpenAIRealtime`.
+     */
+    onInboundCallSessionConfig?: (req: TwiMLRequest) => Promise<Record<string, unknown> | null>;
+}
+/**
+ * Configuration for `OpenAIRealtimeProvider`.
+ */
+declare class OpenAIRealtimeProviderConfig extends MediaStreamsOpenAIProviderConfig {
+    /**
+     * Executable `TACTool` implementations, looked up by name to run mid-call
+     * tool requests. This alone does not tell the model these tools exist — also
+     * add each tool's `toRealtimeFormat()` schema to
+     * {@link OpenAIRealtimeProviderConfig.defaultSessionConfig}'s `tools` entry.
+     */
+    readonly tools: TACTool<never, unknown>[];
+    /**
+     * If set, sent verbatim as `response.create`'s `response` payload when the
+     * call connects — e.g. `{ instructions: 'Hi there!' }`. No SDK-added wrapping
+     * text or language assumption.
+     */
+    readonly welcomeGreetingResponse?: Record<string, unknown>;
+    /**
+     * The `session.update` payload's `session` body, sent once the model connects
+     * — used for any call that doesn't supply its own via
+     * {@link OpenAIRealtimeProviderConfig.onInboundCallSessionConfig} or
+     * `InitiateVoiceConversationOptionsOpenAIRealtime`.
+     *
+     * See
+     * https://developers.openai.com/api/reference/resources/realtime/client-events#session.update
+     * for the schema. If using {@link OpenAIRealtimeProviderConfig.tools}, its
+     * `tools` entry must separately list each tool's `toRealtimeFormat()` schema
+     * — this config is passed to OpenAI as-is, with no tool schemas merged in.
+     */
+    readonly defaultSessionConfig?: Record<string, unknown>;
+    /**
+     * Per-inbound-call override for
+     * {@link OpenAIRealtimeProviderConfig.defaultSessionConfig}, called with the
+     * `TwiMLRequest`. Its return value is used verbatim (not merged with
+     * `defaultSessionConfig`); return `null` to fall back to it. Outbound calls
+     * don't use this — see `InitiateVoiceConversationOptionsOpenAIRealtime`.
+     */
+    readonly onInboundCallSessionConfig?: (req: TwiMLRequest) => Promise<Record<string, unknown> | null>;
+    constructor(options?: OpenAIRealtimeProviderConfigOptions);
+    createProvider(channel: VoiceChannel, tacConfig: TACConfig): VoiceProvider;
+}
+
+/**
+ * Per-call barge-in bookkeeping.
+ *
+ * For every delta that carries an `item_id`, `currentItemAudioMs` is never
+ * more than the duration of audio actually sent to Twilio for
+ * `lastAssistantItem`: it comes from delta byte counts rather than a
+ * wall-clock estimate, floored per delta, so it can understate by up to a
+ * millisecond per delta. `conversation.item.truncate` rejects an `audioEndMs`
+ * beyond the item's real content, so understating is the safe direction.
+ *
+ * `responseActive` tracks whether a response is still being generated (set on
+ * `response.created`, cleared on `response.done` or once barge-in cancels it) —
+ * `response.cancel` with nothing in flight is itself an error event, so this
+ * gates whether to send it.
+ *
+ * `mutedItemId` is the assistant item truncated by the last barge-in —
+ * `response.output_audio.delta` events whose `item_id` matches it are dropped
+ * as stale audio for a reply the caller already talked over. It is never
+ * cleared; the next barge-in overwrites it.
+ *
+ * @internal
+ */
+declare class BargeInState {
+    lastAssistantItem: string | null;
+    currentItemAudioMs: number;
+    mutedItemId: string | null;
+    responseActive: boolean;
+}
+/**
+ * Per-call bookkeeping the OpenAI Realtime provider needs beyond
+ * `ConversationSession` and the sockets its base class holds.
+ *
+ * @internal
+ */
+declare class CallState$1 extends MediaStreamsOpenAICallState {
+    /**
+     * Tail of this call's model-event chain: each incoming OpenAI Realtime event
+     * is appended to it rather than dispatched on arrival.
+     *
+     * The Python SDK reads model events in a sequential loop, so event N is fully
+     * handled before N+1 is even read. `ws` delivers each event on its own
+     * `'message'` emission with nothing serializing them, so without this chain a
+     * `response.output_audio.delta` could advance the barge-in bookkeeping while
+     * dispatch is suspended on the `handleFunctionCall` await, producing a
+     * truncate that overruns the item it names.
+     */
+    modelEvents: Promise<void>;
+    readonly bargeIn: BargeInState;
+}
+
+/**
+ * The audio format both directions of a call must use.
+ *
+ * Twilio Media Streams always sends and expects 8kHz G.711 u-law — see
+ * https://www.twilio.com/docs/voice/media-streams/websocket-messages. Not
+ * configurable. No `rate` key: Realtime's `session.audio.*.format` schema
+ * rejects it as unknown, since g711 is inherently fixed-rate.
+ */
+declare const TWILIO_AUDIO_FORMAT_FOR_REALTIME: {
+    readonly type: "audio/pcmu";
+};
+/**
+ * A {@link VoiceProvider} bridging Twilio Media Streams to OpenAI's Realtime
+ * API.
+ *
+ * Twilio streams call audio to TAC's own WebSocket via `<Connect><Stream>`, and
+ * this provider relays it to and from a second WebSocket it opens to OpenAI's
+ * Realtime API.
+ *
+ * ```ts
+ * const channel = new VoiceChannel(
+ *   tac,
+ *   new OpenAIRealtimeProviderConfig({ defaultSessionConfig: { instructions: '...' } })
+ * );
+ * ```
+ */
+declare class OpenAIRealtimeProvider extends MediaStreamsOpenAIProvider<CallState$1> {
+    /** @internal */
+    get providerId(): string;
+    /**
+     * The Realtime-specific config this provider was built with.
+     *
+     * `declare`: `target: ES2022` implies `useDefineForClassFields`, so a plain
+     * redeclaration would emit a field definition that runs after `super()` and
+     * overwrite the value the base constructor assigned with `undefined`. This
+     * exists only to narrow the base's `MediaStreamsOpenAIProviderConfig` to the
+     * Realtime shape `connectModel` reads `welcomeGreetingResponse` from.
+     *
+     * No `override`: TypeScript rejects it alongside `declare` (TS1243), and
+     * `noImplicitOverride` does not require it for a `declare`d field.
+     */
+    protected readonly config: OpenAIRealtimeProviderConfig;
+    constructor(channel: VoiceChannel, tacConfig: TACConfig, config: OpenAIRealtimeProviderConfig);
+    get channelName(): string;
+    /**
+     * Initiate an outbound voice conversation.
+     *
+     * Places an outbound call with inline TwiML that connects to a Media Stream.
+     * Unlike inbound, there is no local session yet at this point — one is
+     * created when Twilio's WebSocket `start` event arrives.
+     *
+     * TwiML fields are merged per-field — see
+     * {@link TwiMLBuilderMediaStreams.build}. The WebSocket URL is derived from
+     * `TACConfig.voicePublicDomain` + `TACConfig.voiceWebsocketPath` unless
+     * overridden per-call via `options.websocketUrl`.
+     *
+     * Pass `InitiateVoiceConversationOptionsOpenAIRealtime` with `sessionConfig`
+     * set to override `OpenAIRealtimeProviderConfig.defaultSessionConfig` for
+     * this call.
+     *
+     * @param options - Outbound call options, validated in full against
+     *   `InitiateVoiceConversationOptionsOpenAIRealtimeSchema`.
+     * @throws {TypeError} if `options` is not a valid
+     *   `InitiateVoiceConversationOptionsOpenAIRealtime` — including an unknown
+     *   key, a missing `to`, or a `twimlOptions` that is not a
+     *   `VoiceTwiMLOptionsMediaStreams`.
+     * @throws {Error} if no WebSocket URL can be resolved — neither
+     *   `options.websocketUrl` nor any TwiML layer sets one and
+     *   `TACConfig.voicePublicDomain` is unset.
+     */
+    initiateOutboundConversation(options: InitiateVoiceConversationOptions | InitiateVoiceConversationOptionsOpenAIRealtime): Promise<InitiateVoiceConversationResult>;
+    /**
+     * Drive one Twilio Media Stream connection from `start` to disconnect.
+     *
+     * Twilio's `start` event names the call, which opens the matching OpenAI
+     * Realtime socket; from then on caller audio is relayed to the model and the
+     * model's audio back to Twilio, until either side goes away. Whichever leg
+     * closes first takes the other down with it, so a caller is never left
+     * connected to silence.
+     *
+     * Twilio streams audio without waiting for the OpenAI socket to finish
+     * connecting, so audio that arrives during that handshake is held and
+     * forwarded, in order, once the model is ready — a caller who speaks the
+     * instant the call connects is heard in full.
+     *
+     * Called by `VoiceChannel.handleWebSocketConnection`; hosts serve the socket
+     * rather than calling this directly.
+     *
+     * @param ws - The accepted Twilio-facing WebSocket.
+     */
+    handleWebSocket(ws: WebSocket): void;
+    /**
+     * Handle Twilio's `start` event: track the call and open its session.
+     *
+     * @param start - The event's `start` body, parsed against
+     *   `StreamStartMessageSchema`.
+     * @param ws - The Twilio-facing socket this call arrived on.
+     * @returns The conversation id — which is the call SID — and the call's
+     *   freshly tracked transport state.
+     */
+    private registerCall;
+    /**
+     * Open this call's OpenAI Realtime socket and send its session config.
+     *
+     * @internal
+     */
+    connectModel(conversationId: ConversationId): Promise<void>;
+    /**
+     * The validated session config for this call: its own stashed override if it
+     * has one, else the channel-wide default.
+     *
+     * @throws {Error} if neither exists, if it has no `model`, or if either audio
+     *   direction is set to a format Twilio can't carry.
+     */
+    private resolveSessionConfig;
+    /**
+     * Wire up the model socket: dispatch its events, and tear the call down when
+     * it goes away.
+     *
+     * The Python SDK races its two read loops so the Twilio leg dies with the
+     * model leg; `ws` is event-driven, so the same guarantee is a close/error
+     * handler instead. Python's sequential read loop also handles each model
+     * event to completion before reading the next, which `ws` does not — see
+     * {@link CallState.modelEvents} for the chain that restores it.
+     */
+    private attachModelHandlers;
+    /**
+     * Hang up the Twilio leg because the model leg is gone, then clean up. A
+     * no-op once the call has already been cleaned up, so both the model socket's
+     * `close` and its `error` can call it.
+     */
+    private endCallFromModel;
+    /** Apply one parsed OpenAI Realtime event to the call. */
+    protected dispatchModelEvent(conversationId: ConversationId, session: ConversationSession, event: Record<string, unknown>): Promise<void>;
+    /** Record one turn on the session's running transcript. */
+    private appendTranscript;
+    /**
+     * The caller started talking. Cancel any response still generating, truncate
+     * the model's memory of the last reply at the point actually heard, then
+     * clear Twilio's buffered audio so playback stops immediately.
+     *
+     * If no assistant audio has been sent since the last barge-in this is a
+     * no-op: there is nothing queued at Twilio to clear, no item id to name in a
+     * truncate, and any response still generating is left to run.
+     */
+    private handleBargeIn;
+    /**
+     * Run a model-requested tool call and hand the result back.
+     *
+     * Always sends a `function_call_output` once a `call_id` is present — even a
+     * tool that ran successfully can return something `JSON.stringify` throws on
+     * (a circular object, a `BigInt`) or has no JSON form at all, which
+     * `JSON.stringify` reports by returning `undefined` rather than throwing (a
+     * void tool, a bare function, a `Symbol`). Either way the model would
+     * otherwise be left waiting on a `call_id` it never gets a result for.
+     * Without a `call_id` there is nothing to reply to, so the item is dropped
+     * instead.
+     */
+    private handleFunctionCall;
+    /**
+     * Drop this call's transport state, close the model socket, and end the
+     * session.
+     *
+     * Both legs can report the call ending, and the first one to arrive tears
+     * down the other, so this runs at most once per call: a second invocation
+     * finds nothing tracked and returns.
+     */
+    private cleanupCall;
+}
+
+interface GPTLiveProviderConfigOptions extends MediaStreamsOpenAIProviderConfigOptions {
+    /**
+     * If set, sent verbatim as a `session.commentary.append` once `session.started`
+     * arrives. Word it as an instruction, not just a greeting — e.g. "Greet the
+     * caller immediately using: Hi, how can I help you today?". A bare greeting
+     * will not make the model speak first.
+     */
+    welcomeInstruction?: string;
+}
+/**
+ * Configuration for `GPTLiveProvider`.
+ *
+ * Two GPT-Live-specific notes on inherited members:
+ *
+ * - `tools` holds executable implementations looked up by name. It does **not**
+ *   tell the model the tools exist — also add each tool's `toRealtimeFormat()`
+ *   schema to `defaultSessionConfig.delegation.responses.tools`.
+ * - `defaultSessionConfig` is the `session.start` payload's `session` body. It
+ *   must include `model` (e.g. `'gpt-live-1'`), and `audio.format`
+ *   must be `TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE`.
+ */
+declare class GPTLiveProviderConfig extends MediaStreamsOpenAIProviderConfig {
+    readonly welcomeInstruction: string | null;
+    constructor(opts?: GPTLiveProviderConfigOptions);
+    createProvider(channel: VoiceChannel, tacConfig: TACConfig): VoiceProvider;
+}
+
+/**
+ * Per-call bookkeeping `GPTLiveProvider` needs beyond `ConversationSession`.
+ *
+ * @internal
+ */
+declare class CallState extends MediaStreamsOpenAICallState {
+    /**
+     * Settles once `session.closed` arrives, so teardown can wait for graceful
+     * finalization before tearing the socket down.
+     */
+    readonly closed: Promise<void>;
+    private readonly resolveClosed;
+    constructor();
+    markClosed(): void;
+}
+
+/**
+ * The audio format both directions of a call must use.
+ *
+ * Twilio Media Streams always sends and expects 8kHz G.711 u-law — see
+ * https://www.twilio.com/docs/voice/media-streams/websocket-messages. Not
+ * configurable. GPT-Live speaks it natively on both legs, so a single
+ * `session.audio.format` covers input and output and nothing transcodes.
+ *
+ * Spelled with an explicit `rate`, which GPT-Live's schema wants and Realtime's
+ * rejects — that is why this is a separate constant from
+ * `TWILIO_AUDIO_FORMAT_FOR_REALTIME` rather than a shared one.
+ */
+declare const TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE: {
+    readonly type: "audio/pcmu";
+    readonly rate: 8000;
+};
+/**
+ * `ConversationSession.metadata` key holding OpenAI's id for the GPT-Live
+ * session behind this call, set once `session.started` arrives. Quote it to
+ * OpenAI support when reporting a session.
+ *
+ * Opaque: the prefix differs across GPT-Live's alpha (`rtc_`) and GA (`live_`),
+ * so never parse it, validate it, or branch on it.
+ */
+declare const GPT_LIVE_SESSION_ID_METADATA_KEY = "gpt_live_session_id";
+/**
+ * A {@link VoiceProvider} bridging Twilio Media Streams to OpenAI's GPT-Live
+ * API.
+ */
+declare class GPTLiveProvider extends MediaStreamsOpenAIProvider<CallState> {
+    /** @internal */
+    get providerId(): string;
+    /**
+     * No `override`: TypeScript rejects it alongside `declare` (TS1243), and
+     * `declare` is what keeps this a pure type narrowing of the base's field
+     * rather than a second field that shadows it.
+     */
+    protected readonly config: GPTLiveProviderConfig;
+    private readonly pendingTokenExpiries;
+    /** Calls whose teardown has begun but is still awaiting `session.closed`. */
+    private readonly closingCalls;
+    get channelName(): string;
+    /**
+     * Initiate an outbound voice conversation.
+     *
+     * Places an outbound call with inline TwiML that connects to a Media Stream.
+     * Unlike inbound, there is no local session yet at this point — one is
+     * created when Twilio's WebSocket `start` event arrives.
+     *
+     * TwiML fields are merged per-field — see
+     * {@link TwiMLBuilderMediaStreams.build}. The WebSocket URL is derived from
+     * `TACConfig.voicePublicDomain` + `TACConfig.voiceWebsocketPath` unless
+     * overridden per-call via `options.websocketUrl`.
+     *
+     * Pass `InitiateVoiceConversationOptionsGPTLive` with `sessionConfig` set to
+     * override `GPTLiveProviderConfig.defaultSessionConfig` for this call.
+     *
+     * @param options - Outbound call options.
+     * @throws {TypeError} if `options` does not satisfy
+     *   `InitiateVoiceConversationOptionsGPTLiveSchema`.
+     * @throws {Error} if no WebSocket URL can be resolved — neither
+     *   `options.websocketUrl` nor any TwiML layer sets one and
+     *   `TACConfig.voicePublicDomain` is unset.
+     */
+    initiateOutboundConversation(options: InitiateVoiceConversationOptions | InitiateVoiceConversationOptionsGPTLive): Promise<InitiateVoiceConversationResult>;
+    /**
+     * Start the clock on a stashed token, so a call that never connects cannot
+     * strand its override in {@link pendingSessionConfigs} forever.
+     *
+     * Unref'd: a two-minute timer must not be what keeps the process alive after
+     * the call it belongs to is long over.
+     */
+    private armTokenExpiry;
+    /**
+     * Stop the clock on a token, once the call it belongs to has claimed it.
+     *
+     * Without this a two-minute timer outlives every call that connected
+     * normally, waiting to purge an entry that is already gone.
+     */
+    private cancelTokenExpiry;
+    /**
+     * Drive one Twilio Media Stream connection from `start` to disconnect.
+     *
+     * Twilio's `start` event names the call, which opens the matching GPT-Live
+     * socket; from then on caller audio is relayed to the model and the model's
+     * audio back to Twilio, until either side goes away. Whichever leg closes
+     * first takes the other down with it, so a caller is never left connected to
+     * silence.
+     *
+     * Twilio streams audio without waiting for the GPT-Live socket to finish
+     * connecting, so audio that arrives during that handshake is held and
+     * forwarded, in order, once the model is ready — a caller who speaks the
+     * instant the call connects is heard in full.
+     *
+     * Called by `VoiceChannel.handleWebSocketConnection`; hosts serve the socket
+     * rather than calling this directly.
+     *
+     * @param ws - The accepted Twilio-facing WebSocket.
+     */
+    handleWebSocket(ws: WebSocket): void;
+    /**
+     * Handle Twilio's `start` event: track the call and open its session.
+     *
+     * @param start - The event's `start` body, parsed against
+     *   `StreamStartMessageSchema`.
+     * @param ws - The Twilio-facing socket this call arrived on.
+     * @returns The conversation id — which is the call SID — and the call's
+     *   freshly tracked transport state.
+     */
+    private registerCall;
+    /**
+     * Open this call's GPT-Live socket and send its session config.
+     *
+     * @internal
+     */
+    connectModel(conversationId: ConversationId): Promise<void>;
+    /**
+     * The validated session config for this call: its own stashed override if it
+     * has one, else the channel-wide default.
+     *
+     * @throws {Error} if neither exists, if the audio format is one Twilio can't
+     *   carry, or if it names no model.
+     */
+    private resolveSessionConfig;
+    /**
+     * Wire up the model socket: dispatch its events, and tear the call down when
+     * it goes away.
      *
-     * @param conversationId - The conversation ID
-     * @returns true if an active task exists
+     * The Python SDK races its Twilio read against its model-event reader so the
+     * Twilio leg dies with the model leg; `ws` is event-driven, so the same
+     * guarantee is a close/error handler instead.
      */
-    hasActiveStreamTask(conversationId: ConversationId): boolean;
+    private attachModelHandlers;
     /**
-     * Field names on {@link TwiMLOptions} that map directly to `<ConversationRelay>`
-     * attributes (camelCase, emitted as-is). Excludes the fields handled specially
-     * by {@link generateTwiml}: websocketUrl (resolved through the layered merge and
-     * emitted as the `url` attribute), actionUrl, languages, customParameters, extra.
+     * Hang up the Twilio leg because the model leg is gone, then clean up. A
+     * no-op once the call has already been cleaned up, so both the model socket's
+     * `close` and its `error` can call it.
      */
-    private static readonly RELAY_ATTR_FIELDS;
+    private endCallFromModel;
     /**
-     * Generate TwiML XML for ConversationRelay from a merged {@link TwiMLOptions}.
+     * Close this call's GPT-Live session gracefully, drop its transport state,
+     * and end the session.
      *
-     * This is the low-level emitter used by `handleIncomingCall` and
-     * `initiateOutboundConversation` after layering. It mirrors the Python SDK's
-     * `generate_twiml`. The WebSocket URL may be passed as `websocketUrl` or via
-     * `options.websocketUrl` (the explicit argument wins when both are given), so a
-     * channel-less caller can pass everything in one object.
+     * `session.close` asks the server to finalize the session, and teardown waits
+     * up to {@link CLOSE_TIMEOUT_MS} for the `session.closed` answering it before
+     * the socket goes away — otherwise the socket would be gone before the server
+     * could finish.
      *
-     * @param websocketUrl - Public WebSocket URL (e.g. 'wss://example.ngrok.app/ws').
-     *   Optional if `options.websocketUrl` is set.
-     * @param options - Merged TwiMLOptions to emit.
-     * @returns TwiML XML string ready to return to Twilio.
-     * @throws {Error} if no WebSocket URL is provided via either source.
+     * Both legs can report the call ending, and the first one to arrive tears
+     * down the other, so this runs at most once per call: a second invocation
+     * finds the call either untracked or already closing, and returns.
      */
-    private generateTwiml;
+    private cleanupCall;
     /**
-     * Generate TwiML to connect a call to ConversationRelay.
-     * Validates configuration with Zod before generating TwiML.
+     * Drop this provider's transport state on channel shutdown, including the
+     * bookkeeping it keeps beyond the base class's.
      *
-     * @param config - ConversationRelay configuration (url, transcription, TTS, etc.)
-     * @param options - Optional settings for parameters and the Connect verb
-     * @returns TwiML XML string
-     * @throws {Error} if config validation fails
+     * The token expiry timers are unref'd and delete themselves, so nothing hangs
+     * without this — but a shut-down provider must not still be holding entries
+     * for calls that can no longer arrive.
      */
-    connectConversationRelay(config: ConversationRelayConfig, options?: {
-        parameters?: CustomParameters;
-        actionUrl?: string;
-    }): string;
+    shutdown(): void;
+    /** Apply one parsed GPT-Live event to the call. */
+    protected dispatchModelEvent(conversationId: ConversationId, session: ConversationSession, event: Record<string, unknown>): Promise<void>;
     /**
-     * Filter out undefined values from configuration object.
-     * Keeps null, false, 0, and empty strings as they are valid values.
+     * Run a Responses-delegated tool call and hand the result back.
+     *
+     * Always sends a `function_call_output` once a `call_id` is present — even a
+     * tool that ran successfully can return something `JSON.stringify` throws on
+     * (a circular object, a `BigInt`) or has no JSON form at all, which
+     * `JSON.stringify` reports by returning `undefined` rather than throwing (a
+     * void tool, a bare function, a `Symbol`). Either way the model would
+     * otherwise be left waiting on a `call_id` it never gets a result for.
+     * Without a `call_id` there is nothing to reply to, so the item is dropped
+     * instead.
      */
-    private filterUnsetValues;
+    private handleFunctionCall;
     /**
-     * Cleanup channel state on shutdown
+     * Surface the GPT-Live session id from a session-snapshot event.
      *
-     * Note: WebSocket connections are managed by the server and closed there.
-     * This method only cleans up internal channel state.
+     * OpenAI support asks for this id when investigating a session, so it goes
+     * where a caller can reach it — `session.metadata`, which outlives the call
+     * into `onConversationEnded` — and is logged once per call.
      */
-    shutdown(): void;
+    private recordGptLiveSessionId;
+    /** Accumulate one transcript delta into the in-progress turn. */
+    private static appendTranscriptDelta;
 }
 
 declare function scrubPii(value: string): string;
@@ -4292,243 +6263,6 @@ declare class MemoryPromptBuilder {
     private static assemblePrompt;
 }
 
-/**
- * TAC Tool class with helper methods for LLM integration
- *
- * Matches Python's TACTool dataclass with conversion methods.
- */
-declare class TACTool<TParams = unknown, TResult = unknown> {
-    readonly name: string;
-    readonly description: string;
-    readonly parameters: JSONSchema;
-    readonly implementation: ToolFunction<TParams, TResult>;
-    constructor(name: string, description: string, parameters: JSONSchema, implementation: ToolFunction<TParams, TResult>);
-    /**
-     * Convert to OpenAI function calling format
-     */
-    toOpenAIFormat(): OpenAITool;
-    /**
-     * Convert to Anthropic tool calling format
-     */
-    toAnthropicFormat(): AnthropicTool;
-    /**
-     * Convert to JSON string (OpenAI format by default)
-     */
-    toJSON(): string;
-    /**
-     * Convert this tool to an OpenAI Agents SDK `FunctionTool` instance.
-     *
-     * Unlike `toOpenAIFormat` and `toAnthropicFormat` (which return plain
-     * objects consumed by HTTP APIs), the OpenAI Agents SDK dispatches on tool
-     * *type*, so this returns a live `tool(...)` object with an invoke callback
-     * that calls this tool and JSON-encodes the result.
-     *
-     * Requires the `@openai/agents` package:
-     *
-     *     npm install @openai/agents
-     *
-     * @returns A FunctionTool ready to pass to `new Agent({ tools: [...] })`.
-     */
-    toOpenAIAgentsSDKTool(): Promise<any>;
-}
-/**
- * Create a tool directly with all parameters
- *
- * Simplified approach matching Python's create_tool function.
- * No builder pattern - just a simple function call.
- */
-declare function defineTool<TParams = unknown, TResult = unknown>(name: string, description: string, parameters: JSONSchema, implementation: ToolFunction<TParams, TResult>): TACTool<TParams, TResult>;
-
-/**
- * Parameters for memory retrieval tool
- */
-interface MemoryRetrievalParams {
-    query?: string;
-    beginDate?: string;
-    endDate?: string;
-    observationsLimit?: number;
-    summariesLimit?: number;
-    communicationsLimit?: number;
-    relevanceThreshold?: number;
-}
-/**
- * Create memory retrieval tool.
- *
- * @param memoryClient - Memory client instance (must be initialized with storeId)
- * @param profileId - Optional profile ID for memory retrieval
- * @param conversationId - Optional conversation ID for memory retrieval
- * @param options - Optional overrides for tool metadata.
- * @param options.name - Tool name exposed to the LLM. Defaults to `retrieve_profile_memory`.
- * @param options.description - Tool description exposed to the LLM. Defaults to a
- *   generic "retrieve memories" prompt.
- */
-declare function createMemoryRetrievalTool(memoryClient: MemoryClient, profileId?: string, conversationId?: string, options?: {
-    name?: string;
-    description?: string;
-}): TACTool<MemoryRetrievalParams, MemoryRetrievalResponse>;
-/**
- * Create factory function for memory tools
- *
- * @param memoryClient - Memory client instance (must be initialized with storeId)
- */
-declare function createMemoryTools(memoryClient: MemoryClient): {
-    forProfile: (profileId: string, conversationId?: string) => TACTool<MemoryRetrievalParams, MemoryRetrievalResponse>;
-    forSession: (profileId?: string, conversationId?: string) => TACTool<MemoryRetrievalParams, MemoryRetrievalResponse>;
-};
-
-/**
- * Parameters for send message tool
- */
-interface SendMessageParams {
-    message: string;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Result from send message tool
- */
-interface SendMessageResult {
-    success: boolean;
-    message_id?: string;
-    error?: string;
-}
-/**
- * Create send message tool
- */
-declare function createSendMessageTool(channel: BaseChannel, conversationId: ConversationId): TACTool<SendMessageParams, SendMessageResult>;
-/**
- * Create factory function for messaging tools
- */
-declare function createMessagingTools(): {
-    forConversation: (channel: BaseChannel, conversationId: ConversationId) => TACTool<SendMessageParams, SendMessageResult>;
-};
-
-/**
- * Handoff tool for the Twilio Agent Connect.
- *
- * Generic Studio-backed handoff that routes a conversation to a human agent.
- * Produces a structured HandoffPayload and delivers it as a Twilio Studio
- * Execution (voice via `<Connect action>`, digital channels via direct POST).
- */
-
-/**
- * Build a HandoffPayload from session context and attributes.
- *
- * Useful for custom handoff tools that want TAC's payload shape without
- * the Studio-specific delivery in `postStudioHandoff`.
- */
-declare function buildHandoffPayload(session: ConversationSession, memoryStoreId: string, attributes: Record<string, unknown>): HandoffPayload;
-/**
- * POST a handoff payload to a Twilio Studio Flow Executions endpoint.
- *
- * Emits the Twilio Studio Executions API wire format: form-encoded
- * `To` / `From` / `Parameters` fields with HTTP Basic auth.
- * `Parameters` is a JSON string keyed under `HandoffData` so Studio
- * can reference it via `{{flow.data.HandoffData.*}}`.
- */
-declare function postStudioHandoff(payload: HandoffPayload, session: ConversationSession, options: {
-    handoffUrl: string;
-    fromAddress: string;
-    apiKey: string;
-    apiSecret: string;
-}): Promise<void>;
-/**
- * Result returned by the handoff tool.
- */
-interface HandoffResult {
-    status: 'handoff_initiated' | 'handoff_failed';
-    channel: string;
-    error?: string;
-}
-interface HandoffParams {
-    reason: string;
-}
-/**
- * Create a handoff tool that delivers in the Twilio Studio Executions API shape.
- *
- * The returned tool exposes only `handoff({ reason })` to the LLM. All other
- * dependencies (TAC instance, session, static attributes) are captured in the
- * closure.
- *
- * On digital channels, the tool POSTs to the Studio Flow Executions endpoint
- * derived from `tac.getConfig().studioHandoffFlowSid`. For voice channels,
- * the payload is stored on the session and the voice channel automatically
- * sends the WS `end` message with `handoffData` after the LLM's final
- * response is delivered.
- *
- * The tool also sets the conversation to INACTIVE and clears status callbacks
- * to prevent further webhook events from being routed to TAC.
- *
- * **Not available in voice-only mode.** This tool requires Conversation
- * Orchestrator for conversation state management and Conversation Memory for
- * the handoff payload. In voice-only mode, implement your own handoff by
- * setting `session.pendingHandoffData` directly — the voice channel will
- * send the WS `end` message with your payload, and your `<Connect action>`
- * URL handler can route the call accordingly.
- *
- * @throws Error if `tac.getConfig().studioHandoffFlowSid` is unset, if
- *   Conversation Orchestrator is not configured (voice-only mode), or if
- *   the memory store ID was not resolved at startup.
- */
-declare function createStudioHandoffTool(tac: TAC, session: ConversationSession, options?: {
-    attributes?: Record<string, unknown>;
-    name?: string;
-    description?: string;
-}): TACTool<HandoffParams, HandoffResult>;
-
-/**
- * Parameters for knowledge search tool (visible to LLM)
- */
-interface KnowledgeSearchParams {
-    query: string;
-}
-/**
- * Configuration for knowledge search tool
- */
-interface KnowledgeToolConfig {
-    name?: string;
-    description?: string;
-    topK?: number;
-}
-/**
- * Create knowledge search tool with explicit name and description
- *
- * @param knowledgeClient - The Knowledge client instance
- * @param knowledgeBaseId - The knowledge base ID to search
- * @param config - Configuration with required name and description
- * @returns TACTool configured for knowledge search
- */
-declare function createKnowledgeSearchTool(knowledgeClient: KnowledgeClient, knowledgeBaseId: string, config: {
-    name: string;
-    description: string;
-    topK?: number;
-}): TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>;
-/**
- * Create knowledge search tool with auto-fetched metadata from knowledge base
- *
- * This async version fetches the knowledge base metadata to auto-generate
- * the tool name and description if not provided.
- *
- * @param knowledgeClient - The Knowledge client instance
- * @param knowledgeBaseId - The knowledge base ID to search
- * @param config - Optional configuration (name/description auto-generated if not provided)
- * @returns Promise containing TACTool configured for knowledge search
- */
-declare function createKnowledgeSearchToolAsync(knowledgeClient: KnowledgeClient, knowledgeBaseId: string, config?: KnowledgeToolConfig): Promise<TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>>;
-/**
- * Create factory for knowledge tools
- *
- * @param knowledgeClient - The Knowledge client instance
- * @returns Factory object with methods to create knowledge tools
- */
-declare function createKnowledgeTools(knowledgeClient: KnowledgeClient): {
-    forKnowledgeBase: (knowledgeBaseId: string, config: {
-        name: string;
-        description: string;
-        topK?: number;
-    }) => TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>;
-    forKnowledgeBaseAsync: (knowledgeBaseId: string, config?: KnowledgeToolConfig) => Promise<TACTool<KnowledgeSearchParams, KnowledgeChunkResult[]>>;
-};
-
 /**
  * Server configuration options
  */
@@ -4650,4 +6384,4 @@ declare class TACServer {
     stop(): Promise<void>;
 }
 
-export { type ActionChannelSettings, ActionChannelSettingsSchema, type ActionParticipantRef, ActionParticipantRefSchema, type ActionResponse, ActionResponseSchema, type ActionTextContent, ActionTextContentSchema, type AdapterOptions, type AmdEvent, AmdEventSchema, type AmdHandler, type AnthropicTool, AnthropicToolSchema, type AuthorInfo, AuthorInfoSchema, BaseChannel, type BaseChannelEvents, type BaseChannelOptions, BaseClient, type BuiltInToolName, BuiltInTools, CALL_EVENT_KINDS, type CallEventKind, CallEventKindSchema, type CallOptions, CallOptionsSchema, type CallStatusEvent, CallStatusEventSchema, type CallStatusHandler, type CaptureRule, CaptureRuleSchema, type ChannelSettings, ChannelSettingsSchema, type ChannelType, ChannelTypeSchema, ChatChannel, type ChatChannelConfig, type CintelParticipant, CintelParticipantSchema, type Communication, type CommunicationContent, CommunicationContentSchema, type CommunicationParticipant, CommunicationParticipantSchema, CommunicationSchema, type ConversationAddress, ConversationAddressSchema, ConversationClient, type ConversationConfiguration, ConversationConfigurationSchema, type ConversationEndedCallback, type ConversationGroupingType, ConversationGroupingTypeSchema, type ConversationId, type ConversationIntelligenceConfig, ConversationIntelligenceConfigSchema, type ConversationParticipant, ConversationParticipantSchema, type ConversationRelayAttributes, ConversationRelayAttributesSchema, type ConversationRelayCallbackPayload, ConversationRelayCallbackPayloadSchema, type ConversationRelayConfig, ConversationRelayConfigSchema, type ConversationResponse, ConversationResponseSchema, type ConversationSession, ConversationSessionSchema, type ConversationSummaryItem, ConversationSummaryItemSchema, type ConversationWebhookPayload, type CreateConversationSummariesResponse, CreateConversationSummariesResponseSchema, type CreateObservationResponse, CreateObservationResponseSchema, type CreateObservationsRequest, CreateObservationsRequestSchema, type CustomParameters, CustomParametersSchema, EMPTY_MEMORY_RESPONSE, EnvironmentVariables, type ExecutionDetails, ExecutionDetailsSchema, type HandoffPayload, HandoffPayloadSchema, type HandoffResult, type InboundCallTwimlHandler, type InitiateChatConversationOptions, type InitiateConversationResult, type InitiateMessagingConversationOptions, InitiateMessagingConversationOptionsSchema, type InitiateVoiceConversationOptions, InitiateVoiceConversationOptionsSchema, type InitiateVoiceConversationResult, type IntelligenceConfiguration, IntelligenceConfigurationSchema, type InterruptCallback, type InterruptMessage, InterruptMessageSchema, type InterruptMode, InterruptModeSchema, type JSONSchema, JSONSchemaSchema, type KnowledgeBase, KnowledgeBaseSchema, type KnowledgeBaseStatus, KnowledgeBaseStatusSchema, type KnowledgeChunkResult, KnowledgeChunkResultSchema, KnowledgeClient, type KnowledgeSearchResponse, KnowledgeSearchResponseSchema, type LanguageAttributes, LanguageAttributesSchema, type LanguageConfig, LanguageConfigSchema, type ListCommunicationsResponse, ListCommunicationsResponseSchema, type ListConversationsResponse, ListConversationsResponseSchema, type ListParticipantsResponse, ListParticipantsResponseSchema, type Logger, type MemoryChannelType, MemoryChannelTypeSchema, MemoryClient, type MemoryCommunication, type MemoryCommunicationContent, MemoryCommunicationContentSchema, MemoryCommunicationSchema, type MemoryDeliveryStatus, MemoryDeliveryStatusSchema, type MemoryMode, MemoryModeSchema, type MemoryParticipant, MemoryParticipantSchema, type MemoryParticipantType, MemoryParticipantTypeSchema, MemoryPromptBuilder, type MemoryRetrievalRequest, MemoryRetrievalRequestSchema, type MemoryRetrievalResponse, MemoryRetrievalResponseSchema, type MessageDirection, MessageDirectionSchema, type MessageReadyCallback, MessagingChannel, type MessagingChannelConfig, type MessagingChannelEvents, type ObservationCreateRequest, ObservationCreateRequestSchema, type ObservationInfo, ObservationInfoSchema, type OpenAITool, OpenAIToolSchema, type Operator, type OperatorProcessingResult, OperatorProcessingResultSchema, type OperatorResult, type OperatorResultEvent, OperatorResultEventSchema, OperatorResultProcessor, OperatorResultSchema, OperatorSchema, type ParticipantAddress, ParticipantAddressSchema, type ParticipantAddressType, ParticipantAddressTypeSchema, type ParticipantId, type PendingHandoffData, PendingHandoffDataSchema, type Profile, type ProfileId, type ProfileLookupResponse, ProfileLookupResponseSchema, type ProfileResponse, ProfileResponseSchema, type PromptMessage, PromptMessageSchema, RCSChannel, type RecordingEvent, RecordingEventSchema, type RecordingHandler, SMSChannel, type SendMessageActionPayload, SendMessageActionPayloadSchema, type SendMessageActionRequest, SendMessageActionRequestSchema, type SessionInfo, SessionInfoSchema, type SessionMessage, SessionMessageSchema, type SetupMessage, SetupMessageSchema, type StatusCallback, StatusCallbackSchema, type StatusTimeouts, StatusTimeoutsSchema, type StreamTask, type SummaryInfo, SummaryInfoSchema, TAC, type TACChannelType, TACChannelTypeSchema, type TACCommunication, type TACCommunicationAuthor, TACCommunicationAuthorSchema, type TACCommunicationContent, TACCommunicationContentSchema, TACCommunicationSchema, TACConfig, type TACConfigData, TACConfigSchema, type TACDeliveryStatus, TACDeliveryStatusSchema, TACMemoryResponse, type TACOptions, type TACParticipantType, TACParticipantTypeSchema, TACServer, type TACServerConfig, TACTool, type TextTokenMessage, TextTokenMessageSchema, type ToolContext, type ToolExecutionResult, ToolExecutionResultSchema, type ToolFunction, type Transcription, TranscriptionSchema, type TranscriptionWord, TranscriptionWordSchema, type TwiMLOptions, TwiMLOptionsSchema, type TwiMLRequest, TwiMLRequestSchema, type TwilioMemoryConfig, TwilioMemoryConfigSchema, type TypedCallOptions, VoiceChannel, type VoiceChannelConfig, type VoiceChannelEvents, type WebSocketMessage, WebSocketMessageSchema, WhatsAppChannel, type _CallsCreateDriftGuards, type _SDKDriftGuards, amdEventFromForm, buildHandoffPayload, callOptionsToCreateParams, callStatusEventFromForm, createKnowledgeSearchTool, createKnowledgeSearchToolAsync, createKnowledgeTools, createLogger, createMemoryRetrievalTool, createMemoryTools, createMessagingTools, createSendMessageTool, createStudioHandoffTool, defineTool, isConversationId, isParticipantId, isProfileId, maskAddress, maskEmail, maskPhone, postStudioHandoff, recordingEventFromForm, redactTwimlParameters, scrubObject, scrubPii, studioExecutionsUrl, studioVoiceHandoffUrl, twiMLRequestFromForm };
+export { type ActionChannelSettings, ActionChannelSettingsSchema, type ActionParticipantRef, ActionParticipantRefSchema, type ActionResponse, ActionResponseSchema, type ActionTextContent, ActionTextContentSchema, type AdapterOptions, type AmdEvent, AmdEventSchema, type AmdHandler, type AnthropicTool, AnthropicToolSchema, type AuthorInfo, AuthorInfoSchema, BaseChannel, type BaseChannelEvents, type BaseChannelOptions, BaseClient, type BuildStreamTwiMLInputs, type BuiltInToolName, BuiltInTools, CALL_EVENT_KINDS, type CallEventKind, CallEventKindSchema, type CallOptions, CallOptionsSchema, type CallStatusEvent, CallStatusEventSchema, type CallStatusHandler, type CaptureRule, CaptureRuleSchema, type ChannelSettings, ChannelSettingsSchema, type ChannelType, ChannelTypeSchema, ChatChannel, type ChatChannelConfig, type CintelParticipant, CintelParticipantSchema, type Communication, type CommunicationContent, CommunicationContentSchema, type CommunicationParticipant, CommunicationParticipantSchema, CommunicationSchema, type ConversationAddress, ConversationAddressSchema, ConversationClient, type ConversationConfiguration, ConversationConfigurationSchema, type ConversationEndedCallback, type ConversationGroupingType, ConversationGroupingTypeSchema, type ConversationId, type ConversationIntelligenceConfig, ConversationIntelligenceConfigSchema, type ConversationParticipant, ConversationParticipantSchema, type ConversationRelayAttributes, ConversationRelayAttributesSchema, type ConversationRelayCallbackPayload, ConversationRelayCallbackPayloadSchema, type ConversationRelayConfig, ConversationRelayConfigSchema, ConversationRelayProvider, ConversationRelayProviderConfig, type ConversationRelayProviderConfigOptions, type ConversationResponse, ConversationResponseSchema, type ConversationSession, ConversationSessionSchema, type ConversationSummaryItem, ConversationSummaryItemSchema, type ConversationWebhookPayload, type CreateConversationSummariesResponse, CreateConversationSummariesResponseSchema, type CreateObservationResponse, CreateObservationResponseSchema, type CreateObservationsRequest, CreateObservationsRequestSchema, type CustomParameters, CustomParametersSchema, type DtmfEvent, type DtmfHandler, type DtmfMessage, DtmfMessageSchema, EMPTY_MEMORY_RESPONSE, EnvironmentVariables, type ExecutionDetails, ExecutionDetailsSchema, GPTLiveProvider, GPTLiveProviderConfig, type GPTLiveProviderConfigOptions, GPT_LIVE_SESSION_ID_METADATA_KEY, type HandoffPayload, HandoffPayloadSchema, type HandoffResult, type InboundCallTwimlHandler, type InitiateChatConversationOptions, type InitiateConversationResult, type InitiateMessagingConversationOptions, InitiateMessagingConversationOptionsSchema, type InitiateVoiceConversationOptions, type InitiateVoiceConversationOptionsGPTLive, InitiateVoiceConversationOptionsGPTLiveSchema, type InitiateVoiceConversationOptionsOpenAIRealtime, InitiateVoiceConversationOptionsOpenAIRealtimeSchema, InitiateVoiceConversationOptionsSchema, type InitiateVoiceConversationResult, type IntelligenceConfiguration, IntelligenceConfigurationSchema, type InterruptCallback, type InterruptMessage, InterruptMessageSchema, type InterruptMode, InterruptModeSchema, type JSONSchema, JSONSchemaSchema, type KnowledgeBase, KnowledgeBaseSchema, type KnowledgeBaseStatus, KnowledgeBaseStatusSchema, type KnowledgeChunkResult, KnowledgeChunkResultSchema, KnowledgeClient, type KnowledgeSearchResponse, KnowledgeSearchResponseSchema, type LanguageAttributes, LanguageAttributesSchema, type LanguageConfig, LanguageConfigSchema, type ListCommunicationsResponse, ListCommunicationsResponseSchema, type ListConversationsResponse, ListConversationsResponseSchema, type ListParticipantsResponse, ListParticipantsResponseSchema, type Logger, MediaStreamsOpenAICallState, MediaStreamsOpenAIProvider, MediaStreamsOpenAIProviderConfig, type MediaStreamsOpenAIProviderConfigOptions, MediaStreamsProviderConfig, type MediaStreamsProviderConfigOptions, type MediaStreamsTwiMLBuilderConfig, type MemoryChannelType, MemoryChannelTypeSchema, MemoryClient, type MemoryCommunication, type MemoryCommunicationContent, MemoryCommunicationContentSchema, MemoryCommunicationSchema, type MemoryDeliveryStatus, MemoryDeliveryStatusSchema, type MemoryMode, MemoryModeSchema, type MemoryParticipant, MemoryParticipantSchema, type MemoryParticipantType, MemoryParticipantTypeSchema, MemoryPromptBuilder, type MemoryRetrievalRequest, MemoryRetrievalRequestSchema, type MemoryRetrievalResponse, MemoryRetrievalResponseSchema, type MessageDirection, MessageDirectionSchema, type MessageReadyCallback, MessagingChannel, type MessagingChannelConfig, type MessagingChannelEvents, OPENAI_USER_AGENT, type ObservationCreateRequest, ObservationCreateRequestSchema, type ObservationInfo, ObservationInfoSchema, OpenAIRealtimeProvider, OpenAIRealtimeProviderConfig, type OpenAIRealtimeProviderConfigOptions, type OpenAIRealtimeTool, OpenAIRealtimeToolSchema, type OpenAITool, OpenAIToolSchema, type Operator, type OperatorProcessingResult, OperatorProcessingResultSchema, type OperatorResult, type OperatorResultEvent, OperatorResultEventSchema, OperatorResultProcessor, OperatorResultSchema, OperatorSchema, type ParticipantAddress, ParticipantAddressSchema, type ParticipantAddressType, ParticipantAddressTypeSchema, type ParticipantId, type PendingHandoffData, PendingHandoffDataSchema, type Profile, type ProfileId, type ProfileLookupResponse, ProfileLookupResponseSchema, type ProfileResponse, ProfileResponseSchema, type PromptMessage, PromptMessageSchema, RCSChannel, type RecordingEvent, RecordingEventSchema, type RecordingHandler, SMSChannel, type SendMessageActionPayload, SendMessageActionPayloadSchema, type SendMessageActionRequest, SendMessageActionRequestSchema, type SessionInfo, SessionInfoSchema, type SessionMessage, SessionMessageSchema, type SetupMessage, SetupMessageSchema, type StatusCallback, StatusCallbackSchema, type StatusTimeouts, StatusTimeoutsSchema, type StreamStartMessage, StreamStartMessageSchema, type StreamTask, type SummaryInfo, SummaryInfoSchema, TAC, type TACChannelType, TACChannelTypeSchema, type TACCommunication, type TACCommunicationAuthor, TACCommunicationAuthorSchema, type TACCommunicationContent, TACCommunicationContentSchema, TACCommunicationSchema, TACConfig, type TACConfigData, TACConfigSchema, type TACDeliveryStatus, TACDeliveryStatusSchema, TACMemoryResponse, type TACOptions, type TACParticipantType, TACParticipantTypeSchema, TACServer, type TACServerConfig, TACTool, TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE, TWILIO_AUDIO_FORMAT_FOR_REALTIME, type TextTokenMessage, TextTokenMessageSchema, type ToolContext, type ToolExecutionResult, ToolExecutionResultSchema, type ToolFunction, type Transcription, TranscriptionSchema, type TranscriptionWord, TranscriptionWordSchema, TwiMLBuilderMediaStreams, type TwiMLOptions, TwiMLOptionsSchema, type TwiMLRequest, TwiMLRequestSchema, type TwilioMemoryConfig, TwilioMemoryConfigSchema, type TwilioProviderCallbackResponse, type TypedCallOptions, VoiceChannel, type VoiceChannelConfig, type VoiceChannelEvents, VoiceProvider, VoiceProviderConfig, type VoiceTwiMLOptions, type VoiceTwiMLOptionsConversationRelay, VoiceTwiMLOptionsConversationRelaySchema, type VoiceTwiMLOptionsMediaStreams, VoiceTwiMLOptionsMediaStreamsSchema, VoiceTwiMLOptionsSchema, type WebSocketMessage, WebSocketMessageSchema, WhatsAppChannel, type _CallsCreateDriftGuards, type _SDKDriftGuards, amdEventFromForm, buildHandoffPayload, callOptionsToCreateParams, callStatusEventFromForm, createKnowledgeSearchTool, createKnowledgeSearchToolAsync, createKnowledgeTools, createLogger, createMemoryRetrievalTool, createMemoryTools, createMessagingTools, createSendMessageTool, createStudioHandoffTool, defineTool, generateStreamTwiml, isConversationId, isParticipantId, isProfileId, maskAddress, maskEmail, maskPhone, postStudioHandoff, recordingEventFromForm, redactTwimlParameters, scrubObject, scrubPii, shutdownAnalytics, studioExecutionsUrl, studioVoiceHandoffUrl, trackEvent, twiMLRequestFromForm };