twilio-agent-connect 2.2.0 → 2.4.0

package/dist/index.js

@@ -3,9 +3,10 @@ export { z } from 'zod';
 import pino from 'pino';
 import axios, { AxiosError } from 'axios';
 import axiosRetry from 'axios-retry';
+import { Analytics } from '@segment/analytics-node';
+import twilio from 'twilio';
 import { WebSocket } from 'ws';
 import VoiceResponse from 'twilio/lib/twiml/VoiceResponse.js';
-import twilio from 'twilio';
 import Fastify from 'fastify';
 import formbody from '@fastify/formbody';
 import websocket from '@fastify/websocket';
@@ -769,10 +770,16 @@ var InterruptMessageSchema = z.object({
   utteranceUntilInterrupt: z.string().optional(),
   durationUntilInterruptMs: z.number().int().nonnegative().optional()
 });
+var DtmfMessageSchema = z.object({
+  type: z.literal("dtmf"),
+  /** The key pressed: `0`-`9`, `*`, `#`, or `A`-`D`. */
+  digit: z.string()
+});
 var WebSocketMessageSchema = z.union([
   SetupMessageSchema,
   PromptMessageSchema,
-  InterruptMessageSchema
+  InterruptMessageSchema,
+  DtmfMessageSchema
 ]);
 var TextTokenMessageSchema = z.object({
   type: z.literal("text"),
@@ -799,37 +806,43 @@ var LanguageConfigSchema = z.object({
   /** Speech model for STT. Choices vary by transcriptionProvider. */
   speechModel: z.string().optional()
 });
-var TwiMLOptionsSchema = z.object({
-  /** Custom parameters to pass to ConversationRelay as `<Parameter>` children */
-  customParameters: CustomParametersSchema.optional(),
-  /** Initial greeting message for the caller */
-  welcomeGreeting: z.string().optional(),
+var VoiceTwiMLOptionsBase = z.object({
   /**
-   * What caller input can interrupt the welcome greeting.
-   * Defaults to 'any' on Twilio.
+   * Custom parameters to pass to the provider's TwiML element as `<Parameter>`
+   * children.
    */
-  welcomeGreetingInterruptible: InterruptModeSchema.optional(),
+  customParameters: CustomParametersSchema.optional(),
   /**
    * URL for Twilio to request when the call ends (`<Connect action>`). Set to
    * a non-empty URL, or leave unset. An explicit `undefined` suppresses the
-   * action entirely (see `VoiceChannel`'s actionUrl resolution); an empty
+   * action entirely (see the TwiML builder's actionUrl resolution); an empty
    * string is rejected so it can't silently drop the action.
    */
   actionUrl: z.string().min(1, "actionUrl must not be empty").optional(),
   /**
-   * Conversation Service SID. When set, ConversationRelay will manage
-   * conversation creation and participants.
-   */
-  conversationConfiguration: z.string().optional(),
-  /**
-   * ConversationRelay WebSocket URL (the `<ConversationRelay url=...>`
-   * attribute). Leave unset (the default) to use the URL the channel derives
+   * WebSocket URL for the provider's TwiML element (`<ConversationRelay url=...>`
+   * today). Leave unset (the default) to use the URL the channel derives
    * from `TACConfig.voicePublicDomain` + `voiceWebsocketPath`. Set it only for
    * a per-call URL — e.g. an affinity-routed host that appends a token to the
    * upgrade URL — typically from an `onInboundCallTwiml` customizer. Layers
    * per-field like every other field. Must be non-empty when set.
    */
-  websocketUrl: z.string().min(1, "websocketUrl must not be empty").optional(),
+  websocketUrl: z.string().min(1, "websocketUrl must not be empty").optional()
+});
+var VoiceTwiMLOptionsSchema = VoiceTwiMLOptionsBase.strict();
+var VoiceTwiMLOptionsConversationRelaySchema = VoiceTwiMLOptionsBase.extend({
+  /** Initial greeting message for the caller */
+  welcomeGreeting: z.string().optional(),
+  /**
+   * What caller input can interrupt the welcome greeting.
+   * Defaults to 'any' on Twilio.
+   */
+  welcomeGreetingInterruptible: InterruptModeSchema.optional(),
+  /**
+   * Conversation Service SID. When set, ConversationRelay will manage
+   * conversation creation and participants.
+   */
+  conversationConfiguration: z.string().optional(),
   // Language, TTS, STT
   /**
    * Language for both STT and TTS, e.g. 'en-US'. Equivalent to setting both
@@ -937,17 +950,19 @@ var TwiMLOptionsSchema = z.object({
   extra: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).optional()
 }).strict().superRefine((value, ctx) => {
   if (!value.extra) return;
-  const typed = new Set(Object.keys(TwiMLOptionsShape).filter((k) => k !== "extra"));
+  const typed = new Set(
+    Object.keys(VoiceTwiMLOptionsConversationRelayShape).filter((k) => k !== "extra")
+  );
   const shadowed = Object.keys(value.extra).filter((k) => typed.has(k)).sort();
   if (shadowed.length > 0) {
     ctx.addIssue({
       code: "custom",
       path: ["extra"],
-      message: `TwiMLOptions.extra keys [${shadowed.join(", ")}] shadow typed fields. Set the typed field directly instead of using \`extra\`.`
+      message: `VoiceTwiMLOptionsConversationRelay.extra keys [${shadowed.join(", ")}] shadow typed fields. Set the typed field directly instead of using \`extra\`.`
     });
   }
 });
-var TwiMLOptionsShape = {
+var VoiceTwiMLOptionsConversationRelayShape = {
   customParameters: true,
   welcomeGreeting: true,
   welcomeGreetingInterruptible: true,
@@ -979,6 +994,28 @@ var TwiMLOptionsShape = {
   languages: true,
   extra: true
 };
+var VoiceTwiMLOptionsMediaStreamsSchema = VoiceTwiMLOptionsBase.extend({
+  /**
+   * Friendly name for the stream (`<Stream name=...>`). Must be unique per
+   * call; it arrives back in the WebSocket `start` event.
+   */
+  name: z.string().optional(),
+  /**
+   * Absolute URL Twilio posts to when the stream starts, stops, or errors
+   * (StreamSid/StreamName/StreamEvent/StreamError/Timestamp params). Must be
+   * non-empty when set, like the other URL fields, so an empty string can't
+   * silently emit a broken attribute.
+   */
+  statusCallback: z.string().min(1, "statusCallback must not be empty").optional(),
+  /** HTTP method for `statusCallback`. Defaults to POST on Twilio. */
+  statusCallbackMethod: z.enum(["GET", "POST"]).optional(),
+  /**
+   * HTTP method for `actionUrl`. Defaults to POST on Twilio. Lives here rather
+   * than on the shared base because no other provider's TwiML exposes it.
+   */
+  actionMethod: z.enum(["GET", "POST"]).optional()
+}).strict();
+var TwiMLOptionsSchema = VoiceTwiMLOptionsConversationRelaySchema;
 var TwiMLRequestSchema = z.object({
   from: z.string().optional(),
   to: z.string().optional(),
@@ -990,8 +1027,8 @@ var TwiMLRequestSchema = z.object({
   /**
    * Any other fields from the Twilio webhook not captured above. Values are
    * always strings here (webhook form fields are url-encoded), unlike
-   * TwiMLOptions.extra which accepts string | boolean | number for emitted
-   * TwiML attributes.
+   * VoiceTwiMLOptionsConversationRelay.extra which accepts string | boolean |
+   * number for emitted TwiML attributes.
    */
   extra: z.record(z.string(), z.string()).default({})
 });
@@ -1231,12 +1268,52 @@ function callOptionsToCreateParams(options) {
   }
   return params;
 }
-var InitiateVoiceConversationOptionsSchema = z.object({
+var InitiateVoiceConversationOptionsBase = z.object({
   to: z.string().min(1, "Recipient phone number is required"),
   websocketUrl: z.url().optional(),
-  twimlOptions: TwiMLOptionsSchema.optional(),
+  twimlOptions: VoiceTwiMLOptionsConversationRelaySchema.optional(),
   callOptions: CallOptionsSchema.optional()
+});
+var InitiateVoiceConversationOptionsSchema = InitiateVoiceConversationOptionsBase.strict();
+var InitiateVoiceConversationOptionsOpenAIRealtimeSchema = InitiateVoiceConversationOptionsBase.extend({
+  // Overridden to the Media Streams subtype: the inherited ConversationRelay
+  // schema is `.strict()` and would reject `name` / `statusCallback` outright,
+  // so this provider's TwiML options could never survive parsing.
+  twimlOptions: VoiceTwiMLOptionsMediaStreamsSchema.optional(),
+  /**
+   * Used verbatim in place of `OpenAIRealtimeProviderConfig.defaultSessionConfig`
+   * for this call.
+   */
+  sessionConfig: z.record(z.string(), z.unknown()).nullable().optional()
 }).strict();
+var InitiateVoiceConversationOptionsGPTLiveSchema = InitiateVoiceConversationOptionsBase.extend({
+  // Overridden to the Media Streams subtype: the inherited ConversationRelay
+  // schema is `.strict()` and would reject `name` / `statusCallback` outright,
+  // so this provider's TwiML options could never survive parsing.
+  twimlOptions: VoiceTwiMLOptionsMediaStreamsSchema.optional(),
+  /**
+   * Used verbatim in place of `GPTLiveProviderConfig.defaultSessionConfig`
+   * for this call.
+   */
+  sessionConfig: z.record(z.string(), z.unknown()).nullable().optional()
+}).strict();
+var StreamStartMessageSchema = z.object({
+  /** SID of the Media Stream itself (`MZ...`), used to address media back to Twilio. */
+  streamSid: z.string(),
+  /** SID of the call the stream is attached to — TAC's conversation identifier. */
+  callSid: z.string(),
+  /**
+   * Negotiated audio format (encoding, sample rate, channels). Left untyped
+   * because Twilio may add fields here, and the provider only reads it for
+   * diagnostics.
+   */
+  mediaFormat: z.record(z.string(), z.unknown()).nullable().optional(),
+  /**
+   * Values of the `<Parameter>` children emitted on `<Stream>`. Defaults to an
+   * empty object so callers never have to null-check it.
+   */
+  customParameters: z.record(z.string(), z.string()).default({})
+});
 var JSONSchemaSchema = z.object({
   type: z.enum(["object", "string", "number", "boolean", "array"]),
   properties: z.record(z.string(), z.any()).optional(),
@@ -1258,6 +1335,12 @@ var AnthropicToolSchema = z.object({
   description: z.string(),
   input_schema: JSONSchemaSchema
 });
+var OpenAIRealtimeToolSchema = z.object({
+  type: z.literal("function"),
+  name: z.string(),
+  description: z.string(),
+  parameters: JSONSchemaSchema
+});
 var ToolExecutionResultSchema = z.object({
   success: z.boolean(),
   data: z.any().optional(),
@@ -1681,7 +1764,97 @@ function createLogger(options) {
 
 // package.json
 var package_default = {
-  version: "2.2.0"};
+  name: "twilio-agent-connect",
+  version: "2.4.0",
+  description: "Twilio Agent Connect - A TypeScript framework for building intelligent agents",
+  type: "module",
+  main: "./dist/index.js",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      default: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup",
+    clean: "rimraf dist packages/*/dist",
+    test: "vitest --run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest --coverage",
+    lint: "eslint 'packages/*/src/**/*.ts' 'src/**/*.ts'",
+    "lint:fix": "eslint 'packages/*/src/**/*.ts' 'src/**/*.ts' --fix",
+    format: "prettier --write 'packages/*/src/**/*.ts' 'src/**/*.ts' 'getting_started/**/*.ts'",
+    "format:check": "prettier --check 'packages/*/src/**/*.ts' 'src/**/*.ts' 'getting_started/**/*.ts'",
+    typecheck: "tsc --noEmit",
+    docs: "typedoc",
+    "docs:watch": "typedoc --watch",
+    "example:getting-started": "cd getting_started/examples/openai && npm install && npm run dev",
+    "example:chat": "cd getting_started/examples/chat && npm install && npm run dev"
+  },
+  keywords: [
+    "twilio",
+    "ai",
+    "agents",
+    "framework",
+    "typescript"
+  ],
+  author: "Twilio",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/twilio/twilio-agent-connect-typescript.git"
+  },
+  devDependencies: {
+    "@eslint/js": "^9.0.0",
+    "@shipgirl/typedoc-plugin-versions": "^0.3.2",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "@vitest/coverage-v8": "^4.1.2",
+    "axios-mock-adapter": "^2.1.0",
+    eslint: "^9.0.0",
+    globals: "^15.0.0",
+    prettier: "^3.0.0",
+    rimraf: "^5.0.0",
+    tsup: "^8.5.1",
+    typedoc: "^0.28.20",
+    "typedoc-material-theme": "^1.4.1",
+    typescript: "^5.0.0",
+    "typescript-eslint": "^8.0.0",
+    vitest: "^4.1.2"
+  },
+  dependencies: {
+    "@fastify/formbody": "^8.0.2",
+    "@fastify/websocket": "^11.2.0",
+    "@segment/analytics-node": "^3.1.0",
+    axios: "^1.15.2",
+    "axios-retry": "^4.5.0",
+    dotenv: "^16.4.7",
+    fastify: "^5.8.5",
+    "fastify-graceful-shutdown": "^5.0.0",
+    pino: "^9.0.0",
+    twilio: "^5.10.7",
+    ws: "^8.19.0",
+    zod: "^4.0.0"
+  },
+  peerDependencies: {
+    "@openai/agents": "^0.8.0"
+  },
+  peerDependenciesMeta: {
+    "@openai/agents": {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=22.13.0",
+    npm: ">=9.0.0"
+  }
+};
 function buildUserAgent() {
   return `twilio-agent-connect-typescript/${package_default.version}`;
 }
@@ -2425,6 +2598,57 @@ var KnowledgeClient = class extends BaseClient {
     }
   }
 };
+var SDK_PACKAGE = "twilio-agent-connect-typescript";
+var client = null;
+var log = null;
+var disabled = null;
+function getLog() {
+  return log ??= createLogger({ name: "analytics" });
+}
+function isDisabled() {
+  if (disabled === null) {
+    disabled = process.env.TAC_ANALYTICS_DISABLED === "true";
+  }
+  return disabled;
+}
+function getClient() {
+  if (isDisabled()) return null;
+  if (client) return client;
+  client = new Analytics({
+    writeKey: "oH5gLNxB4NEg60y81mBxHWZn4RAoXQTN",
+    flushAt: 20,
+    flushInterval: 1e4
+  });
+  client.on("error", (err) => {
+    getLog().debug({ err }, "Segment analytics error");
+  });
+  return client;
+}
+function trackEvent(event, properties) {
+  try {
+    const analytics = getClient();
+    if (!analytics) return;
+    analytics.track({
+      anonymousId: properties.account_sid,
+      event,
+      properties: {
+        ...properties,
+        sdk_version: package_default.version,
+        sdk_package: SDK_PACKAGE
+      }
+    });
+    getLog().debug({ event }, "Analytics event tracked");
+  } catch (err) {
+    getLog().debug({ err, event }, "Analytics event failed");
+  }
+}
+async function shutdownAnalytics() {
+  if (client) {
+    await client.closeAndFlush({ timeout: 5e3 }).catch(() => {
+    });
+    client = null;
+  }
+}
 
 // packages/core/src/lib/operator-result-processor.ts
 function extractProfileIds(operatorResult) {
@@ -3164,6 +3388,8 @@ var TAC = class _TAC {
       channel.shutdown();
     }
     this.channels.clear();
+    shutdownAnalytics().catch(() => {
+    });
     this.logger.info("TAC shutdown complete");
   }
 };
@@ -3255,6 +3481,12 @@ var BaseChannel = class {
     if (this.callbacks.onConversationStarted) {
       this.callbacks.onConversationStarted({ session });
     }
+    trackEvent("Conversation Started", {
+      account_sid: this.config.accountSid,
+      channel: this.channelType,
+      conversation_id: conversationId,
+      has_profile_id: !!profileId
+    });
     return session;
   }
   /**
@@ -3277,6 +3509,12 @@ var BaseChannel = class {
           );
         }
       }
+      trackEvent("Conversation Ended", {
+        account_sid: this.config.accountSid,
+        channel: this.channelType,
+        conversation_id: conversationId,
+        duration_ms: Date.now() - session.startedAt.getTime()
+      });
       this.activeConversations.delete(conversationId);
       this.logger.debug(
         {
@@ -3543,6 +3781,21 @@ var MessagingChannel = class extends BaseChannel {
     this.conversationClient = tac.getConversationClient();
     this.messagingCallbacks = {};
   }
+  /**
+   * 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.
+   */
+  trackResponseSent(conversationId) {
+    trackEvent("Response Sent", {
+      account_sid: this.config.accountSid,
+      channel: this.channelType,
+      conversation_id: conversationId,
+      response_type: "full"
+    });
+  }
   /**
    * Check if a message is from the bot itself (2-tier).
    *
@@ -3777,6 +4030,11 @@ var MessagingChannel = class extends BaseChannel {
         userMemory
       });
     }
+    trackEvent("Message Received", {
+      account_sid: this.config.accountSid,
+      channel: this.channelType,
+      conversation_id: conversationId
+    });
   }
   /**
    * Handle conversation updated event
@@ -4253,6 +4511,7 @@ var SMSChannel = class extends MessagingChannel {
       });
       throw error;
     }
+    this.trackResponseSent(conversationId);
   }
   /**
    * Initiate an outbound SMS conversation
@@ -4375,6 +4634,7 @@ var RCSChannel = class extends MessagingChannel {
       });
       throw error;
     }
+    this.trackResponseSent(conversationId);
   }
   /**
    * Initiate an outbound RCS conversation
@@ -4499,6 +4759,7 @@ var WhatsAppChannel = class extends MessagingChannel {
       });
       throw error;
     }
+    this.trackResponseSent(conversationId);
   }
   /**
    * Initiate an outbound WhatsApp conversation
@@ -4639,6 +4900,7 @@ var ChatChannel = class extends MessagingChannel {
       });
       throw error;
     }
+    this.trackResponseSent(conversationId);
   }
   /**
    * Initiate an outbound chat conversation
@@ -4667,271 +4929,489 @@ var ChatChannel = class extends MessagingChannel {
   }
 };
 
-// packages/core/src/util/handoff-urls.ts
-function studioExecutionsUrl(flowSid) {
-  return `https://studio.twilio.com/v2/Flows/${flowSid}/Executions`;
-}
-function studioVoiceHandoffUrl(accountSid, flowSid) {
-  return `https://webhooks.twilio.com/v1/Accounts/${accountSid}/Flows/${flowSid}?Trigger=incomingCall`;
+// packages/core/src/lib/deprecation.ts
+var warned = /* @__PURE__ */ new Set();
+function warnDeprecated(oldName, replacement) {
+  if (warned.has(oldName)) return;
+  warned.add(oldName);
+  console.warn(`${oldName} is deprecated and will be removed in 3.0 \u2014 use ${replacement} instead.`);
 }
 
-// packages/core/src/channels/voice.ts
-var DEFAULT_WELCOME_GREETING = "Hello! How can I assist you today?";
-var POLL_ATTEMPTS = 10;
-var POLL_BASE_DELAY_MS = 250;
-var POLL_MAX_DELAY_MS = 1500;
-function stringifyParameterValue(value) {
-  if (typeof value === "object") {
-    return JSON.stringify(value);
+// packages/core/src/channels/voice/provider.ts
+var VoiceProvider = class {
+  /** The `VoiceChannel` that owns this provider. */
+  channel;
+  /** Logger named after the concrete provider class. */
+  logger;
+  constructor(channel) {
+    this.channel = channel;
+    this.logger = createLogger({ name: this.constructor.name });
   }
-  return String(value);
-}
-var VoiceChannel = class _VoiceChannel extends BaseChannel {
-  webSocketConnections;
-  voiceCallbacks;
-  streamTasks;
-  promptQueues;
-  initializationRetries;
-  callSidToConversationId;
-  MAX_INITIALIZATION_RETRIES = 3;
-  twilioClient;
-  voiceConfig;
-  onInboundCallTwimlHandler;
-  onCallStatusHandler;
-  onAmdHandler;
-  onRecordingHandler;
-  constructor(tac, options) {
-    super(tac, options);
-    this.voiceConfig = options ?? {};
-    this.webSocketConnections = /* @__PURE__ */ new Map();
-    this.voiceCallbacks = {};
-    this.streamTasks = /* @__PURE__ */ new Map();
-    this.promptQueues = /* @__PURE__ */ new Map();
-    this.initializationRetries = /* @__PURE__ */ new Map();
-    this.callSidToConversationId = /* @__PURE__ */ new Map();
+  /**
+   * 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() {
+    return "custom";
   }
   /**
-   * Register a callback that produces per-call overrides for the TwiML inside
-   * `<ConversationRelay>` on inbound calls.
+   * Channel name identifier, e.g. `"VOICE"`.
    *
-   * 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.
+   * A label for this provider's transport; it does not change how
+   * `VoiceChannel` reports its `ChannelType`.
+   */
+  get channelName() {
+    return "VOICE";
+  }
+  /**
+   * Build the response for an inbound call. Default: not supported.
    *
-   * @example
-   * ```typescript
-   * voiceChannel.onInboundCallTwiml(async req => {
-   *   if (req.callerCountry === 'MX') {
-   *     return { language: 'es-MX', welcomeGreeting: '¡Hola!' };
-   *   }
-   *   return {};
-   * });
-   * ```
+   * @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.
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await -- Default rejects without awaiting, but stays `async` so callers always get a Promise
+  async handleIncomingCall(_twimlRequest, _options) {
+    throw new Error(`${this.constructor.name} does not support inbound calls.`);
+  }
+  /**
+   * Handle this provider's own out-of-band lifecycle webhook, if it has one.
    *
-   * Outbound calls don't use this — pass per-call TwiML via
-   * `InitiateVoiceConversationOptions.twimlOptions` directly.
+   * 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.
    */
-  onInboundCallTwiml(callback) {
-    this.onInboundCallTwimlHandler = callback;
+  // eslint-disable-next-line @typescript-eslint/require-await -- Default acknowledges without awaiting, but stays `async` so callers always get a Promise
+  async handleTwilioProviderCallback(_payload) {
+    return { status: 200, content: "", contentType: "text/plain" };
   }
   /**
-   * Register a handler for Twilio `statusCallback` webhooks.
+   * Drive one WebSocket connection from accept to disconnect.
    *
-   * This is the Calls-API status callback (call disposition), not the
-   * ConversationRelay session callback — see
-   * {@link handleConversationRelayCallback}.
+   * 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) {
+    throw new Error(`${this.constructor.name} does not support WebSocket connections.`);
+  }
+  /** Place an outbound call. Default: not supported. */
+  // eslint-disable-next-line @typescript-eslint/require-await -- Default rejects without awaiting, but stays `async` so callers always get a Promise
+  async initiateOutboundConversation(_options) {
+    throw new Error(`${this.constructor.name} does not support outbound calls.`);
+  }
+  /** Send a text response back through this provider's transport, if supported. */
+  // eslint-disable-next-line @typescript-eslint/require-await -- Default rejects without awaiting, but stays `async` so callers always get a Promise
+  async sendResponse(_conversationId, _message, _metadata) {
+    throw new Error(`${this.constructor.name} does not support sendResponse.`);
+  }
+  /**
+   * Stream a text response back through this provider's transport, token by
+   * token, if supported. Default: not supported.
    *
-   * 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 _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.
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await -- Default rejects without awaiting, but stays `async` so callers always get a Promise
+  async sendStreamingResponse(_conversationId, _stream, _options) {
+    throw new Error(`${this.constructor.name} does not support sendStreamingResponse.`);
+  }
+  /** Return the Twilio-facing WebSocket for a conversation, if tracked. */
+  getWebSocket(_conversationId) {
+    return null;
+  }
+  /**
+   * Drop this provider's transport state on channel shutdown.
    *
-   * Twilio reports only the terminal event by default, which covers every
-   * disposition; set `CallOptions.statusCallbackEvent` for ringing/answered.
+   * 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() {
+    return void 0;
+  }
+  /**
+   * Set callback URLs on `callParams` for every registered call-event handler.
    *
-   * @example
-   * ```typescript
-   * voiceChannel.onCallStatus(async event => {
-   *   if (event.isUnreached) {
-   *     // queue a retry
-   *   }
-   * });
-   * ```
+   * 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.
    */
-  onCallStatus(callback) {
-    this.onCallStatusHandler = callback;
+  applyCallEventCallbacks(callParams) {
+    const handlers = this.channel.getCallEventHandlers();
+    const wiring = [
+      ["status", "statusCallback", handlers.status],
+      ["amd", "asyncAmdStatusCallback", handlers.amd],
+      ["recording", "recordingStatusCallback", handlers.recording]
+    ];
+    for (const [kind, param, handler] of wiring) {
+      if (!handler) continue;
+      const url = this.channel.getTacConfig().callEventUrl(kind);
+      if (url !== void 0 && callParams[param] === void 0) {
+        callParams[param] = url;
+      }
+    }
+    return callParams;
   }
+};
+var VoiceProviderConfig = class {
+  /** Memory retrieval mode for this channel. Defaults to `'never'`. */
+  memoryMode;
   /**
-   * Register a handler for Twilio `asyncAmdStatusCallback` webhooks.
+   * The {@link BaseChannelOptions} this config was constructed with, retained
+   * verbatim so `VoiceChannel` can hand them to `BaseChannel`.
    *
-   * 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).
+   * 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.
    *
-   * @example
-   * ```typescript
-   * voiceChannel.onAmd(async event => {
-   *   if (event.isMachine) {
-   *     await voiceChannel.endCall(event.callSid); // voicemail → hang up
-   *   }
-   * });
-   * ```
+   * @internal
    */
-  onAmd(callback) {
-    this.onAmdHandler = callback;
+  channelOptions;
+  constructor(options) {
+    this.memoryMode = options?.memoryMode ?? "never";
+    this.channelOptions = { ...options };
   }
   /**
-   * 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.
+   * Build the {@link VoiceProvider} this config configures.
    *
-   * @example
-   * ```typescript
-   * voiceChannel.onRecording(async event => {
-   *   if (event.recordingStatus === 'completed') {
-   *     // store event.recordingUrl
-   *   }
-   * });
-   * ```
+   * @param _channel - The owning `VoiceChannel`.
+   * @param _tacConfig - `TACConfig` — providers that talk TwiML need it to
+   *   derive default URLs (`voicePublicDomain` etc.).
    */
-  onRecording(callback) {
-    this.onRecordingHandler = callback;
+  createProvider(_channel, _tacConfig) {
+    throw new Error(
+      `${this.constructor.name} must implement createProvider() to be usable as a VoiceChannel config.`
+    );
+  }
+};
+
+// packages/core/src/channels/voice/twiml.ts
+function filterUnsetValues(config) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (value !== void 0) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function stringifyParameterValue(value) {
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+var TwiMLBuilderBase = class {
+  tacConfig;
+  channelConfig;
+  logger;
+  constructor(tacConfig, channelConfig, logger) {
+    this.tacConfig = tacConfig;
+    this.channelConfig = channelConfig;
+    this.logger = logger;
   }
   /**
-   * Resolve the public WebSocket URL from `TACConfig.voicePublicDomain` +
-   * `TACConfig.voiceWebsocketPath`. Throws if `voicePublicDomain` isn't set.
+   * 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.
    */
-  resolveWebsocketUrl(action) {
-    if (this.config.voicePublicDomain) {
-      return `wss://${this.config.voicePublicDomain}${this.config.voiceWebsocketPath}`;
+  overlayFields(target, source, skip = []) {
+    for (const key of Object.keys(source)) {
+      if (skip.includes(key)) {
+        continue;
+      }
+      target[key] = source[key];
     }
-    throw new Error(
-      `${action} needs a WebSocket URL. Set TWILIO_VOICE_PUBLIC_DOMAIN (or TACConfig.voicePublicDomain).`
+  }
+  /**
+   * The error thrown when no layer and no `TACConfig`-derived default supplies
+   * a WebSocket URL. `caller` names the API the developer actually called.
+   */
+  missingWebsocketUrlError(caller) {
+    return new Error(
+      `${caller} needs a WebSocket URL. Set TWILIO_VOICE_PUBLIC_DOMAIN (or TACConfig.voicePublicDomain).`
     );
   }
   /**
-   * Resolve the default `<Connect action=...>` cleanup URL.
+   * The WebSocket URL derived from `TACConfig.voicePublicDomain` +
+   * `TACConfig.voiceWebsocketPath`, or undefined when `voicePublicDomain` is
+   * unset.
+   */
+  defaultWebsocketUrl() {
+    if (!this.tacConfig.voicePublicDomain) {
+      return void 0;
+    }
+    return `wss://${this.tacConfig.voicePublicDomain}${this.tacConfig.voiceWebsocketPath}`;
+  }
+  /**
+   * 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.
    */
-  resolveDefaultActionUrl() {
-    if (this.config.voicePublicDomain) {
-      return `https://${this.config.voicePublicDomain}${this.config.voiceActionPath}`;
+  defaultActionUrl() {
+    if (this.tacConfig.voicePublicDomain) {
+      return `https://${this.tacConfig.voicePublicDomain}${this.tacConfig.voiceActionPath}`;
     }
     return void 0;
   }
-  getTwilioClient() {
-    if (!this.twilioClient) {
-      this.twilioClient = twilio(this.config.apiKey, this.config.apiSecret, {
-        accountSid: this.config.accountSid
-      });
+};
+
+// packages/core/src/util/handoff-urls.ts
+function studioExecutionsUrl(flowSid) {
+  return `https://studio.twilio.com/v2/Flows/${flowSid}/Executions`;
+}
+function studioVoiceHandoffUrl(accountSid, flowSid) {
+  return `https://webhooks.twilio.com/v1/Accounts/${accountSid}/Flows/${flowSid}?Trigger=incomingCall`;
+}
+
+// packages/core/src/channels/voice/conversation-relay/twiml.ts
+var DEFAULT_WELCOME_GREETING = "Hello! How can I assist you today?";
+var SKIP_ACTION_URL = ["actionUrl"];
+var TwiMLBuilderConversationRelay = class _TwiMLBuilderConversationRelay extends TwiMLBuilderBase {
+  /**
+   * Field names on {@link VoiceTwiMLOptionsConversationRelay} 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.
+   */
+  static RELAY_ATTR_FIELDS = [
+    "welcomeGreeting",
+    "welcomeGreetingInterruptible",
+    "conversationConfiguration",
+    "language",
+    "ttsLanguage",
+    "transcriptionLanguage",
+    "voice",
+    "ttsProvider",
+    "transcriptionProvider",
+    "speechModel",
+    "elevenlabsTextNormalization",
+    "eotThreshold",
+    "partialPrompts",
+    "deepgramSmartFormat",
+    "speechTimeout",
+    "interruptible",
+    "interruptSensitivity",
+    "reportInputDuringAgentSpeech",
+    "ignoreBackchannel",
+    "preemptible",
+    "dtmfDetection",
+    "hints",
+    "events",
+    "debug",
+    "intelligenceService"
+  ];
+  /**
+   * Build the TwiML XML for one call.
+   *
+   * @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, options) {
+    const merged = this.buildTwimlOptions(options?.host, options?.perCall);
+    const resolvedWebsocketUrl = options?.websocketUrl ?? merged.websocketUrl ?? this.defaultWebsocketUrl();
+    if (!resolvedWebsocketUrl) {
+      throw this.missingWebsocketUrlError(caller);
     }
-    return this.twilioClient;
-  }
-  get channelType() {
-    return "voice";
+    return this.generateTwiml(resolvedWebsocketUrl, merged);
   }
   /**
-   * Register event callbacks (override for Voice-specific events)
+   * 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).
+   *
+   * `actionUrl` is skipped by the overlays on purpose — it's resolved once via
+   * {@link resolveActionUrl} looking at every layer at once, and that resolved
+   * value is written into `merged` before the overlays run. Letting it through
+   * would let a higher-priority layer that didn't set actionUrl silently clobber
+   * a lower layer that did.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Generic event callback needs to accept any args
-  on(event, callback) {
-    switch (event) {
-      case "setup":
-        this.voiceCallbacks.onSetup = callback;
-        break;
-      case "prompt":
-        this.voiceCallbacks.onPrompt = callback;
-        break;
-      case "interrupt":
-        this.voiceCallbacks.onInterrupt = callback;
-        break;
-      case "webSocketConnected":
-        this.voiceCallbacks.onWebSocketConnected = callback;
-        break;
-      case "webSocketDisconnected":
-        this.voiceCallbacks.onWebSocketDisconnected = callback;
-        break;
-      default:
-        super.on(event, callback);
-        break;
+  buildTwimlOptions(host, perCall) {
+    const merged = {
+      welcomeGreeting: DEFAULT_WELCOME_GREETING,
+      ...this.tacConfig.isOrchestratorEnabled() && this.tacConfig.conversationConfigurationId !== void 0 ? { conversationConfiguration: this.tacConfig.conversationConfigurationId } : {}
+    };
+    const resolvedActionUrl = this.resolveActionUrl(host, perCall);
+    if (resolvedActionUrl !== void 0) {
+      merged.actionUrl = resolvedActionUrl;
+    }
+    if (host) {
+      this.overlayFields(merged, host, SKIP_ACTION_URL);
     }
+    if (this.channelConfig.defaultTwimlOptions) {
+      this.overlayFields(merged, this.channelConfig.defaultTwimlOptions, SKIP_ACTION_URL);
+    }
+    if (perCall) {
+      this.overlayFields(merged, perCall, SKIP_ACTION_URL);
+    }
+    return merged;
   }
   /**
-   * Process conversation webhooks for cleanup.
+   * Resolve the TwiML `<Connect action=...>` URL.
    *
-   * Voice channel processes CONVERSATION_UPDATED events:
-   * - CLOSED status: Clean up local session state
+   * 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`.
    *
-   * Note: Conversation tracking uses instance-local memory. In multi-instance
-   * deployments, webhooks may route to a different instance, preventing cleanup.
+   * User-expressed intent (Studio handoff is configured explicitly on
+   * `TACConfig`) beats the SDK's generated cleanup default.
    *
-   * @param payload - Raw webhook event data from Twilio
-   * @param idempotencyToken - Optional Twilio idempotency token from request headers
+   * 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.
    */
-  async processWebhook(payload, idempotencyToken) {
-    try {
-      const result = this.preprocessWebhook(payload, idempotencyToken);
-      if (!result) {
-        return;
+  resolveActionUrl(host, customized) {
+    if (customized && "actionUrl" in customized) {
+      return customized.actionUrl;
+    }
+    const defaults = this.channelConfig.defaultTwimlOptions;
+    if (defaults && "actionUrl" in defaults) {
+      return defaults.actionUrl;
+    }
+    if (host && "actionUrl" in host) {
+      return host.actionUrl;
+    }
+    if (this.tacConfig.studioHandoffFlowSid) {
+      return studioVoiceHandoffUrl(this.tacConfig.accountSid, this.tacConfig.studioHandoffFlowSid);
+    }
+    return this.defaultActionUrl();
+  }
+  /**
+   * Generate TwiML XML for ConversationRelay from a merged {@link VoiceTwiMLOptionsConversationRelay}.
+   *
+   * This is the low-level emitter used by {@link build} after layering. It
+   * mirrors the Python SDK's `generate_twiml`.
+   *
+   * @param websocketUrl - Public WebSocket URL (e.g. 'wss://example.ngrok.app/ws').
+   * @param options - Merged VoiceTwiMLOptionsConversationRelay to emit.
+   * @returns TwiML XML string ready to return to Twilio.
+   */
+  generateTwiml(websocketUrl, options) {
+    const response = new VoiceResponse();
+    const connect = response.connect(options.actionUrl ? { action: options.actionUrl } : {});
+    const relayAttrs = { url: websocketUrl };
+    for (const field of _TwiMLBuilderConversationRelay.RELAY_ATTR_FIELDS) {
+      let value = options[field];
+      if (value === void 0) {
+        continue;
       }
-      const { webhookData, eventType, conversationId } = result;
-      switch (eventType) {
-        case "CONVERSATION_UPDATED":
-          this.logger.debug(
-            { conversation_id: conversationId, status: webhookData.data?.status },
-            "Handling CONVERSATION_UPDATED"
-          );
-          await this.handleConversationUpdated(webhookData);
-          break;
-        default:
-          this.logger.debug(
-            {
-              event_type: eventType,
-              raw_event_type: webhookData.eventType,
-              conversation_id: conversationId
-            },
-            "Unhandled event type - this event will be ignored"
+      if (field === "interruptible" && typeof value === "boolean") {
+        value = value ? "any" : "none";
+      }
+      relayAttrs[field] = value;
+    }
+    if (options.extra) {
+      for (const [key, value] of Object.entries(options.extra)) {
+        if (key === "url") {
+          this.logger.warn(
+            "Ignoring `url` in VoiceTwiMLOptionsConversationRelay.extra; set `websocketUrl` to override the ConversationRelay URL."
           );
+          continue;
+        }
+        relayAttrs[key] = value;
       }
-      this.logger.debug({ event_type: eventType }, "Webhook processing completed");
-    } catch (error) {
-      if (idempotencyToken) {
-        this.removeWebhookToken(idempotencyToken);
+    }
+    const relay = connect.conversationRelay(
+      relayAttrs
+    );
+    if (options.languages && options.languages.length > 0) {
+      for (const lang of options.languages) {
+        const langAttrs = filterUnsetValues(lang);
+        relay.language(langAttrs);
       }
-      this.handleError(error instanceof Error ? error : new Error(String(error)), { payload });
     }
+    if (options.customParameters) {
+      for (const [name, value] of Object.entries(options.customParameters)) {
+        if (value !== null && value !== void 0) {
+          relay.parameter({ name, value: stringifyParameterValue(value) });
+        }
+      }
+    }
+    return response.toString();
+  }
+};
+
+// packages/core/src/channels/voice/conversation-relay/provider.ts
+var POLL_ATTEMPTS = 10;
+var POLL_BASE_DELAY_MS = 250;
+var POLL_MAX_DELAY_MS = 1500;
+var ConversationRelayProvider = class extends VoiceProvider {
+  /** @internal */
+  get providerId() {
+    return "conversation_relay";
   }
   /**
-   * Handle conversation updated event
+   * The owning channel's logger, so relocated ConversationRelay logic keeps
+   * logging exactly as it did when it lived on `VoiceChannel`.
    */
-  async handleConversationUpdated(payload) {
-    const conversationId = this.extractConversationId(payload);
-    if (!conversationId) {
-      throw new Error("Missing conversation ID in conversation.updated event");
-    }
-    if (payload.data?.status === "CLOSED") {
-      this.logger.debug(
-        { conversation_id: conversationId, status: payload.data.status },
-        "Conversation closed, cleaning up"
-      );
-      await this.endConversation(conversationId);
-    } else if (payload.data?.status === "INACTIVE") {
-      this.invalidateCachedMemory(conversationId);
-    }
+  logger;
+  /** In-flight streaming responses, keyed by conversation. */
+  streamTasks;
+  config;
+  tacConfig;
+  twimlBuilder;
+  webSocketConnections;
+  promptQueues;
+  initializationRetries;
+  callSidToConversationId;
+  MAX_INITIALIZATION_RETRIES = 3;
+  constructor(channel, tacConfig, config) {
+    super(channel);
+    this.logger = channel.getLoggerInternal();
+    this.config = config;
+    this.tacConfig = tacConfig;
+    this.twimlBuilder = new TwiMLBuilderConversationRelay(tacConfig, config, this.logger);
+    this.streamTasks = /* @__PURE__ */ new Map();
+    this.webSocketConnections = /* @__PURE__ */ new Map();
+    this.promptQueues = /* @__PURE__ */ new Map();
+    this.initializationRetries = /* @__PURE__ */ new Map();
+    this.callSidToConversationId = /* @__PURE__ */ new Map();
+  }
+  get channelName() {
+    return "VOICE";
   }
   /**
    * Get active WebSocket connection for a conversation
    */
-  getWebsocket(conversationId) {
+  getWebSocket(conversationId) {
     return this.webSocketConnections.get(conversationId) || null;
   }
   /**
@@ -4941,12 +5421,13 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
    * caller speaks.
    */
   async initializeOrchestratedConversation(callSid, fromNumber, ws) {
-    if (!this.conversationClient) {
+    const conversationClient = this.channel.getConversationClientInternal();
+    if (!conversationClient) {
       throw new Error("Conversation client is required in orchestrated mode");
     }
     let conversations = [];
     for (let attempt = 0; attempt < POLL_ATTEMPTS; attempt++) {
-      conversations = await this.conversationClient.listConversations({
+      conversations = await conversationClient.listConversations({
         channelId: callSid,
         status: ["ACTIVE"]
       });
@@ -4967,33 +5448,100 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
     }
     const conversation = conversations[0];
     const conversationId = conversation.id;
-    const participants = await this.conversationClient.listParticipants(conversationId);
+    const participants = await conversationClient.listParticipants(conversationId);
     const customerParticipant = participants.find((p) => p.type === "CUSTOMER");
     const customerAddress = customerParticipant?.addresses?.find((a) => a.channel === "VOICE")?.address ?? fromNumber ?? void 0;
     const profileId = customerParticipant?.profileId ? customerParticipant.profileId : void 0;
     this.webSocketConnections.set(conversationId, ws);
     this.callSidToConversationId.set(callSid, conversationId);
-    const session = this.startConversation(conversationId, profileId);
+    const session = this.channel.startConversationInternal(conversationId, profileId);
     session.callSid = callSid;
     if (customerAddress) {
       session.authorInfo = {
         address: customerAddress
       };
     }
-    if (this.voiceCallbacks.onWebSocketConnected) {
-      this.voiceCallbacks.onWebSocketConnected({ conversationId });
+    const voiceCallbacks = this.channel.getVoiceCallbacks();
+    if (voiceCallbacks.onWebSocketConnected) {
+      voiceCallbacks.onWebSocketConnected({ conversationId });
     }
     return conversationId;
   }
   /**
    * Handle WebSocket connection from ConversationRelay
    */
-  handleWebSocketConnection(ws) {
+  handleWebSocket(ws) {
     let conversationId = null;
     let callSid = null;
     let fromNumber = null;
     let initializationFailed = false;
     let initPromise = null;
+    const ensureConversation = async () => {
+      if (conversationId) {
+        return conversationId;
+      }
+      const sid = callSid;
+      if (!sid) {
+        return null;
+      }
+      const retryCount = this.initializationRetries.get(sid) ?? 0;
+      if (retryCount >= this.MAX_INITIALIZATION_RETRIES) {
+        throw new Error(
+          `Cannot process message - conversation initialization failed after ${retryCount} attempts for callSid ${sid}`
+        );
+      }
+      try {
+        if (initializationFailed) {
+          this.logger.info(
+            { call_sid: sid, retry_count: retryCount },
+            "Retrying conversation initialization after previous failure"
+          );
+        }
+        if (!this.channel.isOrchestratorEnabledInternal()) {
+          conversationId = sid;
+          this.webSocketConnections.set(conversationId, ws);
+          this.callSidToConversationId.set(sid, conversationId);
+          const session = this.channel.startConversationInternal(conversationId);
+          session.callSid = sid;
+          if (fromNumber) {
+            session.authorInfo = { address: fromNumber };
+          }
+          const voiceCallbacks = this.channel.getVoiceCallbacks();
+          if (voiceCallbacks.onWebSocketConnected) {
+            voiceCallbacks.onWebSocketConnected({ conversationId });
+          }
+        } else {
+          initPromise ??= this.initializeOrchestratedConversation(sid, fromNumber, ws);
+          try {
+            conversationId = await initPromise;
+          } finally {
+            initPromise = null;
+          }
+        }
+        initializationFailed = false;
+        this.initializationRetries.delete(sid);
+        this.logger.info(
+          { conversation_id: conversationId, call_sid: sid },
+          "Conversation initialization succeeded"
+        );
+        trackEvent("Conversation Initialized", {
+          account_sid: this.tacConfig.accountSid,
+          channel: "voice",
+          conversation_id: conversationId,
+          provider: this.providerId,
+          orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+        });
+        return conversationId;
+      } catch (err) {
+        initializationFailed = true;
+        this.initializationRetries.set(sid, retryCount + 1);
+        this.logger.error(
+          { err, call_sid: sid, retry_count: retryCount + 1 },
+          "Conversation initialization failed"
+        );
+        throw err;
+      }
+    };
     ws.on("message", (data) => {
       (async () => {
         try {
@@ -5016,7 +5564,7 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
             case "setup":
               callSid = message.callSid;
               fromNumber = message.from;
-              if (this.tac.isOrchestratorEnabled()) {
+              if (this.channel.isOrchestratorEnabledInternal()) {
                 this.logger.debug(
                   { call_sid: callSid },
                   "Starting background conversation initialization"
@@ -5024,77 +5572,30 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
                 initPromise = this.initializeOrchestratedConversation(callSid, fromNumber, ws);
                 void initPromise.catch(() => void 0);
               }
-              if (this.voiceCallbacks.onSetup) {
-                this.voiceCallbacks.onSetup({
-                  callSid,
-                  from: message.from,
-                  to: message.to,
-                  customParameters: message.customParameters
-                });
+              {
+                const voiceCallbacks = this.channel.getVoiceCallbacks();
+                if (voiceCallbacks.onSetup) {
+                  voiceCallbacks.onSetup({
+                    callSid,
+                    from: message.from,
+                    to: message.to,
+                    customParameters: message.customParameters
+                  });
+                }
               }
               break;
             case "prompt":
-              if (!conversationId && callSid) {
-                const retryCount = this.initializationRetries.get(callSid) ?? 0;
-                if (retryCount >= this.MAX_INITIALIZATION_RETRIES) {
-                  throw new Error(
-                    `Cannot process prompt - conversation initialization failed after ${retryCount} attempts for callSid ${callSid}`
-                  );
-                }
-                try {
-                  if (initializationFailed) {
-                    this.logger.info(
-                      { call_sid: callSid, retry_count: retryCount },
-                      "Retrying conversation initialization after previous failure"
-                    );
-                  }
-                  if (!this.tac.isOrchestratorEnabled()) {
-                    conversationId = callSid;
-                    this.webSocketConnections.set(conversationId, ws);
-                    this.callSidToConversationId.set(callSid, conversationId);
-                    const session = this.startConversation(conversationId);
-                    session.callSid = callSid;
-                    if (fromNumber) {
-                      session.authorInfo = { address: fromNumber };
-                    }
-                    if (this.voiceCallbacks.onWebSocketConnected) {
-                      this.voiceCallbacks.onWebSocketConnected({ conversationId });
-                    }
-                  } else {
-                    initPromise ??= this.initializeOrchestratedConversation(
-                      callSid,
-                      fromNumber,
-                      ws
-                    );
-                    try {
-                      conversationId = await initPromise;
-                    } finally {
-                      initPromise = null;
-                    }
-                  }
-                  initializationFailed = false;
-                  this.initializationRetries.delete(callSid);
-                  this.logger.info(
-                    { conversation_id: conversationId, call_sid: callSid },
-                    "Conversation initialization succeeded"
-                  );
-                } catch (err) {
-                  initializationFailed = true;
-                  this.initializationRetries.set(callSid, retryCount + 1);
-                  this.logger.error(
-                    { err, call_sid: callSid, retry_count: retryCount + 1 },
-                    "Conversation initialization failed"
-                  );
-                  throw err;
-                }
-              }
+              await ensureConversation();
               if (conversationId) {
                 const previousPrompt = this.promptQueues.get(conversationId) ?? Promise.resolve();
                 const currentPrompt = previousPrompt.then(() => this.handlePromptMessage(conversationId, message)).catch((err) => {
-                  this.handleError(err instanceof Error ? err : new Error(String(err)), {
-                    conversationId,
-                    message: data.toString()
-                  });
+                  this.channel.handleErrorInternal(
+                    err instanceof Error ? err : new Error(String(err)),
+                    {
+                      conversationId,
+                      message: data.toString()
+                    }
+                  );
                 });
                 this.promptQueues.set(conversationId, currentPrompt);
               } else {
@@ -5106,6 +5607,17 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
                 this.handleInterruptMessage(conversationId, message);
               }
               break;
+            case "dtmf":
+              try {
+                await ensureConversation();
+              } catch (err) {
+                this.logger.warn(
+                  { err, call_sid: callSid },
+                  "Conversation initialization failed on DTMF keypress, delivering digit without a conversation"
+                );
+              }
+              await this.handleDtmfMessage(conversationId, callSid, message);
+              break;
             default:
               this.logger.debug(
                 {
@@ -5117,11 +5629,14 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
               break;
           }
         } catch (error) {
-          this.handleError(error instanceof Error ? error : new Error(String(error)), {
-            conversationId,
-            callSid,
-            message: data.toString()
-          });
+          this.channel.handleErrorInternal(
+            error instanceof Error ? error : new Error(String(error)),
+            {
+              conversationId,
+              callSid,
+              message: data.toString()
+            }
+          );
         }
       })().catch((err) => {
         this.logger.error({ err }, "Unhandled error in WebSocket message handler");
@@ -5155,7 +5670,7 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
       }
     });
     ws.on("error", (error) => {
-      this.handleError(error, { conversationId });
+      this.channel.handleErrorInternal(error, { conversationId });
     });
   }
   /**
@@ -5164,10 +5679,11 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
   async handlePromptMessage(conversationId, message) {
     const transcript = message.voicePrompt;
     const streamTask = this.startStreamTask(conversationId);
-    const session = this.getConversationSession(conversationId);
-    const userMemory = session ? await this.retrieveMemoryIfEnabled(session, transcript) : void 0;
-    if (this.voiceCallbacks.onPrompt) {
-      await this.voiceCallbacks.onPrompt({
+    const session = this.channel.getConversationSession(conversationId);
+    const userMemory = session ? await this.channel.retrieveMemoryInternal(session, transcript) : void 0;
+    const voiceCallbacks = this.channel.getVoiceCallbacks();
+    if (voiceCallbacks.onPrompt) {
+      await voiceCallbacks.onPrompt({
         conversationId,
         transcript,
         abortSignal: streamTask.controller.signal,
@@ -5203,13 +5719,42 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
         }
       }
     }
-    if (this.voiceCallbacks.onInterrupt) {
-      this.voiceCallbacks.onInterrupt({
+    const voiceCallbacks = this.channel.getVoiceCallbacks();
+    if (voiceCallbacks.onInterrupt) {
+      voiceCallbacks.onInterrupt({
         conversationId,
         utteranceUntilInterrupt,
         durationUntilInterruptMs
       });
     }
+    trackEvent("Voice Interrupt", {
+      account_sid: this.tacConfig.accountSid,
+      channel: "voice",
+      conversation_id: conversationId,
+      ...durationUntilInterruptMs !== void 0 && {
+        duration_until_interrupt_ms: durationUntilInterruptMs
+      },
+      provider: this.providerId,
+      orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+    });
+  }
+  /**
+   * Handle WebSocket DTMF message (caller keypress)
+   */
+  async handleDtmfMessage(conversationId, callSid, message) {
+    const { digit } = message;
+    this.logger.debug({ conversation_id: conversationId, call_sid: callSid }, "DTMF keypress");
+    const voiceCallbacks = this.channel.getVoiceCallbacks();
+    if (!voiceCallbacks.onDtmf) {
+      return;
+    }
+    const session = conversationId ? this.channel.getConversationSession(conversationId) : void 0;
+    await voiceCallbacks.onDtmf({
+      conversationId: conversationId ?? void 0,
+      callSid: callSid ?? void 0,
+      digit,
+      ...session !== void 0 && { session }
+    });
   }
   /**
    * Handle WebSocket disconnection. In orchestrated mode the conversation stays
@@ -5220,11 +5765,19 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
     this.cancelStreamTask(conversationId);
     this.webSocketConnections.delete(conversationId);
     this.promptQueues.delete(conversationId);
-    if (this.voiceCallbacks.onWebSocketDisconnected) {
-      this.voiceCallbacks.onWebSocketDisconnected({ conversationId });
-    }
-    if (!this.tac.isOrchestratorEnabled()) {
-      await this.endConversation(conversationId);
+    const voiceCallbacks = this.channel.getVoiceCallbacks();
+    if (voiceCallbacks.onWebSocketDisconnected) {
+      voiceCallbacks.onWebSocketDisconnected({ conversationId });
+    }
+    trackEvent("Websocket Disconnected", {
+      account_sid: this.tacConfig.accountSid,
+      channel: "voice",
+      conversation_id: conversationId,
+      provider: this.providerId,
+      orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+    });
+    if (!this.channel.isOrchestratorEnabledInternal()) {
+      await this.channel.endConversationInternal(conversationId);
     }
   }
   /**
@@ -5242,7 +5795,7 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
         last: true
       };
       ws.send(JSON.stringify(response));
-      const session = this.getConversationSession(conversationId);
+      const session = this.channel.getConversationSession(conversationId);
       if (session?.pendingHandoffData) {
         try {
           ws.send(JSON.stringify(session.pendingHandoffData));
@@ -5256,7 +5809,7 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
       }
       return Promise.resolve();
     } catch (error) {
-      this.handleError(error instanceof Error ? error : new Error(String(error)), {
+      this.channel.handleErrorInternal(error instanceof Error ? error : new Error(String(error)), {
         conversationId,
         message,
         metadata
@@ -5315,7 +5868,7 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
         ws.send(JSON.stringify({ type: "text", token: "", last: true }));
       }
     } catch (error) {
-      this.handleError(error instanceof Error ? error : new Error(String(error)), {
+      this.channel.handleErrorInternal(error instanceof Error ? error : new Error(String(error)), {
         conversationId
       });
       throw error;
@@ -5327,6 +5880,61 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
     return fullResponse;
   }
   // =========================================================================
+  // Stream Task Management
+  //
+  // ConversationRelay-specific: these track the AbortController for a text
+  // token stream. Full-duplex audio transports have no equivalent, so this
+  // stays off `VoiceProvider`.
+  // =========================================================================
+  /**
+   * Start tracking a streaming task for a conversation
+   *
+   * @param conversationId - The conversation ID
+   * @returns The stream task with its AbortController
+   */
+  startStreamTask(conversationId) {
+    this.cancelStreamTask(conversationId);
+    const task = { controller: new AbortController(), hasSentTokens: false };
+    this.streamTasks.set(conversationId, task);
+    this.logger.debug({ conversation_id: conversationId }, "Started stream task");
+    return task;
+  }
+  /**
+   * Cancel an active streaming task
+   *
+   * @param conversationId - The conversation ID
+   * @returns true if a task was cancelled, false otherwise
+   */
+  cancelStreamTask(conversationId) {
+    const task = this.streamTasks.get(conversationId);
+    if (task) {
+      task.controller.abort();
+      this.streamTasks.delete(conversationId);
+      this.logger.debug({ conversation_id: conversationId }, "Cancelled stream task");
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Complete a streaming task (remove from tracking)
+   *
+   * @param conversationId - The conversation ID
+   */
+  completeStreamTask(conversationId) {
+    this.streamTasks.delete(conversationId);
+    this.logger.debug({ conversation_id: conversationId }, "Completed stream task");
+  }
+  /**
+   * Check if a stream task is active
+   *
+   * @param conversationId - The conversation ID
+   * @returns true if an active task exists
+   */
+  hasActiveStreamTask(conversationId) {
+    const task = this.streamTasks.get(conversationId);
+    return task !== void 0 && !task.controller.signal.aborted;
+  }
+  // =========================================================================
   // Incoming Call Handling
   // =========================================================================
   /**
@@ -5343,7 +5951,8 @@ var VoiceChannel = 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.
@@ -5366,117 +5975,64 @@ var VoiceChannel = 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}.
    */
   async handleIncomingCall(twimlRequest, options) {
+    const host = this.narrowTwimlOptions(options?.hostTwimlOptions, "options.hostTwimlOptions");
+    const onInboundCallTwimlHandler = this.channel.getInboundCallTwimlHandler();
     let customized;
-    if (this.onInboundCallTwimlHandler && twimlRequest) {
-      customized = await this.onInboundCallTwimlHandler(twimlRequest);
-    }
-    const merged = this.buildTwimlOptions(options?.hostTwimlOptions, customized);
-    const websocketUrl = merged.websocketUrl ?? this.resolveWebsocketUrl("handleIncomingCall");
-    return this.generateTwiml(websocketUrl, merged);
-  }
-  /**
-   * 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).
-   */
-  buildTwimlOptions(host, perCall) {
-    const merged = {
-      welcomeGreeting: DEFAULT_WELCOME_GREETING,
-      ...this.tac.isOrchestratorEnabled() && this.config.conversationConfigurationId !== void 0 ? { conversationConfiguration: this.config.conversationConfigurationId } : {}
-    };
-    const resolvedActionUrl = this.resolveActionUrl(host, perCall);
-    if (resolvedActionUrl !== void 0) {
-      merged.actionUrl = resolvedActionUrl;
-    }
-    if (host) {
-      this.overlayFields(merged, host);
-    }
-    if (this.voiceConfig.defaultTwimlOptions) {
-      this.overlayFields(merged, this.voiceConfig.defaultTwimlOptions);
-    }
-    if (perCall) {
-      this.overlayFields(merged, perCall);
-    }
-    return merged;
-  }
-  /**
-   * 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.
-   */
-  overlayFields(target, source) {
-    for (const key of Object.keys(source)) {
-      if (key === "actionUrl") {
-        continue;
-      }
-      target[key] = source[key];
+    if (onInboundCallTwimlHandler && twimlRequest) {
+      customized = this.narrowTwimlOptions(
+        await onInboundCallTwimlHandler(twimlRequest),
+        "the onInboundCallTwiml customizer output"
+      );
     }
+    return this.twimlBuilder.build("handleIncomingCall", {
+      host,
+      perCall: customized
+    });
   }
   /**
-   * Resolve the TwiML `<Connect action=...>` URL.
-   *
-   * 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.
+   * 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.
    *
-   * 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.
    */
-  resolveActionUrl(host, customized) {
-    if (customized && "actionUrl" in customized) {
-      return customized.actionUrl;
-    }
-    if (this.voiceConfig.defaultTwimlOptions && "actionUrl" in this.voiceConfig.defaultTwimlOptions) {
-      return this.voiceConfig.defaultTwimlOptions.actionUrl;
-    }
-    if (host && "actionUrl" in host) {
-      return host.actionUrl;
+  narrowTwimlOptions(value, label) {
+    if (value === void 0) {
+      return void 0;
     }
-    if (this.config.studioHandoffFlowSid) {
-      return studioVoiceHandoffUrl(this.config.accountSid, this.config.studioHandoffFlowSid);
+    const parsed = VoiceTwiMLOptionsConversationRelaySchema.safeParse(value);
+    if (!parsed.success) {
+      const errorMessage = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new Error(
+        `ConversationRelayProvider.handleIncomingCall requires ${label} to be a VoiceTwiMLOptionsConversationRelay: ${errorMessage}`
+      );
     }
-    return this.resolveDefaultActionUrl();
+    return parsed.data;
   }
   // =========================================================================
   // Outbound Call Handling
   // =========================================================================
   /**
-   * 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.
    */
   mergeCallOptions(perCall) {
-    const defaults = this.voiceConfig.defaultCallOptions;
+    const defaults = this.config.defaultCallOptions;
     if (!defaults && !perCall) {
       return void 0;
     }
@@ -5495,8 +6051,8 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
    * 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:
@@ -5508,19 +6064,7 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
   buildCallParams(callOptions) {
     const merged = this.mergeCallOptions(callOptions);
     const params = merged ? callOptionsToCreateParams(merged) : {};
-    const wiring = [
-      ["status", "statusCallback", this.onCallStatusHandler],
-      ["amd", "asyncAmdStatusCallback", this.onAmdHandler],
-      ["recording", "recordingStatusCallback", this.onRecordingHandler]
-    ];
-    for (const [kind, param, handler] of wiring) {
-      if (!handler) continue;
-      const url = this.config.callEventUrl(kind);
-      if (url !== void 0 && params[param] === void 0) {
-        params[param] = url;
-      }
-    }
-    return params;
+    return this.applyCallEventCallbacks(params);
   }
   /**
    * Initiate an outbound voice conversation
@@ -5532,14 +6076,16 @@ var VoiceChannel = 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
    *
@@ -5549,22 +6095,23 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
    */
   async initiateOutboundConversation(options) {
     const validated = InitiateVoiceConversationOptionsSchema.parse(options);
-    const fromNumber = this.config.phoneNumber;
+    const fromNumber = this.tacConfig.phoneNumber;
     this.logger.info(
       { to: validated.to, from: fromNumber },
       "Initiating outbound voice conversation"
     );
     try {
-      const merged = this.buildTwimlOptions(void 0, validated.twimlOptions);
-      const websocketUrl = validated.websocketUrl ?? merged.websocketUrl ?? this.resolveWebsocketUrl("initiateOutboundConversation");
-      const twiml = this.generateTwiml(websocketUrl, merged);
+      const twiml = this.twimlBuilder.build("initiateOutboundConversation", {
+        perCall: validated.twimlOptions,
+        websocketUrl: validated.websocketUrl
+      });
       const callParams = this.buildCallParams(validated.callOptions);
       this.logger.debug(
         { twiml: redactTwimlParameters(twiml), to: maskAddress(validated.to) },
         "Outbound call TwiML"
       );
-      const client = this.getTwilioClient();
-      const call = await client.calls.create({
+      const client2 = this.channel.getTwilioClientInternal();
+      const call = await client2.calls.create({
         to: validated.to,
         from: fromNumber,
         twiml,
@@ -5580,7 +6127,7 @@ var VoiceChannel = class _VoiceChannel extends BaseChannel {
         { err: error, to: maskAddress(validated.to) },
         "Failed to initiate outbound call"
       );
-      this.handleError(error instanceof Error ? error : new Error(String(error)), {
+      this.channel.handleErrorInternal(error instanceof Error ? error : new Error(String(error)), {
         to: validated.to
       });
       throw error;
@@ -5593,412 +6140,2642 @@ var VoiceChannel = 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
    */
-  async handleConversationRelayCallback(payload) {
+  async handleTwilioProviderCallback(rawPayload) {
+    const parsed = ConversationRelayCallbackPayloadSchema.safeParse(rawPayload);
+    if (!parsed.success) {
+      this.logger.warn(
+        { errors: parsed.error.issues },
+        "Invalid ConversationRelay callback payload"
+      );
+      return { status: 400, content: "Invalid payload", contentType: "text/plain" };
+    }
+    const payload = parsed.data;
     this.logger.debug(
       { call_sid: payload.CallSid, call_status: payload.CallStatus },
       "ConversationRelay callback received"
     );
-    if (payload.AccountSid !== this.config.accountSid) {
+    if (payload.AccountSid !== this.tacConfig.accountSid) {
       this.logger.warn(
-        { expected: this.config.accountSid, received: payload.AccountSid },
+        { expected: this.tacConfig.accountSid, received: payload.AccountSid },
         "ConversationRelay callback AccountSid mismatch, ignoring"
       );
       return { status: 403, content: "Forbidden", contentType: "text/plain" };
     }
-    if (payload.CallStatus === "completed" && !this.tac.isOrchestratorEnabled()) {
+    if (payload.CallStatus === "completed" && !this.channel.isOrchestratorEnabledInternal()) {
       const conversationId = this.callSidToConversationId.get(payload.CallSid);
       if (conversationId) {
         this.callSidToConversationId.delete(payload.CallSid);
-        await this.endConversation(conversationId);
+        await this.channel.endConversationInternal(conversationId);
       }
     }
     return { status: 200, content: "OK", contentType: "text/plain" };
   }
   // =========================================================================
-  // Call Event Handling (status callback, async AMD, recording)
+  // ConversationRelay TwiML Generation
   // =========================================================================
   /**
-   * 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
    */
-  callEventAccountOk(form) {
-    const accountSid = form["AccountSid"];
-    if (accountSid && accountSid !== this.config.accountSid) {
-      this.logger.warn(
-        { expected: this.config.accountSid, received: accountSid },
-        "Call event AccountSid mismatch, ignoring"
-      );
-      return false;
+  connectConversationRelay(config, options) {
+    const validationResult = ConversationRelayConfigSchema.safeParse(config);
+    if (!validationResult.success) {
+      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new Error(`Invalid ConversationRelay configuration: ${errorMessage}`);
     }
-    return true;
-  }
-  /**
-   * 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.
-   */
-  async dispatchCallEvent(kind, form, handler, parse, logFields) {
-    const ok = { status: 200, content: "OK", contentType: "text/plain" };
-    if (!handler || !this.callEventAccountOk(form)) {
-      return ok;
+    const validatedConfig = validationResult.data;
+    const { languages, ...conversationRelayAttributes } = validatedConfig;
+    const filteredConfig = filterUnsetValues(conversationRelayAttributes);
+    const response = new VoiceResponse();
+    const connect = response.connect(options?.actionUrl ? { action: options.actionUrl } : {});
+    const relay = connect.conversationRelay(filteredConfig);
+    if (languages && languages.length > 0) {
+      for (const lang of languages) {
+        const filteredLang = filterUnsetValues(lang);
+        relay.language(filteredLang);
+      }
     }
-    try {
-      const event = parse(form);
-      this.logger.debug(logFields(event), `Call ${kind} event received`);
-      await handler(event);
-    } catch (error) {
-      this.logger.error({ err: error, kind }, "Failed to process call event callback");
-      return { status: 400, content: "Bad Request", contentType: "text/plain" };
+    if (options?.parameters) {
+      for (const [name, value] of Object.entries(options.parameters)) {
+        relay.parameter({ name, value: String(value) });
+      }
     }
-    return ok;
+    return response.toString();
   }
   /**
-   * Handle a Twilio `statusCallback` webhook.
+   * Drop this provider's ConversationRelay transport state on channel shutdown.
    *
-   * 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.
+   * Note: WebSocket connections are managed by the server and closed there.
+   * This method only cleans up internal provider state.
    */
-  async handleCallStatusEvent(form) {
-    return this.dispatchCallEvent(
-      "status",
-      form,
-      this.onCallStatusHandler,
-      callStatusEventFromForm,
-      (event) => ({ call_sid: event.callSid, call_status: event.callStatus })
-    );
+  shutdown() {
+    super.shutdown();
+    this.streamTasks.clear();
+    this.webSocketConnections.clear();
+    this.promptQueues.clear();
+    this.initializationRetries.clear();
+    this.callSidToConversationId.clear();
+  }
+};
+
+// packages/core/src/channels/voice/conversation-relay/config.ts
+var ConversationRelayProviderConfig = class extends VoiceProviderConfig {
+  /**
+   * Static `VoiceTwiMLOptionsConversationRelay` for the TwiML inside `<ConversationRelay>`, applied
+   * to every call (inbound and outbound).
+   */
+  defaultTwimlOptions;
+  /** Static {@link CallOptions} applied to every outbound call. */
+  defaultCallOptions;
+  constructor(options) {
+    super(options);
+    if (options?.defaultTwimlOptions !== void 0) {
+      this.defaultTwimlOptions = options.defaultTwimlOptions;
+    }
+    if (options?.defaultCallOptions !== void 0) {
+      this.defaultCallOptions = options.defaultCallOptions;
+    }
+  }
+  createProvider(channel, tacConfig) {
+    return new ConversationRelayProvider(channel, tacConfig, this);
+  }
+};
+
+// packages/core/src/channels/voice/channel.ts
+var VoiceChannel = class _VoiceChannel extends BaseChannel {
+  provider;
+  voiceCallbacks;
+  twilioClient;
+  onInboundCallTwimlHandler;
+  onCallStatusHandler;
+  onAmdHandler;
+  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.
+   */
+  constructor(tac, options) {
+    super(tac, _VoiceChannel.toBaseOptions(options));
+    this.voiceCallbacks = {};
+    this.provider = _VoiceChannel.toProviderConfig(options).createProvider(this, this.config);
+  }
+  /**
+   * 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.
+   */
+  static toBaseOptions(options) {
+    if (options === void 0) {
+      return void 0;
+    }
+    if (options instanceof VoiceProviderConfig) {
+      return { ...options.channelOptions, memoryMode: options.memoryMode };
+    }
+    return options;
+  }
+  /**
+   * Resolve the provider config: an explicit {@link VoiceProviderConfig} as-is,
+   * anything else wrapped as a {@link ConversationRelayProviderConfig}.
+   */
+  static toProviderConfig(options) {
+    return options instanceof VoiceProviderConfig ? options : new ConversationRelayProviderConfig(options);
+  }
+  /**
+   * 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 VoiceTwiMLOptionsConversationRelay}. 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) {
+    this.onInboundCallTwimlHandler = callback;
+  }
+  /**
+   * Register a handler for Twilio `statusCallback` webhooks.
+   *
+   * This is the Calls-API status callback (call disposition), not the
+   * ConversationRelay session callback — see
+   * {@link handleTwilioProviderCallback}.
+   *
+   * 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) {
+    this.onCallStatusHandler = callback;
+  }
+  /**
+   * 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) {
+    this.onAmdHandler = callback;
+  }
+  /**
+   * 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) {
+    this.onRecordingHandler = callback;
+  }
+  /**
+   * Register a handler for DTMF keypresses, called once per key in order.
+   *
+   * 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);
+   * });
+   * ```
+   */
+  onDtmf(callback) {
+    this.voiceCallbacks.onDtmf = callback;
+  }
+  // =========================================================================
+  // Provider-facing surface
+  //
+  // `BaseChannel`'s state is `protected`, and a `VoiceProvider` is not a
+  // subclass of `VoiceChannel`, so relocated transport logic genuinely cannot
+  // reach it. These forwarders open exactly what a provider needs and nothing
+  // more; they are `@internal` and are not exported from the package root.
+  // =========================================================================
+  /**
+   * 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.
+   *
+   * @internal
+   */
+  getCallEventHandlers() {
+    return {
+      status: this.onCallStatusHandler,
+      amd: this.onAmdHandler,
+      recording: this.onRecordingHandler
+    };
+  }
+  /**
+   * This channel's `TACConfig`, for a `VoiceProvider` deriving default URLs.
+   * `BaseChannel.config` is `protected`, and a provider is not a subclass.
+   *
+   * @internal
+   */
+  getTacConfig() {
+    return this.config;
+  }
+  /**
+   * This channel's logger, so a provider's relocated logic keeps logging under
+   * the same name it did when it lived on `VoiceChannel`.
+   *
+   * @internal
+   */
+  getLoggerInternal() {
+    return this.logger;
+  }
+  /**
+   * The Conversation Orchestrator client, or `null` in ConversationRelay-only
+   * mode.
+   *
+   * @internal
+   */
+  getConversationClientInternal() {
+    return this.conversationClient;
+  }
+  /**
+   * The lazily built Twilio REST client, for a provider placing outbound calls.
+   *
+   * @internal
+   */
+  getTwilioClientInternal() {
+    return this.getTwilioClient();
+  }
+  /**
+   * Whether Conversation Orchestrator is configured. Providers branch on this
+   * to decide who owns conversation cleanup.
+   *
+   * @internal
+   */
+  isOrchestratorEnabledInternal() {
+    return this.tac.isOrchestratorEnabled();
+  }
+  /**
+   * Voice event callbacks registered via {@link on}, for a provider to fire.
+   *
+   * @internal
+   */
+  getVoiceCallbacks() {
+    return this.voiceCallbacks;
+  }
+  /**
+   * The inbound-TwiML customizer registered via {@link onInboundCallTwiml}, for
+   * a provider building the inbound response.
+   *
+   * @internal
+   */
+  getInboundCallTwimlHandler() {
+    return this.onInboundCallTwimlHandler;
+  }
+  /**
+   * Start tracking a conversation session. Forwards to
+   * `BaseChannel.startConversation`.
+   *
+   * @internal
+   */
+  startConversationInternal(conversationId, profileId) {
+    return this.startConversation(conversationId, profileId);
+  }
+  /**
+   * End a tracked conversation session. Forwards to
+   * `BaseChannel.endConversation`.
+   *
+   * @internal
+   */
+  endConversationInternal(conversationId) {
+    return this.endConversation(conversationId);
+  }
+  /**
+   * Retrieve memory when `memoryMode` calls for it. Forwards to
+   * `BaseChannel.retrieveMemoryIfEnabled`.
+   *
+   * @internal
+   */
+  retrieveMemoryInternal(session, query) {
+    return this.retrieveMemoryIfEnabled(session, query);
+  }
+  /**
+   * Report an error through the channel's `onError` callback and logger.
+   * Forwards to `BaseChannel.handleError`.
+   *
+   * @internal
+   */
+  handleErrorInternal(error, context) {
+    this.handleError(error, context);
+  }
+  getTwilioClient() {
+    if (!this.twilioClient) {
+      this.twilioClient = twilio(this.config.apiKey, this.config.apiSecret, {
+        accountSid: this.config.accountSid
+      });
+    }
+    return this.twilioClient;
+  }
+  get channelType() {
+    return "voice";
+  }
+  /**
+   * Register event callbacks (override for Voice-specific events)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Generic event callback needs to accept any args
+  on(event, callback) {
+    switch (event) {
+      case "setup":
+        this.voiceCallbacks.onSetup = callback;
+        break;
+      case "prompt":
+        this.voiceCallbacks.onPrompt = callback;
+        break;
+      case "interrupt":
+        this.voiceCallbacks.onInterrupt = callback;
+        break;
+      case "dtmf":
+        this.voiceCallbacks.onDtmf = callback;
+        break;
+      case "webSocketConnected":
+        this.voiceCallbacks.onWebSocketConnected = callback;
+        break;
+      case "webSocketDisconnected":
+        this.voiceCallbacks.onWebSocketDisconnected = callback;
+        break;
+      default:
+        super.on(event, callback);
+        break;
+    }
+  }
+  /**
+   * 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
+   */
+  async processWebhook(payload, idempotencyToken) {
+    try {
+      const result = this.preprocessWebhook(payload, idempotencyToken);
+      if (!result) {
+        return;
+      }
+      const { webhookData, eventType, conversationId } = result;
+      switch (eventType) {
+        case "CONVERSATION_UPDATED":
+          this.logger.debug(
+            { conversation_id: conversationId, status: webhookData.data?.status },
+            "Handling CONVERSATION_UPDATED"
+          );
+          await this.handleConversationUpdated(webhookData);
+          break;
+        default:
+          this.logger.debug(
+            {
+              event_type: eventType,
+              raw_event_type: webhookData.eventType,
+              conversation_id: conversationId
+            },
+            "Unhandled event type - this event will be ignored"
+          );
+      }
+      this.logger.debug({ event_type: eventType }, "Webhook processing completed");
+    } catch (error) {
+      if (idempotencyToken) {
+        this.removeWebhookToken(idempotencyToken);
+      }
+      this.handleError(error instanceof Error ? error : new Error(String(error)), { payload });
+    }
+  }
+  /**
+   * Handle conversation updated event
+   */
+  async handleConversationUpdated(payload) {
+    const conversationId = this.extractConversationId(payload);
+    if (!conversationId) {
+      throw new Error("Missing conversation ID in conversation.updated event");
+    }
+    if (payload.data?.status === "CLOSED") {
+      this.logger.debug(
+        { conversation_id: conversationId, status: payload.data.status },
+        "Conversation closed, cleaning up"
+      );
+      await this.endConversation(conversationId);
+    } else if (payload.data?.status === "INACTIVE") {
+      this.invalidateCachedMemory(conversationId);
+    }
+  }
+  /**
+   * Get active WebSocket connection for a conversation
+   */
+  getWebsocket(conversationId) {
+    return this.provider.getWebSocket(conversationId);
+  }
+  /**
+   * 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) {
+    trackEvent("Websocket Connected", {
+      account_sid: this.config.accountSid,
+      channel: "voice",
+      provider: this.provider.providerId,
+      orchestrator_enabled: this.config.isOrchestratorEnabled()
+    });
+    const result = this.provider.handleWebSocket(ws);
+    if (result instanceof Promise) {
+      void result.catch((err) => {
+        this.logger.error({ err }, "WebSocket handler error");
+      });
+    }
+  }
+  /**
+   * Send voice response via WebSocket
+   */
+  async sendResponse(conversationId, message, metadata) {
+    await this.provider.sendResponse(conversationId, message, metadata);
+    trackEvent("Response Sent", {
+      account_sid: this.config.accountSid,
+      channel: "voice",
+      conversation_id: conversationId,
+      response_type: "full",
+      provider: this.provider.providerId,
+      orchestrator_enabled: this.config.isOrchestratorEnabled()
+    });
+  }
+  /**
+   * 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.
+   */
+  async sendStreamingResponse(conversationId, stream, options) {
+    const fullResponse = await this.provider.sendStreamingResponse(conversationId, stream, options);
+    if (fullResponse) {
+      trackEvent("Response Sent", {
+        account_sid: this.config.accountSid,
+        channel: "voice",
+        conversation_id: conversationId,
+        response_type: "streaming",
+        provider: this.provider.providerId,
+        orchestrator_enabled: this.config.isOrchestratorEnabled()
+      });
+    }
+    return fullResponse;
+  }
+  // =========================================================================
+  // Incoming Call Handling
+  // =========================================================================
+  /**
+   * 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.
+   */
+  async handleIncomingCall(twimlRequest, options) {
+    return this.provider.handleIncomingCall(twimlRequest, options);
+  }
+  // =========================================================================
+  // Outbound Call Handling
+  // =========================================================================
+  /**
+   * 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`.
+   */
+  async initiateOutboundConversation(options) {
+    return this.provider.initiateOutboundConversation(options);
+  }
+  // =========================================================================
+  // Provider Callback Handling
+  // =========================================================================
+  /**
+   * 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
+   */
+  async handleTwilioProviderCallback(payload) {
+    return this.provider.handleTwilioProviderCallback(payload);
+  }
+  /**
+   * @deprecated Use {@link VoiceChannel.handleTwilioProviderCallback} instead.
+   */
+  async handleConversationRelayCallback(payload) {
+    warnDeprecated("handleConversationRelayCallback", "handleTwilioProviderCallback");
+    return this.handleTwilioProviderCallback(payload);
+  }
+  // =========================================================================
+  // Call Event Handling (status callback, async AMD, recording)
+  // =========================================================================
+  /**
+   * 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.
+   */
+  callEventAccountOk(form) {
+    const accountSid = form["AccountSid"];
+    if (accountSid && accountSid !== this.config.accountSid) {
+      this.logger.warn(
+        { expected: this.config.accountSid, received: accountSid },
+        "Call event AccountSid mismatch, ignoring"
+      );
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 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.
+   */
+  async dispatchCallEvent(kind, form, handler, parse, logFields) {
+    const ok = { status: 200, content: "OK", contentType: "text/plain" };
+    if (!handler || !this.callEventAccountOk(form)) {
+      return ok;
+    }
+    try {
+      const event = parse(form);
+      this.logger.debug(logFields(event), `Call ${kind} event received`);
+      await handler(event);
+    } catch (error) {
+      this.logger.error({ err: error, kind }, "Failed to process call event callback");
+      return { status: 400, content: "Bad Request", contentType: "text/plain" };
+    }
+    return ok;
+  }
+  /**
+   * 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.
+   */
+  async handleCallStatusEvent(form) {
+    return this.dispatchCallEvent(
+      "status",
+      form,
+      this.onCallStatusHandler,
+      callStatusEventFromForm,
+      (event) => ({ call_sid: event.callSid, call_status: event.callStatus })
+    );
   }
   /**
    * 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.
+   * 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.
+   */
+  async handleAmdEvent(form) {
+    return this.dispatchCallEvent("amd", form, this.onAmdHandler, amdEventFromForm, (event) => ({
+      call_sid: event.callSid,
+      answered_by: event.answeredBy
+    }));
+  }
+  /**
+   * 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.
+   */
+  async handleRecordingEvent(form) {
+    return this.dispatchCallEvent(
+      "recording",
+      form,
+      this.onRecordingHandler,
+      recordingEventFromForm,
+      (event) => ({ call_sid: event.callSid, recording_status: event.recordingStatus })
+    );
+  }
+  /**
+   * 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.
+   */
+  async endCall(callSid) {
+    const client2 = this.getTwilioClient();
+    let hungUp = true;
+    try {
+      await client2.calls(callSid).update({ status: "completed" });
+    } catch (error) {
+      hungUp = false;
+      this.logger.error({ err: error, call_sid: callSid }, "Failed to hang up call");
+    }
+    const session = this.getConversationSessionByCallSid(callSid);
+    if (session) {
+      await this.endConversation(session.conversationId);
+    }
+    return hungUp;
+  }
+  /**
+   * 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) {
+    for (const session of this.activeConversations.values()) {
+      if (session.callSid === callSid) {
+        return session;
+      }
+    }
+    return void 0;
+  }
+  // =========================================================================
+  // Stream Task Management
+  //
+  // Stream tasks are ConversationRelay's text-token machinery and live on
+  // `ConversationRelayProvider`, alongside the transport that consumes their
+  // AbortSignal. These forwarders keep the channel-level API intact.
+  // =========================================================================
+  /**
+   * 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.
+   */
+  requireConversationRelayProvider(capability) {
+    if (!(this.provider instanceof ConversationRelayProvider)) {
+      throw new Error(`${this.provider.constructor.name} does not support ${capability}.`);
+    }
+    return this.provider;
+  }
+  /**
+   * Start tracking a streaming task for a conversation
+   *
+   * @param conversationId - The conversation ID
+   * @returns The stream task with its AbortController
+   */
+  startStreamTask(conversationId) {
+    return this.requireConversationRelayProvider("stream tasks").startStreamTask(conversationId);
+  }
+  /**
+   * Cancel an active streaming task
+   *
+   * @param conversationId - The conversation ID
+   * @returns true if a task was cancelled, false otherwise
+   */
+  cancelStreamTask(conversationId) {
+    return this.requireConversationRelayProvider("stream tasks").cancelStreamTask(conversationId);
+  }
+  /**
+   * Complete a streaming task (remove from tracking)
+   *
+   * @param conversationId - The conversation ID
+   */
+  completeStreamTask(conversationId) {
+    this.requireConversationRelayProvider("stream tasks").completeStreamTask(conversationId);
+  }
+  /**
+   * Check if a stream task is active
+   *
+   * @param conversationId - The conversation ID
+   * @returns true if an active task exists
+   */
+  hasActiveStreamTask(conversationId) {
+    return this.requireConversationRelayProvider("stream tasks").hasActiveStreamTask(
+      conversationId
+    );
+  }
+  // =========================================================================
+  // ConversationRelay TwiML Generation
+  // =========================================================================
+  /**
+   * 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, options) {
+    return this.requireConversationRelayProvider(
+      "ConversationRelay TwiML generation"
+    ).connectConversationRelay(config, options);
+  }
+  /**
+   * 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() {
+    this.provider.shutdown();
+    super.shutdown();
+  }
+};
+function generateStreamTwiml(websocketUrl, options) {
+  const resolved = websocketUrl ?? options?.websocketUrl;
+  if (!resolved || !resolved.trim()) {
+    throw new Error(
+      "generateStreamTwiml requires a WebSocket URL \u2014 pass it positionally or set options.websocketUrl."
+    );
+  }
+  const response = new VoiceResponse();
+  const connectAttrs = {};
+  if (options?.actionUrl) {
+    connectAttrs.action = options.actionUrl;
+  }
+  if (options?.actionMethod) {
+    connectAttrs.method = options.actionMethod;
+  }
+  const connect = response.connect(connectAttrs);
+  const streamAttrs = { url: resolved };
+  if (options?.name) {
+    streamAttrs.name = options.name;
+  }
+  if (options?.statusCallback) {
+    streamAttrs.statusCallback = options.statusCallback;
+  }
+  if (options?.statusCallbackMethod) {
+    streamAttrs.statusCallbackMethod = options.statusCallbackMethod;
+  }
+  const stream = connect.stream(streamAttrs);
+  if (options?.customParameters) {
+    for (const [name, value] of Object.entries(options.customParameters)) {
+      if (value !== null && value !== void 0) {
+        stream.parameter({ name, value: stringifyParameterValue(value) });
+      }
+    }
+  }
+  return response.toString();
+}
+var TwiMLBuilderMediaStreams = class extends TwiMLBuilderBase {
+  /**
+   * 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, options) {
+    const merged = this.buildTwimlOptions(options?.host, options?.perCall);
+    const resolvedWebsocketUrl = options?.websocketUrl || merged.websocketUrl || this.defaultWebsocketUrl();
+    if (!resolvedWebsocketUrl) {
+      throw this.missingWebsocketUrlError(caller);
+    }
+    return generateStreamTwiml(resolvedWebsocketUrl, merged);
+  }
+  /**
+   * 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.
+   */
+  buildTwimlOptions(host, perCall) {
+    const merged = {};
+    if (host) {
+      this.overlayFields(merged, host);
+    }
+    if (this.channelConfig.defaultTwimlOptions) {
+      this.overlayFields(merged, this.channelConfig.defaultTwimlOptions);
+    }
+    if (perCall) {
+      this.overlayFields(merged, perCall);
+    }
+    return merged;
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/config.ts
+var MediaStreamsProviderConfig = class extends VoiceProviderConfig {
+  /**
+   * Static `VoiceTwiMLOptionsMediaStreams` applied to every inbound call.
+   * Per-call customization is registered via
+   * `VoiceChannel.onInboundCallTwiml(...)`, which takes precedence over this.
+   */
+  defaultTwimlOptions;
+  constructor(options) {
+    super(options);
+    if (options?.defaultTwimlOptions !== void 0) {
+      this.defaultTwimlOptions = options.defaultTwimlOptions;
+    }
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/shared/config.ts
+var MediaStreamsOpenAIProviderConfig = class extends MediaStreamsProviderConfig {
+  /** OpenAI API key. Defaults to the `OPENAI_API_KEY` environment variable. */
+  openaiApiKey;
+  /**
+   * 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.
+   */
+  // See the `never` note on `MediaStreamsOpenAIProviderConfigOptions.tools`.
+  tools;
+  /**
+   * 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.
+   */
+  defaultSessionConfig;
+  /**
+   * 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.
+   */
+  onInboundCallSessionConfig;
+  constructor(options) {
+    super(options);
+    this.openaiApiKey = options?.openaiApiKey ?? process.env.OPENAI_API_KEY ?? "";
+    this.tools = options?.tools ?? [];
+    if (options?.defaultSessionConfig !== void 0) {
+      this.defaultSessionConfig = options.defaultSessionConfig;
+    }
+    if (options?.onInboundCallSessionConfig !== void 0) {
+      this.onInboundCallSessionConfig = options.onInboundCallSessionConfig;
+    }
+    if (!this.openaiApiKey) {
+      throw new Error(
+        `openaiApiKey is required. Set the OPENAI_API_KEY environment variable or provide openaiApiKey in ${this.constructor.name}.`
+      );
+    }
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/shared/state.ts
+var MediaStreamsOpenAICallState = class {
+  twilioWs = null;
+  modelWs = 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 = null;
+};
+var OPENAI_USER_AGENT = `twilio-agent-connect/TypeScript ${package_default.version}`;
+var INBOUND_SESSION_CONFIG_TTL_MS = 12e4;
+function describeIssues(issues) {
+  return issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join(", ");
+}
+var MediaStreamsOpenAIProvider = class extends VoiceProvider {
+  /**
+   * The owning channel's logger, so this provider logs under the same name the
+   * rest of the voice channel does.
+   */
+  logger;
+  /** Executable tools from the config, looked up by the name the model sends. */
+  toolsByName;
+  /** Per-call transport state, keyed by conversation id. */
+  calls;
+  config;
+  tacConfig;
+  twimlBuilder;
+  /**
+   * 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.
+   */
+  pendingSessionConfigs;
+  /**
+   * 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.
+   */
+  pendingInboundExpiries;
+  constructor(channel, tacConfig, config) {
+    super(channel);
+    this.logger = channel.getLoggerInternal();
+    this.config = config;
+    this.tacConfig = tacConfig;
+    this.toolsByName = new Map(config.tools.map((tool) => [tool.name, tool]));
+    this.calls = /* @__PURE__ */ new Map();
+    this.twimlBuilder = new TwiMLBuilderMediaStreams(tacConfig, config, this.logger);
+    this.pendingSessionConfigs = /* @__PURE__ */ new Map();
+    this.pendingInboundExpiries = /* @__PURE__ */ new Map();
+  }
+  /** The Twilio-facing WebSocket for a conversation, if one is tracked. */
+  getWebSocket(conversationId) {
+    return this.calls.get(conversationId)?.twilioWs ?? 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, headers) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url, { headers });
+      const onOpen = () => {
+        ws.off("error", onError);
+        ws.on("error", () => {
+        });
+        resolve(ws);
+      };
+      const onError = (error) => {
+        ws.off("open", onOpen);
+        reject(error);
+      };
+      ws.once("open", onOpen);
+      ws.once("error", onError);
+    });
+  }
+  /**
+   * 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) {
+    const transcript = this.channel.getConversationSession(conversationId)?.metadata.transcript;
+    return Array.isArray(transcript) ? [...transcript] : [];
+  }
+  /**
+   * The session config stashed for `key` — a call SID for inbound calls, a
+   * token for outbound ones.
+   *
+   * @internal
+   */
+  peekPendingSessionConfig(key) {
+    return this.pendingSessionConfigs.get(key);
+  }
+  /**
+   * How many session config overrides are waiting for their call.
+   *
+   * @internal
+   */
+  pendingSessionConfigCount() {
+    return this.pendingSessionConfigs.size;
+  }
+  /**
+   * 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.
+   */
+  armInboundConfigExpiry(callSid) {
+    this.cancelInboundConfigExpiry(callSid);
+    const timer = setTimeout(() => {
+      this.pendingInboundExpiries.delete(callSid);
+      this.pendingSessionConfigs.delete(callSid);
+    }, INBOUND_SESSION_CONFIG_TTL_MS);
+    timer.unref();
+    this.pendingInboundExpiries.set(callSid, timer);
+  }
+  /**
+   * 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
+   */
+  cancelInboundConfigExpiry(callSid) {
+    const timer = this.pendingInboundExpiries.get(callSid);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.pendingInboundExpiries.delete(callSid);
+    }
+  }
+  /**
+   * The executable tool the model would run for `name`, if the config supplied
+   * one.
+   *
+   * @internal
+   */
+  peekTool(name) {
+    return this.toolsByName.get(name);
+  }
+  // =========================================================================
+  // Inbound Call Handling
+  // =========================================================================
+  /**
+   * 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.
+   */
+  async handleIncomingCall(twimlRequest, options) {
+    const host = this.narrowTwimlOptions(
+      options?.hostTwimlOptions,
+      "handleIncomingCall",
+      "options.hostTwimlOptions"
+    );
+    const onInboundCallTwimlHandler = this.channel.getInboundCallTwimlHandler();
+    let customized;
+    if (onInboundCallTwimlHandler && twimlRequest) {
+      customized = this.narrowTwimlOptions(
+        await onInboundCallTwimlHandler(twimlRequest),
+        "handleIncomingCall",
+        "the onInboundCallTwiml customizer output"
+      );
+    }
+    const twiml = this.twimlBuilder.build("handleIncomingCall", { host, perCall: customized });
+    if (this.config.onInboundCallSessionConfig && twimlRequest?.callSid) {
+      const sessionConfig = await this.config.onInboundCallSessionConfig(twimlRequest);
+      if (sessionConfig !== null) {
+        this.pendingSessionConfigs.set(twimlRequest.callSid, sessionConfig);
+        this.armInboundConfigExpiry(twimlRequest.callSid);
+      }
+    }
+    return twiml;
+  }
+  /**
+   * 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.
+   */
+  narrowTwimlOptions(value, caller, label) {
+    if (value === void 0) {
+      return void 0;
+    }
+    const parsed = VoiceTwiMLOptionsMediaStreamsSchema.safeParse(value);
+    if (!parsed.success) {
+      throw new TypeError(
+        `MediaStreamsOpenAIProvider.${caller} requires ${label} to be a VoiceTwiMLOptionsMediaStreams: ${describeIssues(parsed.error.issues)}`
+      );
+    }
+    return parsed.data;
+  }
+  // =========================================================================
+  // Audio Bridge
+  // =========================================================================
+  /**
+   * 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
+   */
+  async handleModelMessage(conversationId, raw) {
+    try {
+      const event = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+      const session = this.channel.getConversationSession(conversationId);
+      if (session === void 0) {
+        return;
+      }
+      await this.dispatchModelEvent(conversationId, session, event);
+    } catch (err) {
+      this.logger.error({ err, conversation_id: conversationId }, "Error handling model event");
+    }
+  }
+  /**
+   * 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
+   */
+  async runToolCall(conversationId, name, argumentsJson) {
+    this.logger.debug({ conversation_id: conversationId, tool_name: name }, "Tool call");
+    const tool = this.toolsByName.get(name);
+    if (tool === void 0) {
+      return { error: `Unknown tool '${name}'` };
+    }
+    try {
+      const parsedArguments = JSON.parse(
+        typeof argumentsJson === "string" && argumentsJson ? argumentsJson : "{}"
+      );
+      const output = await tool.implementation(parsedArguments);
+      this.logger.debug({ conversation_id: conversationId, tool_name: name }, "Tool result");
+      return output;
+    } catch (err) {
+      this.logger.error({ err, conversation_id: conversationId, tool_name: name }, "Tool failed");
+      return { error: `Tool '${name}' failed to execute.` };
+    }
+  }
+  /** Write one event to this call's model socket, if it still has one. */
+  modelSend(conversationId, payload) {
+    const modelWs = this.calls.get(conversationId)?.modelWs;
+    if (!modelWs) {
+      return;
+    }
+    try {
+      modelWs.send(JSON.stringify(payload));
+    } catch (err) {
+      this.logger.debug({ err, conversation_id: conversationId }, "Failed to send to model");
+    }
+  }
+  /** Write one message to this call's Twilio socket, if it still has one. */
+  twilioSend(conversationId, payload) {
+    const twilioWs = this.calls.get(conversationId)?.twilioWs;
+    if (!twilioWs) {
+      return;
+    }
+    try {
+      twilioWs.send(JSON.stringify(payload));
+    } catch (err) {
+      this.logger.debug({ err, conversation_id: conversationId }, "Failed to send to Twilio");
+    }
+  }
+  /**
+   * Always throws: the model streams its reply as audio straight to Twilio, so
+   * this transport has no text response to send.
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await -- Rejects without awaiting, but stays `async` so callers always get a Promise
+  async sendResponse(_conversationId, _message, _metadata) {
+    throw new Error(
+      `${this.constructor.name} produces audio via the model; it has no text sendResponse.`
+    );
+  }
+  /**
+   * 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() {
+    super.shutdown();
+    for (const timer of this.pendingInboundExpiries.values()) {
+      clearTimeout(timer);
+    }
+    this.pendingInboundExpiries.clear();
+    this.calls.clear();
+    this.pendingSessionConfigs.clear();
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/openai-realtime/state.ts
+var BargeInState = class {
+  lastAssistantItem = null;
+  currentItemAudioMs = 0;
+  mutedItemId = null;
+  responseActive = false;
+};
+var CallState = class 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.resolve();
+  bargeIn = new BargeInState();
+};
+
+// packages/core/src/channels/voice/media-streams/openai-realtime/provider.ts
+var SESSION_CONFIG_TOKEN_PARAM = "_tac_session_config_token";
+var TWILIO_AUDIO_FORMAT_FOR_REALTIME = { type: "audio/pcmu" };
+var PCMU_BYTES_PER_MS = 8;
+function isTwilioMediaStreamAudioFormat(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const expected = TWILIO_AUDIO_FORMAT_FOR_REALTIME;
+  const actual = value;
+  const keys = Object.keys(actual);
+  return keys.length === Object.keys(expected).length && keys.every((key) => actual[key] === expected[key]);
+}
+var OpenAIRealtimeProvider = class extends MediaStreamsOpenAIProvider {
+  /** @internal */
+  get providerId() {
+    return "openai_realtime";
+  }
+  constructor(channel, tacConfig, config) {
+    super(channel, tacConfig, config);
+  }
+  get channelName() {
+    return "VOICE_MEDIA_STREAM_OPENAI_REALTIME";
+  }
+  // =========================================================================
+  // Outbound Call Handling
+  // =========================================================================
+  /**
+   * 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.
+   */
+  async initiateOutboundConversation(options) {
+    const parsedOptions = InitiateVoiceConversationOptionsOpenAIRealtimeSchema.safeParse(options);
+    if (!parsedOptions.success) {
+      throw new TypeError(
+        `OpenAIRealtimeProvider.initiateOutboundConversation requires options to be an InitiateVoiceConversationOptionsOpenAIRealtime: ${describeIssues(
+          parsedOptions.error.issues
+        )}`
+      );
+    }
+    const validated = parsedOptions.data;
+    let twimlOptions = validated.twimlOptions;
+    const sessionConfig = validated.sessionConfig ?? null;
+    let sessionConfigToken = null;
+    if (sessionConfig !== null) {
+      sessionConfigToken = crypto.randomUUID().replace(/-/g, "");
+      twimlOptions = {
+        ...twimlOptions,
+        customParameters: {
+          ...twimlOptions?.customParameters,
+          [SESSION_CONFIG_TOKEN_PARAM]: sessionConfigToken
+        }
+      };
+    }
+    const fromNumber = this.tacConfig.phoneNumber;
+    this.logger.info(
+      { to: maskPhone(validated.to), from: maskPhone(fromNumber) },
+      "Initiating outbound voice conversation"
+    );
+    const twiml = this.twimlBuilder.build("initiateOutboundConversation", {
+      perCall: twimlOptions,
+      websocketUrl: validated.websocketUrl
+    });
+    const callParams = this.applyCallEventCallbacks(
+      validated.callOptions ? callOptionsToCreateParams(validated.callOptions) : {}
+    );
+    if (sessionConfigToken !== null && sessionConfig !== null) {
+      this.pendingSessionConfigs.set(sessionConfigToken, sessionConfig);
+    }
+    try {
+      this.logger.debug(
+        { twiml: redactTwimlParameters(twiml), to: maskPhone(validated.to) },
+        "Outbound call TwiML"
+      );
+      const client2 = this.channel.getTwilioClientInternal();
+      const call = await client2.calls.create({
+        to: validated.to,
+        from: fromNumber,
+        twiml,
+        ...callParams
+      });
+      this.logger.info(
+        { call_sid: call.sid, to: maskPhone(validated.to) },
+        "Outbound voice call placed"
+      );
+      return { callSid: call.sid };
+    } catch (error) {
+      if (sessionConfigToken !== null) {
+        this.pendingSessionConfigs.delete(sessionConfigToken);
+      }
+      this.logger.error(
+        { err: error, to: maskPhone(validated.to) },
+        "Failed to initiate outbound call"
+      );
+      throw error;
+    }
+  }
+  // =========================================================================
+  // Audio Bridge
+  // =========================================================================
+  /**
+   * 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) {
+    let conversationId = null;
+    ws.on("message", (data) => {
+      void (async () => {
+        const message = JSON.parse(data.toString());
+        const event = typeof message.event === "string" ? message.event : "";
+        if (event === "start") {
+          try {
+            const registered = this.registerCall(message.start, ws);
+            conversationId = registered.conversationId;
+            const connecting = this.connectModel(registered.conversationId);
+            registered.call.modelReady = connecting.then(
+              () => true,
+              () => false
+            );
+            await connecting;
+          } catch (err) {
+            this.logger.error(
+              { err, conversation_id: conversationId },
+              "Failed to bridge the call to OpenAI Realtime, ending the call"
+            );
+            ws.close();
+          }
+        } else if (event === "media") {
+          const media = message.media ?? {};
+          const payload = media.payload;
+          if (conversationId !== null && typeof payload === "string" && payload) {
+            const call = this.calls.get(conversationId);
+            if (call === void 0) {
+              return;
+            }
+            if (call.modelReady !== null && !await call.modelReady) {
+              return;
+            }
+            this.modelSend(conversationId, {
+              type: "input_audio_buffer.append",
+              audio: payload
+            });
+          }
+        } else if (event === "stop") {
+          this.logger.info({ conversation_id: conversationId }, "Media stream stopped");
+          if (conversationId !== null) {
+            await this.cleanupCall(conversationId);
+          }
+          ws.close();
+        }
+      })().catch((err) => {
+        this.logger.error(
+          { err, conversation_id: conversationId },
+          "Unhandled error in Media Stream message handler"
+        );
+      });
+    });
+    ws.on("close", () => {
+      this.logger.info({ conversation_id: conversationId }, "Media stream WebSocket closed");
+      if (conversationId !== null) {
+        trackEvent("Websocket Disconnected", {
+          account_sid: this.tacConfig.accountSid,
+          channel: "voice",
+          conversation_id: conversationId,
+          provider: this.providerId,
+          orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+        });
+        void this.cleanupCall(conversationId).catch((err) => {
+          this.logger.error({ err, conversation_id: conversationId }, "Call cleanup error");
+        });
+      }
+    });
+    ws.on("error", (error) => {
+      this.channel.handleErrorInternal(error, { conversationId });
+    });
+  }
+  /**
+   * 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.
+   */
+  registerCall(start, ws) {
+    const message = StreamStartMessageSchema.parse(start ?? {});
+    const conversationId = message.callSid;
+    this.cancelInboundConfigExpiry(conversationId);
+    const token = message.customParameters[SESSION_CONFIG_TOKEN_PARAM];
+    if (token !== void 0) {
+      const pending = this.pendingSessionConfigs.get(token);
+      if (pending !== void 0) {
+        this.pendingSessionConfigs.delete(token);
+        this.pendingSessionConfigs.set(conversationId, pending);
+      }
+    }
+    try {
+      const session = this.channel.startConversationInternal(conversationId);
+      session.callSid = message.callSid;
+      session.metadata.streamSid = message.streamSid;
+      session.metadata.transcript = [];
+      trackEvent("Conversation Initialized", {
+        account_sid: this.tacConfig.accountSid,
+        channel: "voice",
+        conversation_id: conversationId,
+        provider: this.providerId,
+        orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+      });
+    } catch (err) {
+      this.pendingSessionConfigs.delete(conversationId);
+      void this.channel.endConversationInternal(conversationId).catch(() => void 0);
+      throw err;
+    }
+    const call = new CallState();
+    call.twilioWs = ws;
+    this.calls.set(conversationId, call);
+    this.logger.debug(
+      { conversation_id: conversationId, media_format: message.mediaFormat },
+      "Media stream started"
+    );
+    return { conversationId, call };
+  }
+  /**
+   * Open this call's OpenAI Realtime socket and send its session config.
+   *
+   * @internal
+   */
+  async connectModel(conversationId) {
+    const sessionConfig = this.resolveSessionConfig(conversationId);
+    const modelWs = await this.openModelSocket(
+      `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(String(sessionConfig.model))}`,
+      {
+        Authorization: `Bearer ${this.config.openaiApiKey}`,
+        "User-Agent": OPENAI_USER_AGENT
+      }
+    );
+    const call = this.calls.get(conversationId);
+    if (call === void 0) {
+      modelWs.close();
+      return;
+    }
+    call.modelWs = modelWs;
+    this.attachModelHandlers(conversationId, modelWs);
+    this.logger.info({ conversation_id: conversationId }, "Connected to OpenAI Realtime");
+    this.modelSend(conversationId, { type: "session.update", session: sessionConfig });
+    if (this.config.welcomeGreetingResponse !== void 0) {
+      this.modelSend(conversationId, {
+        type: "response.create",
+        response: this.config.welcomeGreetingResponse
+      });
+    }
+  }
+  /**
+   * 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.
+   */
+  resolveSessionConfig(conversationId) {
+    const sessionConfig = this.pendingSessionConfigs.get(conversationId) ?? this.config.defaultSessionConfig;
+    this.pendingSessionConfigs.delete(conversationId);
+    if (sessionConfig === void 0) {
+      throw new Error(
+        `No sessionConfig available for call ${conversationId} \u2014 this call supplied none and defaultSessionConfig isn't set either.`
+      );
+    }
+    if (!sessionConfig.model) {
+      throw new Error(
+        `sessionConfig for call ${conversationId} must include a 'model' field \u2014 it's used as the ?model= query param when opening the OpenAI Realtime WebSocket.`
+      );
+    }
+    const audio = sessionConfig.audio ?? {};
+    for (const direction of ["input", "output"]) {
+      const format = (audio[direction] ?? {}).format;
+      if (!isTwilioMediaStreamAudioFormat(format)) {
+        throw new Error(
+          `sessionConfig for call ${conversationId} has audio.${direction}.format=${JSON.stringify(format)}, expected ${JSON.stringify(TWILIO_AUDIO_FORMAT_FOR_REALTIME)}. Twilio Media Streams is always 8kHz G.711 u-law; set audio.${direction}.format to TWILIO_AUDIO_FORMAT_FOR_REALTIME.`
+        );
+      }
+    }
+    return sessionConfig;
+  }
+  /**
+   * Wire up the model socket: dispatch its events, and tear the call down when
+   * it goes away.
    *
-   * @param form - Raw form data from the webhook request.
+   * 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.
    */
-  async handleAmdEvent(form) {
-    return this.dispatchCallEvent("amd", form, this.onAmdHandler, amdEventFromForm, (event) => ({
-      call_sid: event.callSid,
-      answered_by: event.answeredBy
-    }));
+  attachModelHandlers(conversationId, modelWs) {
+    modelWs.on("message", (raw) => {
+      const call = this.calls.get(conversationId);
+      if (call === void 0) {
+        return;
+      }
+      call.modelEvents = call.modelEvents.then(() => this.handleModelMessage(conversationId, raw)).catch((err) => {
+        this.logger.error(
+          { err, conversation_id: conversationId },
+          "Unhandled error in model message handler"
+        );
+      });
+    });
+    modelWs.on("close", () => {
+      if (this.calls.has(conversationId)) {
+        this.logger.info({ conversation_id: conversationId }, "Model connection ended");
+      }
+      this.endCallFromModel(conversationId);
+    });
+    modelWs.on("error", (error) => {
+      this.logger.error({ err: error, conversation_id: conversationId }, "Model socket error");
+      this.endCallFromModel(conversationId);
+    });
   }
   /**
-   * Handle a Twilio `recordingStatusCallback` webhook.
+   * 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.
+   */
+  endCallFromModel(conversationId) {
+    this.calls.get(conversationId)?.twilioWs?.close();
+    void this.cleanupCall(conversationId).catch((err) => {
+      this.logger.error({ err, conversation_id: conversationId }, "Call cleanup error");
+    });
+  }
+  /** Apply one parsed OpenAI Realtime event to the call. */
+  async dispatchModelEvent(conversationId, session, event) {
+    const call = this.calls.get(conversationId);
+    if (call === void 0) {
+      return;
+    }
+    const bargeIn = call.bargeIn;
+    switch (event.type) {
+      case "error": {
+        const error = event.error ?? {};
+        if (error.code === "response_cancel_not_active") {
+          this.logger.debug(
+            { conversation_id: conversationId, error },
+            "response.cancel raced response.done"
+          );
+        } else {
+          this.logger.error(
+            { conversation_id: conversationId, error },
+            "OpenAI Realtime error event"
+          );
+        }
+        break;
+      }
+      case "input_audio_buffer.speech_started": {
+        this.logger.debug({ conversation_id: conversationId }, "Caller speech detected (VAD)");
+        this.handleBargeIn(conversationId, session, call);
+        break;
+      }
+      case "response.created": {
+        bargeIn.responseActive = true;
+        break;
+      }
+      case "conversation.item.input_audio_transcription.completed": {
+        if (typeof event.transcript === "string" && event.transcript) {
+          this.appendTranscript(session, "user", event.transcript);
+        }
+        break;
+      }
+      case "response.output_item.done": {
+        const item = event.item ?? {};
+        if (item.type === "function_call" && item.status === "completed") {
+          await this.handleFunctionCall(conversationId, item);
+        }
+        break;
+      }
+      case "response.done": {
+        bargeIn.responseActive = false;
+        const response = event.response ?? {};
+        const output = Array.isArray(response.output) ? response.output : [];
+        for (const entry of output) {
+          if (entry.role !== "assistant") {
+            continue;
+          }
+          const contents = Array.isArray(entry.content) ? entry.content : [];
+          for (const content of contents) {
+            if (typeof content.transcript === "string" && content.transcript) {
+              this.appendTranscript(session, "assistant", content.transcript);
+            }
+          }
+        }
+        break;
+      }
+      case "response.output_audio.delta": {
+        const delta = event.delta;
+        if (typeof delta !== "string" || !delta) {
+          break;
+        }
+        const itemId = typeof event.item_id === "string" ? event.item_id : "";
+        if (itemId && itemId === bargeIn.mutedItemId) {
+          break;
+        }
+        if (itemId && itemId !== bargeIn.lastAssistantItem) {
+          bargeIn.lastAssistantItem = itemId;
+          bargeIn.currentItemAudioMs = 0;
+        }
+        bargeIn.currentItemAudioMs += Math.floor(
+          Buffer.from(delta, "base64").length / PCMU_BYTES_PER_MS
+        );
+        this.twilioSend(conversationId, {
+          event: "media",
+          streamSid: session.metadata.streamSid,
+          media: { payload: delta }
+        });
+        break;
+      }
+    }
+  }
+  /** Record one turn on the session's running transcript. */
+  appendTranscript(session, role, text) {
+    const existing = session.metadata.transcript;
+    const transcript = Array.isArray(existing) ? existing : [];
+    if (transcript !== existing) {
+      session.metadata.transcript = transcript;
+    }
+    transcript.push({ role, text });
+  }
+  /**
+   * 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.
    *
-   * 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.
+   * 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.
+   */
+  handleBargeIn(conversationId, session, call) {
+    const bargeIn = call.bargeIn;
+    const lastAssistantItem = bargeIn.lastAssistantItem;
+    if (lastAssistantItem === null) {
+      this.logger.debug(
+        { conversation_id: conversationId },
+        "Barge-in: no assistant item to interrupt"
+      );
+      return;
+    }
+    this.logger.debug({ conversation_id: conversationId }, "Barge-in: truncating assistant reply");
+    if (bargeIn.responseActive) {
+      this.modelSend(conversationId, { type: "response.cancel" });
+      bargeIn.responseActive = false;
+    }
+    this.modelSend(conversationId, {
+      type: "conversation.item.truncate",
+      item_id: lastAssistantItem,
+      content_index: 0,
+      // Derived from bytes actually sent for this item, so for every delta
+      // that carried an `item_id` it can never overstate the duration —
+      // `conversation.item.truncate` rejects an `audio_end_ms` past the item's
+      // real content.
+      audio_end_ms: bargeIn.currentItemAudioMs
+    });
+    this.twilioSend(conversationId, { event: "clear", streamSid: session.metadata.streamSid });
+    trackEvent("Voice Interrupt", {
+      account_sid: this.tacConfig.accountSid,
+      channel: "voice",
+      conversation_id: conversationId,
+      duration_until_interrupt_ms: bargeIn.currentItemAudioMs,
+      provider: this.providerId,
+      orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+    });
+    bargeIn.mutedItemId = lastAssistantItem;
+    bargeIn.lastAssistantItem = null;
+    bargeIn.currentItemAudioMs = 0;
+  }
+  /**
+   * Run a model-requested tool call and hand the result back.
    *
-   * @param form - Raw form data from the webhook request.
+   * 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.
    */
-  async handleRecordingEvent(form) {
-    return this.dispatchCallEvent(
-      "recording",
-      form,
-      this.onRecordingHandler,
-      recordingEventFromForm,
-      (event) => ({ call_sid: event.callSid, recording_status: event.recordingStatus })
-    );
+  async handleFunctionCall(conversationId, item) {
+    const callId = item.call_id;
+    if (typeof callId !== "string" || !callId) {
+      this.logger.error(
+        { conversation_id: conversationId, item_keys: Object.keys(item) },
+        "Received malformed function_call item without call_id"
+      );
+      return;
+    }
+    const name = item.name;
+    let output;
+    if (typeof name !== "string" || !name) {
+      this.logger.error(
+        { conversation_id: conversationId, call_id: callId, item_keys: Object.keys(item) },
+        "Received malformed function_call item without tool name"
+      );
+      output = JSON.stringify({ error: "Malformed function call: missing tool name." });
+    } else {
+      const result = await this.runToolCall(conversationId, name, item.arguments);
+      try {
+        const serialized = JSON.stringify(result);
+        output = serialized ?? "null";
+      } catch (err) {
+        this.logger.error(
+          { err, conversation_id: conversationId, tool_name: name },
+          "Tool returned a non-JSON-serializable result"
+        );
+        output = JSON.stringify({ error: `Tool '${name}' returned a non-serializable result.` });
+      }
+    }
+    this.modelSend(conversationId, {
+      type: "conversation.item.create",
+      item: { type: "function_call_output", call_id: callId, output }
+    });
+    this.modelSend(conversationId, { type: "response.create" });
   }
   /**
-   * Hang up a call and clean up its ConversationRelay session.
+   * Drop this call's transport state, close the model socket, and end the
+   * session.
    *
-   * Works on `callSid` alone, whether or not a session exists yet. No-ops the
-   * session cleanup if none is tracked.
+   * 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.
+   */
+  async cleanupCall(conversationId) {
+    const call = this.calls.get(conversationId);
+    if (call === void 0) {
+      return;
+    }
+    this.calls.delete(conversationId);
+    if (call.modelWs !== null) {
+      try {
+        call.modelWs.close();
+      } catch (err) {
+        this.logger.debug({ err, conversation_id: conversationId }, "Error closing model socket");
+      }
+    }
+    await this.channel.endConversationInternal(conversationId);
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/openai-realtime/config.ts
+var OpenAIRealtimeProviderConfig = class extends MediaStreamsOpenAIProviderConfig {
+  /**
+   * 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;
+  constructor(options) {
+    super(options);
+    if (options?.welcomeGreetingResponse !== void 0) {
+      this.welcomeGreetingResponse = options.welcomeGreetingResponse;
+    }
+  }
+  createProvider(channel, tacConfig) {
+    return new OpenAIRealtimeProvider(channel, tacConfig, this);
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/gpt-live/state.ts
+var CallState2 = class extends MediaStreamsOpenAICallState {
+  /**
+   * Settles once `session.closed` arrives, so teardown can wait for graceful
+   * finalization before tearing the socket down.
+   */
+  closed;
+  resolveClosed;
+  constructor() {
+    super();
+    let resolve;
+    this.closed = new Promise((r) => {
+      resolve = r;
+    });
+    this.resolveClosed = resolve;
+  }
+  markClosed() {
+    this.resolveClosed();
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/gpt-live/provider.ts
+var TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE = { type: "audio/pcmu", rate: 8e3 };
+var GPT_LIVE_SESSION_ID_METADATA_KEY = "gpt_live_session_id";
+var SESSION_CONFIG_TOKEN_PARAM2 = "_tac_session_config_token";
+var SESSION_CONFIG_TOKEN_TTL_MS = 12e4;
+var GPT_LIVE_URL = "wss://api.openai.com/v1/live/sessions";
+var CLOSE_TIMEOUT_MS = 5e3;
+function isTwilioMediaStreamAudioFormat2(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const expected = TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE;
+  const actual = value;
+  const keys = Object.keys(actual);
+  return keys.length === Object.keys(expected).length && keys.every((key) => actual[key] === expected[key]);
+}
+async function waitWithTimeout(promise, ms) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(false), ms);
+  });
+  try {
+    return await Promise.race([promise.then(() => true), timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var GPTLiveProvider = class _GPTLiveProvider extends MediaStreamsOpenAIProvider {
+  /** @internal */
+  get providerId() {
+    return "gpt_live";
+  }
+  pendingTokenExpiries = /* @__PURE__ */ new Map();
+  /** Calls whose teardown has begun but is still awaiting `session.closed`. */
+  closingCalls = /* @__PURE__ */ new Set();
+  get channelName() {
+    return "VOICE_MEDIA_STREAM_OPENAI_GPT_LIVE";
+  }
+  // =========================================================================
+  // Outbound Call Handling
+  // =========================================================================
+  /**
+   * Initiate an outbound voice conversation.
    *
-   * 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.
+   * 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.
    *
-   * @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.
+   * 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.
    */
-  async endCall(callSid) {
-    const client = this.getTwilioClient();
-    let hungUp = true;
+  async initiateOutboundConversation(options) {
+    const parsedOptions = InitiateVoiceConversationOptionsGPTLiveSchema.safeParse(options);
+    if (!parsedOptions.success) {
+      throw new TypeError(
+        `GPTLiveProvider.initiateOutboundConversation requires options to be an InitiateVoiceConversationOptionsGPTLive: ${describeIssues(parsedOptions.error.issues)}`
+      );
+    }
+    const validated = parsedOptions.data;
+    let twimlOptions = validated.twimlOptions;
+    const sessionConfig = validated.sessionConfig ?? null;
+    let sessionConfigToken = null;
+    if (sessionConfig !== null) {
+      sessionConfigToken = crypto.randomUUID().replace(/-/g, "");
+      twimlOptions = {
+        ...twimlOptions,
+        customParameters: {
+          ...twimlOptions?.customParameters,
+          [SESSION_CONFIG_TOKEN_PARAM2]: sessionConfigToken
+        }
+      };
+    }
+    const fromNumber = this.tacConfig.phoneNumber;
+    this.logger.info(
+      { to: maskPhone(validated.to), from: maskPhone(fromNumber) },
+      "Initiating outbound voice conversation"
+    );
+    const twiml = this.twimlBuilder.build("initiateOutboundConversation", {
+      perCall: twimlOptions,
+      websocketUrl: validated.websocketUrl
+    });
+    const callParams = this.applyCallEventCallbacks(
+      validated.callOptions ? callOptionsToCreateParams(validated.callOptions) : {}
+    );
+    if (sessionConfigToken !== null && sessionConfig !== null) {
+      this.pendingSessionConfigs.set(sessionConfigToken, sessionConfig);
+    }
     try {
-      await client.calls(callSid).update({ status: "completed" });
+      this.logger.debug(
+        { twiml: redactTwimlParameters(twiml), to: maskPhone(validated.to) },
+        "Outbound call TwiML"
+      );
+      const client2 = this.channel.getTwilioClientInternal();
+      const call = await client2.calls.create({
+        to: validated.to,
+        from: fromNumber,
+        twiml,
+        ...callParams
+      });
+      this.logger.info(
+        { call_sid: call.sid, to: maskPhone(validated.to) },
+        "Outbound voice call placed"
+      );
+      if (sessionConfigToken !== null) {
+        this.armTokenExpiry(sessionConfigToken);
+      }
+      return { callSid: call.sid };
     } catch (error) {
-      hungUp = false;
-      this.logger.error({ err: error, call_sid: callSid }, "Failed to hang up call");
-    }
-    const session = this.getConversationSessionByCallSid(callSid);
-    if (session) {
-      await this.endConversation(session.conversationId);
+      if (sessionConfigToken !== null) {
+        this.pendingSessionConfigs.delete(sessionConfigToken);
+      }
+      this.logger.error(
+        { err: error, to: maskPhone(validated.to) },
+        "Failed to initiate outbound call"
+      );
+      throw error;
     }
-    return hungUp;
   }
   /**
-   * Look up the active voice session for a Twilio Call SID.
+   * Start the clock on a stashed token, so a call that never connects cannot
+   * strand its override in {@link pendingSessionConfigs} forever.
    *
-   * 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.
+   * Unref'd: a two-minute timer must not be what keeps the process alive after
+   * the call it belongs to is long over.
+   */
+  armTokenExpiry(token) {
+    const timer = setTimeout(() => {
+      this.pendingTokenExpiries.delete(token);
+      this.pendingSessionConfigs.delete(token);
+    }, SESSION_CONFIG_TOKEN_TTL_MS);
+    timer.unref();
+    this.pendingTokenExpiries.set(token, timer);
+  }
+  /**
+   * Stop the clock on a token, once the call it belongs to has claimed it.
    *
-   * 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.
+   * Without this a two-minute timer outlives every call that connected
+   * normally, waiting to purge an entry that is already gone.
+   */
+  cancelTokenExpiry(token) {
+    const timer = this.pendingTokenExpiries.get(token);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.pendingTokenExpiries.delete(token);
+    }
+  }
+  // =========================================================================
+  // Audio Bridge
+  // =========================================================================
+  /**
+   * Drive one Twilio Media Stream connection from `start` to disconnect.
    *
-   * 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.
+   * 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.
    *
-   * @example
-   * ```typescript
-   * async function nudge(callSid: string): Promise<void> {
-   *   const session = voiceChannel.getConversationSessionByCallSid(callSid);
-   *   if (session) {
-   *     await voiceChannel.sendResponse(session.conversationId, 'Still there?');
-   *   }
-   * }
-   * ```
+   * 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.
    *
-   * @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).
+   * Called by `VoiceChannel.handleWebSocketConnection`; hosts serve the socket
+   * rather than calling this directly.
+   *
+   * @param ws - The accepted Twilio-facing WebSocket.
    */
-  getConversationSessionByCallSid(callSid) {
-    for (const session of this.activeConversations.values()) {
-      if (session.callSid === callSid) {
-        return session;
+  handleWebSocket(ws) {
+    let conversationId = null;
+    ws.on("message", (data) => {
+      void (async () => {
+        const message = JSON.parse(data.toString());
+        const event = typeof message.event === "string" ? message.event : "";
+        if (event === "start") {
+          const registered = this.registerCall(message.start, ws);
+          conversationId = registered.conversationId;
+          const connecting = this.connectModel(registered.conversationId);
+          registered.call.modelReady = connecting.then(
+            () => true,
+            () => false
+          );
+          await connecting;
+        } else if (event === "media") {
+          const media = message.media ?? {};
+          const payload = media.payload;
+          if (conversationId !== null && typeof payload === "string" && payload) {
+            const call = this.calls.get(conversationId);
+            if (call === void 0) {
+              return;
+            }
+            if (call.modelReady !== null && !await call.modelReady) {
+              return;
+            }
+            this.modelSend(conversationId, {
+              type: "session.input_audio.append",
+              audio: payload
+            });
+          }
+        } else if (event === "stop") {
+          this.logger.info({ conversation_id: conversationId }, "Media stream stopped");
+          if (conversationId !== null) {
+            await this.cleanupCall(conversationId);
+          }
+          ws.close();
+        }
+      })().catch((err) => {
+        this.logger.error({ err, conversation_id: conversationId }, "Media stream WebSocket error");
+        ws.close();
+      });
+    });
+    ws.on("close", () => {
+      this.logger.info({ conversation_id: conversationId }, "Media stream WebSocket closed");
+      if (conversationId !== null) {
+        trackEvent("Websocket Disconnected", {
+          account_sid: this.tacConfig.accountSid,
+          channel: "voice",
+          conversation_id: conversationId,
+          provider: this.providerId,
+          orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+        });
+        void this.cleanupCall(conversationId).catch((err) => {
+          this.logger.error({ err, conversation_id: conversationId }, "Call cleanup error");
+        });
       }
-    }
-    return void 0;
+    });
+    ws.on("error", (error) => {
+      this.channel.handleErrorInternal(error, { conversationId });
+    });
   }
-  // =========================================================================
-  // Stream Task Management
-  // =========================================================================
   /**
-   * Start tracking a streaming task for a conversation
-   *
-   * @param conversationId - The conversation ID
-   * @returns The stream task with its AbortController
-   */
-  startStreamTask(conversationId) {
-    this.cancelStreamTask(conversationId);
-    const task = { controller: new AbortController(), hasSentTokens: false };
-    this.streamTasks.set(conversationId, task);
-    this.logger.debug({ conversation_id: conversationId }, "Started stream task");
-    return task;
+   * 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.
+   */
+  registerCall(start, ws) {
+    const message = StreamStartMessageSchema.parse(start ?? {});
+    const conversationId = message.callSid;
+    this.cancelInboundConfigExpiry(conversationId);
+    const token = message.customParameters[SESSION_CONFIG_TOKEN_PARAM2];
+    if (token !== void 0) {
+      const pending = this.pendingSessionConfigs.get(token);
+      if (pending !== void 0) {
+        this.pendingSessionConfigs.delete(token);
+        this.pendingSessionConfigs.set(conversationId, pending);
+      }
+      this.cancelTokenExpiry(token);
+    }
+    const call = new CallState2();
+    call.twilioWs = ws;
+    this.calls.set(conversationId, call);
+    try {
+      const session = this.channel.startConversationInternal(conversationId);
+      session.callSid = message.callSid;
+      session.metadata.streamSid = message.streamSid;
+      session.metadata.transcript = [];
+      trackEvent("Conversation Initialized", {
+        account_sid: this.tacConfig.accountSid,
+        channel: "voice",
+        conversation_id: conversationId,
+        provider: this.providerId,
+        orchestrator_enabled: this.tacConfig.isOrchestratorEnabled()
+      });
+    } catch (err) {
+      this.calls.delete(conversationId);
+      this.pendingSessionConfigs.delete(conversationId);
+      void this.channel.endConversationInternal(conversationId).catch(() => void 0);
+      throw err;
+    }
+    this.logger.debug(
+      { conversation_id: conversationId, media_format: message.mediaFormat },
+      "Media stream started"
+    );
+    return { conversationId, call };
   }
   /**
-   * Cancel an active streaming task
+   * Open this call's GPT-Live socket and send its session config.
    *
-   * @param conversationId - The conversation ID
-   * @returns true if a task was cancelled, false otherwise
+   * @internal
    */
-  cancelStreamTask(conversationId) {
-    const task = this.streamTasks.get(conversationId);
-    if (task) {
-      task.controller.abort();
-      this.streamTasks.delete(conversationId);
-      this.logger.debug({ conversation_id: conversationId }, "Cancelled stream task");
-      return true;
+  async connectModel(conversationId) {
+    const sessionConfig = this.resolveSessionConfig(conversationId);
+    const modelWs = await this.openModelSocket(GPT_LIVE_URL, {
+      Authorization: `Bearer ${this.config.openaiApiKey}`,
+      "User-Agent": OPENAI_USER_AGENT
+    });
+    const call = this.calls.get(conversationId);
+    if (call === void 0) {
+      modelWs.close();
+      return;
     }
-    return false;
+    call.modelWs = modelWs;
+    this.attachModelHandlers(conversationId, modelWs);
+    this.logger.info({ conversation_id: conversationId }, "Connected to GPT-Live");
+    this.modelSend(conversationId, { type: "session.start", session: sessionConfig });
   }
   /**
-   * Complete a streaming task (remove from tracking)
+   * The validated session config for this call: its own stashed override if it
+   * has one, else the channel-wide default.
    *
-   * @param conversationId - The conversation ID
+   * @throws {Error} if neither exists, if the audio format is one Twilio can't
+   *   carry, or if it names no model.
    */
-  completeStreamTask(conversationId) {
-    this.streamTasks.delete(conversationId);
-    this.logger.debug({ conversation_id: conversationId }, "Completed stream task");
+  resolveSessionConfig(conversationId) {
+    const sessionConfig = this.pendingSessionConfigs.get(conversationId) ?? this.config.defaultSessionConfig;
+    this.pendingSessionConfigs.delete(conversationId);
+    if (sessionConfig === void 0) {
+      throw new Error(
+        `No sessionConfig available for call ${conversationId} \u2014 this call supplied none and defaultSessionConfig is not set either.`
+      );
+    }
+    const audio = sessionConfig.audio ?? {};
+    if (!isTwilioMediaStreamAudioFormat2(audio.format)) {
+      throw new Error(
+        `sessionConfig for call ${conversationId} has audio.format=${JSON.stringify(audio.format)}, expected ${JSON.stringify(TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE)}. Twilio Media Streams is always 8kHz G.711 u-law; set audio.format to TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE.`
+      );
+    }
+    if (!sessionConfig.model) {
+      throw new Error(`sessionConfig for call ${conversationId} must include 'model'.`);
+    }
+    return sessionConfig;
   }
   /**
-   * Check if a stream task is active
+   * 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) {
-    const task = this.streamTasks.get(conversationId);
-    return task !== void 0 && !task.controller.signal.aborted;
+  attachModelHandlers(conversationId, modelWs) {
+    modelWs.on("message", (raw) => {
+      void this.handleModelMessage(conversationId, raw);
+    });
+    modelWs.on("close", () => {
+      if (this.calls.has(conversationId)) {
+        this.logger.info({ conversation_id: conversationId }, "Model connection ended");
+      }
+      this.endCallFromModel(conversationId);
+    });
+    modelWs.on("error", (error) => {
+      this.logger.error({ err: error, conversation_id: conversationId }, "Model socket error");
+      this.endCallFromModel(conversationId);
+    });
   }
-  // =========================================================================
-  // ConversationRelay TwiML Generation
-  // =========================================================================
   /**
-   * 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.
    */
-  static RELAY_ATTR_FIELDS = [
-    "welcomeGreeting",
-    "welcomeGreetingInterruptible",
-    "conversationConfiguration",
-    "language",
-    "ttsLanguage",
-    "transcriptionLanguage",
-    "voice",
-    "ttsProvider",
-    "transcriptionProvider",
-    "speechModel",
-    "elevenlabsTextNormalization",
-    "eotThreshold",
-    "partialPrompts",
-    "deepgramSmartFormat",
-    "speechTimeout",
-    "interruptible",
-    "interruptSensitivity",
-    "reportInputDuringAgentSpeech",
-    "ignoreBackchannel",
-    "preemptible",
-    "dtmfDetection",
-    "hints",
-    "events",
-    "debug",
-    "intelligenceService"
-  ];
+  endCallFromModel(conversationId) {
+    this.calls.get(conversationId)?.twilioWs?.close();
+    void this.cleanupCall(conversationId).catch((err) => {
+      this.logger.error({ err, conversation_id: conversationId }, "Call cleanup error");
+    });
+  }
   /**
-   * 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.
    */
-  generateTwiml(websocketUrl, options) {
-    const resolvedWebsocketUrl = websocketUrl || options.websocketUrl;
-    if (!resolvedWebsocketUrl) {
-      throw new Error(
-        "generateTwiml requires a WebSocket URL \u2014 pass it explicitly or set options.websocketUrl."
-      );
+  async cleanupCall(conversationId) {
+    const call = this.calls.get(conversationId);
+    if (call === void 0 || this.closingCalls.has(conversationId)) {
+      return;
     }
-    const response = new VoiceResponse();
-    const connect = response.connect(options.actionUrl ? { action: options.actionUrl } : {});
-    const relayAttrs = { url: resolvedWebsocketUrl };
-    for (const field of _VoiceChannel.RELAY_ATTR_FIELDS) {
-      let value = options[field];
-      if (value === void 0) {
-        continue;
-      }
-      if (field === "interruptible" && typeof value === "boolean") {
-        value = value ? "any" : "none";
+    this.closingCalls.add(conversationId);
+    const modelWs = call.modelWs;
+    if (modelWs !== null) {
+      let requested = true;
+      try {
+        modelWs.send(JSON.stringify({ type: "session.close" }));
+      } catch (err) {
+        requested = false;
+        this.logger.debug(
+          { err, conversation_id: conversationId },
+          "Error sending session.close to model socket"
+        );
       }
-      relayAttrs[field] = value;
-    }
-    if (options.extra) {
-      for (const [key, value] of Object.entries(options.extra)) {
-        if (key === "url") {
-          this.logger.warn(
-            "Ignoring `url` in TwiMLOptions.extra; set `websocketUrl` to override the ConversationRelay URL."
+      if (requested) {
+        try {
+          const acknowledged = await waitWithTimeout(call.closed, CLOSE_TIMEOUT_MS);
+          if (!acknowledged) {
+            this.logger.debug(
+              { conversation_id: conversationId },
+              "Timed out waiting for session.closed"
+            );
+          }
+        } catch (err) {
+          this.logger.debug(
+            { err, conversation_id: conversationId },
+            "Error waiting for session.closed"
           );
-          continue;
         }
-        relayAttrs[key] = value;
-      }
-    }
-    const relay = connect.conversationRelay(
-      relayAttrs
-    );
-    if (options.languages && options.languages.length > 0) {
-      for (const lang of options.languages) {
-        const langAttrs = this.filterUnsetValues(lang);
-        relay.language(langAttrs);
       }
     }
-    if (options.customParameters) {
-      for (const [name, value] of Object.entries(options.customParameters)) {
-        if (value !== null && value !== void 0) {
-          relay.parameter({ name, value: stringifyParameterValue(value) });
-        }
+    this.calls.delete(conversationId);
+    this.closingCalls.delete(conversationId);
+    if (modelWs !== null) {
+      try {
+        modelWs.close();
+      } catch (err) {
+        this.logger.debug({ err, conversation_id: conversationId }, "Error closing model socket");
       }
     }
-    return response.toString();
+    await this.channel.endConversationInternal(conversationId);
   }
   /**
-   * 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, options) {
-    const validationResult = ConversationRelayConfigSchema.safeParse(config);
-    if (!validationResult.success) {
-      const errorMessage = validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-      throw new Error(`Invalid ConversationRelay configuration: ${errorMessage}`);
+  shutdown() {
+    for (const timer of this.pendingTokenExpiries.values()) {
+      clearTimeout(timer);
     }
-    const validatedConfig = validationResult.data;
-    const { languages, ...conversationRelayAttributes } = validatedConfig;
-    const filteredConfig = this.filterUnsetValues(conversationRelayAttributes);
-    const response = new VoiceResponse();
-    const connect = response.connect(options?.actionUrl ? { action: options.actionUrl } : {});
-    const relay = connect.conversationRelay(filteredConfig);
-    if (languages && languages.length > 0) {
-      for (const lang of languages) {
-        const filteredLang = this.filterUnsetValues(lang);
-        relay.language(filteredLang);
+    this.pendingTokenExpiries.clear();
+    this.closingCalls.clear();
+    super.shutdown();
+  }
+  /** Apply one parsed GPT-Live event to the call. */
+  async dispatchModelEvent(conversationId, session, event) {
+    switch (event.type) {
+      case "error": {
+        this.logger.error(
+          { conversation_id: conversationId, error: event.error },
+          "GPT-Live error event"
+        );
+        break;
       }
-    }
-    if (options?.parameters) {
-      for (const [name, value] of Object.entries(options.parameters)) {
-        relay.parameter({ name, value: String(value) });
+      case "session.closed": {
+        this.recordGptLiveSessionId(conversationId, session, event);
+        this.calls.get(conversationId)?.markClosed();
+        break;
+      }
+      case "session.started": {
+        this.recordGptLiveSessionId(conversationId, session, event);
+        const instruction = this.config.welcomeInstruction;
+        if (instruction !== null) {
+          this.modelSend(conversationId, {
+            type: "session.commentary.append",
+            delegation_id: null,
+            content: instruction
+          });
+        }
+        break;
+      }
+      case "session.input_transcript.delta": {
+        _GPTLiveProvider.appendTranscriptDelta(session, "user", event);
+        break;
+      }
+      case "session.output_transcript.delta": {
+        _GPTLiveProvider.appendTranscriptDelta(session, "assistant", event);
+        break;
+      }
+      case "session.output_audio.delta": {
+        const delta = event.delta;
+        if (typeof delta !== "string" || !delta) {
+          break;
+        }
+        this.twilioSend(conversationId, {
+          event: "media",
+          streamSid: session.metadata.streamSid,
+          media: { payload: delta }
+        });
+        break;
+      }
+      case "response.event": {
+        const inner = event.event ?? {};
+        if (inner.type !== "response.output_item.done") {
+          break;
+        }
+        const item = inner.item ?? {};
+        if (item.type === "function_call" && item.status === "completed") {
+          await this.handleFunctionCall(conversationId, item);
+        }
+        break;
       }
     }
-    return response.toString();
   }
   /**
-   * 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.
    */
-  filterUnsetValues(config) {
-    const filtered = {};
-    for (const [key, value] of Object.entries(config)) {
-      if (value !== void 0) {
-        filtered[key] = value;
+  async handleFunctionCall(conversationId, item) {
+    const callId = item.call_id;
+    if (typeof callId !== "string" || !callId) {
+      this.logger.error(
+        { conversation_id: conversationId, item_keys: Object.keys(item) },
+        "Received malformed function_call item without call_id"
+      );
+      return;
+    }
+    const name = item.name;
+    let output;
+    if (typeof name !== "string" || !name) {
+      this.logger.error(
+        { conversation_id: conversationId, call_id: callId, item_keys: Object.keys(item) },
+        "Received malformed function_call item without tool name"
+      );
+      output = JSON.stringify({ error: "Malformed function call: missing tool name." });
+    } else {
+      const result = await this.runToolCall(conversationId, name, item.arguments);
+      try {
+        const serialized = JSON.stringify(result);
+        output = serialized ?? "null";
+      } catch (err) {
+        this.logger.error(
+          { err, conversation_id: conversationId, tool_name: name },
+          "Tool returned a non-JSON-serializable result"
+        );
+        output = JSON.stringify({ error: `Tool '${name}' returned a non-serializable result.` });
       }
     }
-    return filtered;
+    this.modelSend(conversationId, {
+      type: "response.item.create",
+      item: { type: "function_call_output", call_id: callId, output }
+    });
+    this.modelSend(conversationId, { type: "response.create" });
   }
   /**
-   * 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() {
-    this.streamTasks.clear();
-    this.webSocketConnections.clear();
-    this.promptQueues.clear();
-    this.initializationRetries.clear();
-    this.callSidToConversationId.clear();
-    super.shutdown();
+  recordGptLiveSessionId(conversationId, session, event) {
+    const snapshot = event.session ?? {};
+    const sessionId = snapshot.id;
+    if (typeof sessionId !== "string" || sessionId === "") {
+      return;
+    }
+    if (session.metadata[GPT_LIVE_SESSION_ID_METADATA_KEY] === sessionId) {
+      return;
+    }
+    session.metadata[GPT_LIVE_SESSION_ID_METADATA_KEY] = sessionId;
+    this.logger.info(
+      { conversation_id: conversationId, gpt_live_session_id: sessionId },
+      "GPT-Live session id"
+    );
+  }
+  /** Accumulate one transcript delta into the in-progress turn. */
+  static appendTranscriptDelta(session, role, event) {
+    const text = event.delta;
+    if (typeof text !== "string" || text === "") {
+      return;
+    }
+    const existing = session.metadata.transcript;
+    const transcript = Array.isArray(existing) ? existing : [];
+    if (transcript !== existing) {
+      session.metadata.transcript = transcript;
+    }
+    const last = transcript[transcript.length - 1];
+    if (last !== void 0 && last.role === role) {
+      last.text += text;
+    } else {
+      transcript.push({ role, text });
+    }
+  }
+};
+
+// packages/core/src/channels/voice/media-streams/gpt-live/config.ts
+var GPTLiveProviderConfig = class extends MediaStreamsOpenAIProviderConfig {
+  welcomeInstruction;
+  constructor(opts = {}) {
+    super(opts);
+    this.welcomeInstruction = opts.welcomeInstruction ?? null;
+  }
+  createProvider(channel, tacConfig) {
+    return new GPTLiveProvider(channel, tacConfig, this);
   }
 };
 
@@ -6197,6 +8974,21 @@ var TACTool = class {
       }
     };
   }
+  /**
+   * 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() {
+    return {
+      type: "function",
+      name: this.name,
+      description: this.description,
+      parameters: this.parameters
+    };
+  }
   /**
    * Convert to Anthropic tool calling format
    */
@@ -6778,16 +9570,7 @@ var TACServer = class {
           }
           const voiceChannel = this.voiceChannel;
           const formData = request.body;
-          const parseResult = ConversationRelayCallbackPayloadSchema.safeParse(formData);
-          if (!parseResult.success) {
-            this.fastify.log.error(
-              { errors: parseResult.error.issues },
-              "Invalid ConversationRelay callback payload"
-            );
-            await reply.code(400).send({ error: "Invalid payload" });
-            return;
-          }
-          const result = await voiceChannel.handleConversationRelayCallback(parseResult.data);
+          const result = await voiceChannel.handleTwilioProviderCallback(formData);
           await reply.code(result.status).type(result.contentType).send(result.content);
         } catch (error) {
           this.fastify.log.error(
@@ -7016,6 +9799,6 @@ var TACServer = class {
   }
 };
 
-export { ActionChannelSettingsSchema, ActionParticipantRefSchema, ActionResponseSchema, ActionTextContentSchema, AmdEventSchema, AnthropicToolSchema, AuthorInfoSchema, BaseChannel, BaseClient, BuiltInTools, CALL_EVENT_KINDS, CallEventKindSchema, CallOptionsSchema, CallStatusEventSchema, CaptureRuleSchema, ChannelSettingsSchema, ChannelTypeSchema, ChatChannel, CintelParticipantSchema, CommunicationContentSchema, CommunicationParticipantSchema, CommunicationSchema, ConversationAddressSchema, ConversationClient, ConversationConfigurationSchema, ConversationGroupingTypeSchema, ConversationIntelligenceConfigSchema, ConversationParticipantSchema, ConversationRelayAttributesSchema, ConversationRelayCallbackPayloadSchema, ConversationRelayConfigSchema, ConversationResponseSchema, ConversationSessionSchema, ConversationSummaryItemSchema, CreateConversationSummariesResponseSchema, CreateObservationResponseSchema, CreateObservationsRequestSchema, CustomParametersSchema, EMPTY_MEMORY_RESPONSE, EnvironmentVariables, ExecutionDetailsSchema, HandoffPayloadSchema, InitiateMessagingConversationOptionsSchema, InitiateVoiceConversationOptionsSchema, IntelligenceConfigurationSchema, InterruptMessageSchema, InterruptModeSchema, JSONSchemaSchema, KnowledgeBaseSchema, KnowledgeBaseStatusSchema, KnowledgeChunkResultSchema, KnowledgeClient, KnowledgeSearchResponseSchema, LanguageAttributesSchema, LanguageConfigSchema, ListCommunicationsResponseSchema, ListConversationsResponseSchema, ListParticipantsResponseSchema, MemoryChannelTypeSchema, MemoryClient, MemoryCommunicationContentSchema, MemoryCommunicationSchema, MemoryDeliveryStatusSchema, MemoryModeSchema, MemoryParticipantSchema, MemoryParticipantTypeSchema, MemoryPromptBuilder, MemoryRetrievalRequestSchema, MemoryRetrievalResponseSchema, MessageDirectionSchema, MessagingChannel, ObservationCreateRequestSchema, ObservationInfoSchema, OpenAIToolSchema, OperatorProcessingResultSchema, OperatorResultEventSchema, OperatorResultProcessor, OperatorResultSchema, OperatorSchema, ParticipantAddressSchema, ParticipantAddressTypeSchema, PendingHandoffDataSchema, ProfileLookupResponseSchema, ProfileResponseSchema, PromptMessageSchema, RCSChannel, RecordingEventSchema, SMSChannel, SendMessageActionPayloadSchema, SendMessageActionRequestSchema, SessionInfoSchema, SessionMessageSchema, SetupMessageSchema, StatusCallbackSchema, StatusTimeoutsSchema, SummaryInfoSchema, TAC, TACChannelTypeSchema, TACCommunicationAuthorSchema, TACCommunicationContentSchema, TACCommunicationSchema, TACConfig, TACConfigSchema, TACDeliveryStatusSchema, TACMemoryResponse, TACParticipantTypeSchema, TACServer, TACTool, TextTokenMessageSchema, ToolExecutionResultSchema, TranscriptionSchema, TranscriptionWordSchema, TwiMLOptionsSchema, TwiMLRequestSchema, TwilioMemoryConfigSchema, VoiceChannel, WebSocketMessageSchema, WhatsAppChannel, 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 { ActionChannelSettingsSchema, ActionParticipantRefSchema, ActionResponseSchema, ActionTextContentSchema, AmdEventSchema, AnthropicToolSchema, AuthorInfoSchema, BaseChannel, BaseClient, BuiltInTools, CALL_EVENT_KINDS, CallEventKindSchema, CallOptionsSchema, CallStatusEventSchema, CaptureRuleSchema, ChannelSettingsSchema, ChannelTypeSchema, ChatChannel, CintelParticipantSchema, CommunicationContentSchema, CommunicationParticipantSchema, CommunicationSchema, ConversationAddressSchema, ConversationClient, ConversationConfigurationSchema, ConversationGroupingTypeSchema, ConversationIntelligenceConfigSchema, ConversationParticipantSchema, ConversationRelayAttributesSchema, ConversationRelayCallbackPayloadSchema, ConversationRelayConfigSchema, ConversationRelayProvider, ConversationRelayProviderConfig, ConversationResponseSchema, ConversationSessionSchema, ConversationSummaryItemSchema, CreateConversationSummariesResponseSchema, CreateObservationResponseSchema, CreateObservationsRequestSchema, CustomParametersSchema, DtmfMessageSchema, EMPTY_MEMORY_RESPONSE, EnvironmentVariables, ExecutionDetailsSchema, GPTLiveProvider, GPTLiveProviderConfig, GPT_LIVE_SESSION_ID_METADATA_KEY, HandoffPayloadSchema, InitiateMessagingConversationOptionsSchema, InitiateVoiceConversationOptionsGPTLiveSchema, InitiateVoiceConversationOptionsOpenAIRealtimeSchema, InitiateVoiceConversationOptionsSchema, IntelligenceConfigurationSchema, InterruptMessageSchema, InterruptModeSchema, JSONSchemaSchema, KnowledgeBaseSchema, KnowledgeBaseStatusSchema, KnowledgeChunkResultSchema, KnowledgeClient, KnowledgeSearchResponseSchema, LanguageAttributesSchema, LanguageConfigSchema, ListCommunicationsResponseSchema, ListConversationsResponseSchema, ListParticipantsResponseSchema, MediaStreamsOpenAICallState, MediaStreamsOpenAIProvider, MediaStreamsOpenAIProviderConfig, MediaStreamsProviderConfig, MemoryChannelTypeSchema, MemoryClient, MemoryCommunicationContentSchema, MemoryCommunicationSchema, MemoryDeliveryStatusSchema, MemoryModeSchema, MemoryParticipantSchema, MemoryParticipantTypeSchema, MemoryPromptBuilder, MemoryRetrievalRequestSchema, MemoryRetrievalResponseSchema, MessageDirectionSchema, MessagingChannel, OPENAI_USER_AGENT, ObservationCreateRequestSchema, ObservationInfoSchema, OpenAIRealtimeProvider, OpenAIRealtimeProviderConfig, OpenAIRealtimeToolSchema, OpenAIToolSchema, OperatorProcessingResultSchema, OperatorResultEventSchema, OperatorResultProcessor, OperatorResultSchema, OperatorSchema, ParticipantAddressSchema, ParticipantAddressTypeSchema, PendingHandoffDataSchema, ProfileLookupResponseSchema, ProfileResponseSchema, PromptMessageSchema, RCSChannel, RecordingEventSchema, SMSChannel, SendMessageActionPayloadSchema, SendMessageActionRequestSchema, SessionInfoSchema, SessionMessageSchema, SetupMessageSchema, StatusCallbackSchema, StatusTimeoutsSchema, StreamStartMessageSchema, SummaryInfoSchema, TAC, TACChannelTypeSchema, TACCommunicationAuthorSchema, TACCommunicationContentSchema, TACCommunicationSchema, TACConfig, TACConfigSchema, TACDeliveryStatusSchema, TACMemoryResponse, TACParticipantTypeSchema, TACServer, TACTool, TWILIO_AUDIO_FORMAT_FOR_GPT_LIVE, TWILIO_AUDIO_FORMAT_FOR_REALTIME, TextTokenMessageSchema, ToolExecutionResultSchema, TranscriptionSchema, TranscriptionWordSchema, TwiMLBuilderMediaStreams, TwiMLOptionsSchema, TwiMLRequestSchema, TwilioMemoryConfigSchema, VoiceChannel, VoiceProvider, VoiceProviderConfig, VoiceTwiMLOptionsConversationRelaySchema, VoiceTwiMLOptionsMediaStreamsSchema, VoiceTwiMLOptionsSchema, WebSocketMessageSchema, WhatsAppChannel, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map