@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/calls/twilio-routes.ts

@@ -1,34 +1,24 @@
 /**
  * HTTP route handlers for Twilio voice webhooks.
  *
- * - handleVoiceWebhook: initial voice webhook; returns TwiML to connect
- *   ConversationRelay (Twilio-native STT) or Stream (custom media-stream STT)
+ * - handleVoiceWebhook: initial voice webhook; returns `<Connect><Stream>`
+ *   TwiML so the daemon receives raw audio over the media-stream transport
+ *   and performs STT/TTS server-side for every call
  * - handleStatusCallback: call status updates (ringing, in-progress, completed, etc.)
- * - handleConnectAction: called when the ConversationRelay connection ends
  *
- * ## STT routing
- *
- * TwiML generation is driven by `services.stt.provider` via
- * {@link resolveTelephonySttRouting}. The resolver returns a discriminated
- * strategy that determines which TwiML path to use:
- *
- * - **`conversation-relay-native`** (deepgram, google-gemini) — emits
- *   `<Connect><ConversationRelay>` with Twilio-native `transcriptionProvider`
- *   and `speechModel` attributes.
- *
- * - **`media-stream-custom`** (openai-whisper) — emits
- *   `<Connect><Stream>` so the daemon receives raw audio and transcribes
- *   server-side.
+ * Setup-flow routing (verification, invite redemption, name capture, deny,
+ * normal) is resolved by the media-stream server when Twilio's `start`
+ * frame arrives — TwiML generation performs no routing of its own. Its
+ * only gate is the STT+TTS credential-readiness preflight: a call whose
+ * daemon cannot transcribe or speak gets audible `<Say>` setup-required
+ * TwiML and a `<Hangup/>` instead of a doomed stream.
  */
 
 import {
   buildTwilioMediaStreamUrl,
-  buildTwilioRelayUrl,
   TWILIO_PUBLIC_BASE_URL_PLACEHOLDER,
 } from "@vellumai/service-contracts/twilio-ingress";
 
-import { loadConfig } from "../config/loader.js";
-import { getProviderEntry } from "../providers/speech-to-text/provider-catalog.js";
 import {
   BadRequestError,
   GoneError,
@@ -54,13 +44,8 @@ import {
   releaseCallbackClaim,
   updateCallSession,
 } from "./call-store.js";
-import { getChannelAdmissionPolicy } from "./channel-admission-reader.js";
-import { getPhoneCallerVerdict } from "./inbound-trust-reader.js";
-import { routeSetup } from "./relay-setup-router.js";
-import { resolveCallHints } from "./stt-hints.js";
-import { resolveTelephonySttRouting } from "./telephony-stt-routing.js";
+import { resolveTelephonyCredentialReadiness } from "./telephony-credential-preflight.js";
 import type { CallStatus } from "./types.js";
-import { resolveVoiceQualityProfile } from "./voice-quality.js";
 
 const log = getLogger("twilio-routes");
 
@@ -71,26 +56,7 @@ const log = getLogger("twilio-routes");
  */
 const TWILIO_RELAY_TOKEN_PLACEHOLDER = "__VELLUM_RELAY_TOKEN__";
 
-// ── Speech config type ───────────────────────────────────────────────
-
-/**
- * Twilio ConversationRelay speech-to-text attributes.
- *
- * All values are pre-formatted strings ready for direct insertion into
- * TwiML XML attribute values (XML escaping is the caller's responsibility).
- */
-export interface TwilioRelaySpeechConfig {
-  /** STT provider name (e.g. "Deepgram", "Google"). */
-  transcriptionProvider: string;
-  /** ASR model identifier, or undefined when the provider default should be used. */
-  speechModel: string | undefined;
-  /** Comma-separated vocabulary hints for the STT provider, or undefined when no hints are available. */
-  hints: string | undefined;
-  /** How aggressively the provider detects the start of caller speech. */
-  interruptSensitivity: string;
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────
+// ── TwiML generation ─────────────────────────────────────────────────
 
 function escapeXml(str: string): string {
   return str
@@ -101,71 +67,11 @@ function escapeXml(str: string): string {
     .replace(/'/g, "&apos;");
 }
 
-export function generateTwiML(
-  callSessionId: string,
-  relayUrl: string,
-  welcomeGreeting: string | null,
-  profile: {
-    language: string;
-    ttsProvider: string;
-    voice: string;
-  },
-  speechConfig: TwilioRelaySpeechConfig,
-  relayToken?: string,
-  customParameters?: Record<string, string>,
-): string {
-  const greetingAttr =
-    welcomeGreeting && welcomeGreeting.trim().length > 0
-      ? `\n      welcomeGreeting="${escapeXml(welcomeGreeting.trim())}"`
-      : "";
-  const tokenParam = relayToken
-    ? `&amp;token=${escapeXml(encodeURIComponent(relayToken))}`
-    : "";
-
-  // Build <Parameter> elements for custom parameters to propagate
-  // through the ConversationRelay setup payload for observability.
-  let parameterElements = "";
-  if (customParameters) {
-    for (const [key, value] of Object.entries(customParameters)) {
-      parameterElements += `\n      <Parameter name="${escapeXml(
-        key,
-      )}" value="${escapeXml(value)}" />`;
-    }
-  }
-
-  // When there are no Parameter children, use self-closing tag to preserve
-  // the original TwiML format. With children, use open/close tags.
-  const hasParameters = parameterElements.length > 0;
-  const relayClose = hasParameters
-    ? `>${parameterElements}\n    </ConversationRelay>`
-    : "/>";
-
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Connect>
-    <ConversationRelay
-      url="${escapeXml(relayUrl)}?callSessionId=${escapeXml(
-        callSessionId,
-      )}${tokenParam}"
-${greetingAttr}
-      voice="${escapeXml(profile.voice)}"
-      language="${escapeXml(profile.language)}"
-      transcriptionProvider="${escapeXml(speechConfig.transcriptionProvider)}"${speechConfig.speechModel ? `\n      speechModel="${escapeXml(speechConfig.speechModel)}"` : ""}
-      ttsProvider="${escapeXml(profile.ttsProvider)}"
-      interruptible="true"
-      dtmfDetection="true"
-      interruptSensitivity="${escapeXml(speechConfig.interruptSensitivity)}"${speechConfig.hints ? `\n      hints="${escapeXml(speechConfig.hints)}"` : ""}
-    ${relayClose}
-  </Connect>
-</Response>`;
-}
-
 /**
- * Generate `<Connect><Stream>` TwiML for the media-stream STT path.
+ * Generate `<Connect><Stream>` TwiML for the media-stream transport.
  *
- * Used when the telephony STT routing resolver selects `media-stream-custom`
- * (e.g. OpenAI Whisper). Twilio opens a WebSocket to `streamUrl` and sends
- * raw audio frames; the daemon transcribes server-side.
+ * Twilio opens a WebSocket to `streamUrl` and sends raw audio frames; the
+ * daemon transcribes and synthesizes speech server-side.
  *
  * `callSessionId` and `token` are encoded as **path segments** on the
  * WebSocket URL so the gateway can validate and route the upgrade request
@@ -220,19 +126,6 @@ export function generateStreamTwiML(
 </Response>`;
 }
 
-export function buildWelcomeGreeting(
-  task: string | null,
-  configuredGreeting?: string,
-): string {
-  void task;
-  const override = configuredGreeting?.trim();
-  if (override) return override;
-  // The contextual first opener now comes from the call controller's
-  // initial LLM turn via the conversation pipeline. Keep Twilio's relay-level
-  // greeting empty by default so we don't speak a deterministic static line first.
-  return "";
-}
-
 /**
  * Map Twilio call status strings to our internal CallStatus.
  */
@@ -305,18 +198,7 @@ async function processVoiceWebhook(
       toNumber: callerTo,
     });
 
-    return buildVoiceWebhookTwiml(
-      session.id,
-      {
-        task: session.task,
-        toNumber: callerTo,
-        fromNumber: callerFrom,
-        direction: "inbound",
-        inviteFriendName: null,
-        inviteGuardianName: null,
-      },
-      session.verificationSessionId,
-    );
+    return buildVoiceWebhookTwiml(session.id, session.verificationSessionId);
   }
 
   // ── Outbound mode: callSessionId is present ─────────────────────
@@ -340,25 +222,14 @@ async function processVoiceWebhook(
     log.info({ callSessionId, callSid }, "Stored CallSid from voice webhook");
   }
 
-  return buildVoiceWebhookTwiml(
-    callSessionId,
-    {
-      task: session.task,
-      toNumber: session.toNumber,
-      fromNumber: session.fromNumber,
-      direction: "outbound",
-      inviteFriendName: session.inviteFriendName,
-      inviteGuardianName: session.inviteGuardianName,
-    },
-    session.verificationSessionId,
-  );
+  return buildVoiceWebhookTwiml(callSessionId, session.verificationSessionId);
 }
 
 // ── Route handlers ───────────────────────────────────────────────────
 
 /**
  * Receives the initial voice webhook when Twilio connects the call.
- * Returns TwiML XML that tells Twilio to open a ConversationRelay WebSocket.
+ * Returns TwiML XML that tells Twilio to open a media-stream WebSocket.
  *
  * Supports two flows:
  * - **Outbound** (callSessionId present in query): uses the existing session
@@ -385,207 +256,57 @@ export async function handleVoiceWebhook(req: Request): Promise<Response> {
 /**
  * Shared TwiML generation for both inbound and outbound voice webhooks.
  *
- * Resolves the telephony STT routing strategy from `services.stt.provider`
- * and branches:
+ * Every call connects over the media-stream transport. Setup-flow routing
+ * (`routeSetup`) is owned by the media-stream server, which resolves it
+ * when Twilio's `start` frame arrives — no routing happens at TwiML time.
  *
- * - **`conversation-relay-native`** — emits `<Connect><ConversationRelay>`
- *   TwiML with Twilio-native STT attributes (`transcriptionProvider`,
- *   `speechModel`). Used for deepgram and google-gemini.
- *
- * - **`media-stream-custom`** — emits `<Connect><Stream>` TwiML so the
- *   daemon receives raw audio for server-side transcription. Used for
- *   openai-whisper.
+ * The one TwiML-time gate is credential readiness: the daemon performs
+ * both STT and TTS on this transport, so when
+ * {@link resolveTelephonyCredentialReadiness} reports a gap the webhook
+ * returns `<Say>` setup-required copy plus `<Hangup/>` (audible via
+ * Twilio-hosted TTS even when the daemon's TTS is the broken half) and
+ * records a `telephony_credential_preflight_failed` call event instead of
+ * connecting a stream that cannot work.
  *
  * When `verificationSessionId` is provided, it is included as a
  * `<Parameter>` in the TwiML for observability and compatibility with
  * the Twilio setup payload. The persisted call session mode is the
- * primary signal for deterministic flow selection in the relay server.
+ * primary signal for deterministic flow selection at stream start.
  */
 async function buildVoiceWebhookTwiml(
   callSessionId: string,
-  sessionContext: {
-    task: string | null;
-    toNumber: string;
-    fromNumber: string;
-    direction: "inbound" | "outbound";
-    inviteFriendName: string | null;
-    inviteGuardianName: string | null;
-  } | null,
   verificationSessionId?: string | null,
 ): Promise<string> {
-  const cfg = loadConfig();
-  const profile = resolveVoiceQualityProfile(cfg);
-
-  log.info(
-    { callSessionId, ttsProvider: profile.ttsProvider, voice: profile.voice },
-    "Voice quality profile resolved",
-  );
-
-  // Resolve telephony STT strategy from services.stt.provider.
-  // The routing resolver handles speech-model defaults internally per provider.
-  const routingResult = resolveTelephonySttRouting();
-
-  // Derive Deepgram fallback values from the provider catalog so they stay
-  // in sync with the single source of truth. Hardcoded strings are kept only
-  // as a final safety net in case the catalog entry is missing.
-  const dgEntry = getProviderEntry("deepgram");
-  const fallbackProvider =
-    dgEntry?.telephonyRouting.twilioNativeMapping?.provider ?? "Deepgram";
-  const fallbackModel =
-    dgEntry?.telephonyRouting.twilioNativeMapping?.defaultSpeechModel ??
-    "nova-3";
-
-  if (routingResult.status === "unknown-provider") {
-    log.error(
-      {
-        callSessionId,
-        providerId: routingResult.providerId,
-        reason: routingResult.reason,
-      },
-      "Telephony STT routing failed — unknown provider; falling back to ConversationRelay with Deepgram",
-    );
-    // Graceful degradation: fall back to Deepgram ConversationRelay so
-    // calls don't fail entirely on a misconfigured provider.
-    return buildConversationRelayTwiml(
-      callSessionId,
-      profile,
-      sessionContext,
-      verificationSessionId,
-      { transcriptionProvider: fallbackProvider, speechModel: fallbackModel },
-    );
-  }
-
-  const { strategy } = routingResult;
-
-  if (strategy.strategy === "conversation-relay-native") {
-    return buildConversationRelayTwiml(
-      callSessionId,
-      profile,
-      sessionContext,
-      verificationSessionId,
-      {
-        transcriptionProvider: strategy.transcriptionProvider,
-        speechModel: strategy.speechModel,
-      },
-    );
-  }
-
-  // media-stream-custom path — preflight check to reject interactive setup
-  // flows that the media-stream transport cannot support. The media-stream
-  // server has a defensive fallback for these cases, but catching them here
-  // avoids bootstrapping a WebSocket session that will immediately fail.
-  const session = getCallSession(callSessionId);
-  const from = sessionContext?.fromNumber ?? "";
-  const to = sessionContext?.toNumber ?? "";
-
-  // Resolve the phone channel's inbound admission floor so this preflight
-  // classification matches the real enforcement at stream start — a
-  // floor-denied caller is recognized as `deny` here, not `normal_call`.
-  // The reader fails open to `null` by contract, so a transport hiccup
-  // admits the caller.
-  const admissionPolicy = await getChannelAdmissionPolicy("phone");
-
-  // Verdict-first caller trust so this preflight matches handleSetup's ACL.
-  // routeSetup uses it when present and not resolutionFailed, else falls back
-  // to local resolution. The reader returns null on failure, keeping the
-  // local path on a gateway blip.
-  const isInbound = sessionContext?.direction !== "outbound";
-  const otherPartyNumber = isInbound ? from : to;
-  const verdict = await getPhoneCallerVerdict(otherPartyNumber);
-
-  const { outcome } = routeSetup({
-    callSessionId,
-    session: session ?? null,
-    from,
-    to,
-    admissionPolicy,
-    verdict,
-  });
-
-  // The media-stream transport supports normal_call and deny (which speaks
-  // a message and tears down). All other outcomes require interactive
-  // sub-flows (DTMF entry, name capture, guardian wait) that media-stream
-  // cannot perform. Reject these deterministically before stream bootstrap.
-  if (outcome.action !== "normal_call" && outcome.action !== "deny") {
+  const readiness = await resolveTelephonyCredentialReadiness();
+  if (readiness.status === "not-ready") {
     log.warn(
-      {
-        callSessionId,
-        setupAction: outcome.action,
-        strategy: "media-stream-custom",
-      },
-      "Media-stream preflight rejected unsupported interactive setup flow — falling back to ConversationRelay with Deepgram",
-    );
-    // Fall back to ConversationRelay so the interactive flow can proceed
-    // through the relay server which supports it natively.
-    return buildConversationRelayTwiml(
-      callSessionId,
-      profile,
-      sessionContext,
-      verificationSessionId,
-      { transcriptionProvider: fallbackProvider, speechModel: fallbackModel },
+      { callSessionId, missing: readiness.missing },
+      "Telephony credential preflight failed — returning setup-required TwiML",
     );
+    recordCallEvent(callSessionId, "telephony_credential_preflight_failed", {
+      missing: readiness.missing,
+    });
+    return buildSetupRequiredTwiml(readiness.userMessage);
   }
 
   return buildMediaStreamTwiml(callSessionId, verificationSessionId);
 }
 
 /**
- * Build ConversationRelay TwiML for Twilio-native STT providers.
+ * Build `<Say>` + `<Hangup/>` TwiML for calls blocked by the credential
+ * preflight, so the caller hears why the call cannot proceed.
  */
-async function buildConversationRelayTwiml(
-  callSessionId: string,
-  profile: ReturnType<typeof resolveVoiceQualityProfile>,
-  sessionContext: {
-    task: string | null;
-    toNumber: string;
-    fromNumber: string;
-    direction: "inbound" | "outbound";
-    inviteFriendName: string | null;
-    inviteGuardianName: string | null;
-  } | null,
-  verificationSessionId: string | null | undefined,
-  sttAttrs: { transcriptionProvider: string; speechModel: string | undefined },
-): Promise<string> {
-  const rawHints = await resolveCallHints(sessionContext, profile.hints);
-
-  const speechConfig: TwilioRelaySpeechConfig = {
-    transcriptionProvider: sttAttrs.transcriptionProvider,
-    speechModel: sttAttrs.speechModel,
-    hints: rawHints && rawHints.length > 0 ? rawHints : undefined,
-    interruptSensitivity: profile.interruptSensitivity,
-  };
-
-  const relayUrl = buildTwilioRelayUrl(TWILIO_PUBLIC_BASE_URL_PLACEHOLDER);
-  const welcomeGreeting = buildWelcomeGreeting(sessionContext?.task ?? null);
-  const relayToken = TWILIO_RELAY_TOKEN_PLACEHOLDER;
-
-  const customParameters: Record<string, string> | undefined =
-    verificationSessionId ? { verificationSessionId } : undefined;
-
-  const twiml = generateTwiML(
-    callSessionId,
-    relayUrl,
-    welcomeGreeting,
-    profile,
-    speechConfig,
-    relayToken,
-    customParameters,
-  );
-
-  log.info(
-    {
-      callSessionId,
-      strategy: "conversation-relay-native",
-      transcriptionProvider: sttAttrs.transcriptionProvider,
-    },
-    "Returning ConversationRelay TwiML",
-  );
-
-  return twiml;
+function buildSetupRequiredTwiml(userMessage: string): string {
+  const sayCopy = `${userMessage} Please finish voice setup and call again. Goodbye.`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <Say>${escapeXml(sayCopy)}</Say>
+  <Hangup/>
+</Response>`;
 }
 
 /**
- * Build Stream TwiML for custom media-stream STT providers.
+ * Build Stream TwiML connecting the call to the daemon's media-stream server.
  */
 function buildMediaStreamTwiml(
   callSessionId: string,
@@ -606,10 +327,7 @@ function buildMediaStreamTwiml(
     customParameters,
   );
 
-  log.info(
-    { callSessionId, strategy: "media-stream-custom" },
-    "Returning Stream TwiML",
-  );
+  log.info({ callSessionId }, "Returning Stream TwiML");
 
   return twiml;
 }
@@ -779,22 +497,8 @@ export async function handleStatusCallback(req: Request): Promise<Response> {
   return new Response(null, { status: 200 });
 }
 
-/**
- * Called when the ConversationRelay connection ends.
- * Returns empty TwiML to acknowledge.
- */
-export async function handleConnectAction(_req: Request): Promise<Response> {
-  log.info("ConversationRelay connect-action callback received");
-  return new Response('<?xml version="1.0" encoding="UTF-8"?><Response/>', {
-    status: 200,
-    headers: { "Content-Type": "text/xml" },
-  });
-}
-
 // ── Transport-agnostic internal route handlers ───────────────────────
 
-const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response/>';
-
 /**
  * Internal voice-webhook handler for gateway→runtime forwarding.
  * Accepts JSON body `{ params, originalUrl? }` from the gateway.
@@ -832,11 +536,3 @@ export function handleInternalStatusCallback({
   processStatusCallback(params);
   return new RouteResponse(null, {});
 }
-
-/**
- * Internal connect-action handler for gateway→runtime forwarding.
- */
-export function handleInternalConnectAction(): RouteResponse {
-  log.info("ConversationRelay connect-action callback received");
-  return new RouteResponse(EMPTY_TWIML, TWIML_HEADERS);
-}

package/src/calls/types.ts

@@ -16,6 +16,7 @@ export type CallEventType =
   | "user_instruction_relayed"
   | "call_ended"
   | "call_failed"
+  | "telephony_credential_preflight_failed"
   | "callee_verification_started"
   | "callee_verification_succeeded"
   | "callee_verification_failed"
@@ -55,9 +56,10 @@ export type PendingQuestionStatus =
   | "cancelled";
 
 /**
- * Explicit call mode written at session creation time. The relay server
- * uses this as the primary signal for deterministic flow selection,
- * with Twilio setup custom parameters as a secondary/observability signal.
+ * Explicit call mode written at session creation time. The media-stream
+ * server's setup router uses this as the primary signal for deterministic
+ * flow selection, with Twilio custom parameters as a secondary/observability
+ * signal.
  */
 export type CallMode = "normal" | "verification" | "invite";
 

package/src/calls/voice-ingress-preflight.ts

@@ -2,6 +2,7 @@ import { getIsPlatform } from "../config/env-registry.js";
 import { loadConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/types.js";
 import { getPublicBaseUrl } from "../inbound/public-ingress-urls.js";
+import { resolveTelephonyCredentialReadiness } from "./telephony-credential-preflight.js";
 
 const SERVICE_UNAVAILABLE_STATUS = 503 as const;
 
@@ -32,6 +33,14 @@ function fail(error: string): VoiceIngressPreflightFailure {
 export async function preflightVoiceIngress(): Promise<VoiceIngressPreflightResult> {
   const ingressConfig = loadConfig();
 
+  // The daemon performs both STT and TTS on the media-stream transport —
+  // in every deployment mode, platform-hosted included — so credential
+  // readiness gates outbound placement before any Twilio call is made.
+  const readiness = await resolveTelephonyCredentialReadiness();
+  if (readiness.status === "not-ready") {
+    return fail(readiness.userMessage);
+  }
+
   // Platform-callback deployments register routes with the platform and receive
   // stable callback URLs. No public ingress URL or local gateway is involved.
   if (getIsPlatform()) {

package/src/calls/voice-quality.ts

@@ -17,15 +17,13 @@ export interface VoiceQualityProfile {
 /**
  * Build a Twilio-compatible ElevenLabs voice string.
  *
- * Twilio ConversationRelay accepts:
+ * Twilio's native TTS voice attribute accepts:
  *   - bare voiceId
  *   - voiceId-model-speed_stability_similarity
  *
  * We default to bare voiceId unless a model is explicitly configured.
  * This avoids forcing model/tuning suffixes that may be rejected for some
  * voice + model combinations.
- *
- * See: https://www.twilio.com/docs/voice/conversationrelay/voice-configuration
  */
 export function buildElevenLabsVoiceSpec(config: {
   voiceId: string;
@@ -47,7 +45,7 @@ export function buildElevenLabsVoiceSpec(config: {
 }
 
 /**
- * Resolve a valid native Twilio voice for the ConversationRelay TwiML.
+ * Resolve a valid native Twilio voice for the configured TTS provider.
  *
  * Returns the registered {@link NativeTwilioVoiceSpec} for `providerId` when one
  * exists; otherwise — no builder registered (e.g. a synthesized-play provider
@@ -81,23 +79,20 @@ function resolveNativeTwilioVoice(
 /**
  * Resolve the effective voice quality profile from config.
  *
- * The TwiML always carries a valid, non-empty native Twilio voice:
+ * The profile always carries a valid, non-empty native Twilio voice:
  *
- * - **native-twilio** providers (e.g. ElevenLabs): Twilio drives TTS with this
- *   voice directly, built from the provider's registered
- *   {@link NativeTwilioVoiceSpec} builder.
- * - **synthesized-play** providers (e.g. Fish Audio): audio is delivered via
- *   `play` messages, so Twilio's native TTS is unused on the happy path. The
- *   voice still matters as a fallback — if synthesis fails mid-call the
- *   controller falls back to native token TTS, and an empty voice makes Twilio
- *   reject the turn with error 64106 ("TTS provider rejected the request due to
- *   invalid parameters") and drop the call. These providers have no registered
- *   native builder, so they resolve to the ElevenLabs fallback voice.
+ * - **native-twilio** providers (e.g. ElevenLabs): the voice is built from
+ *   the provider's registered {@link NativeTwilioVoiceSpec} builder.
+ * - **synthesized-play** providers (e.g. Fish Audio): the daemon synthesizes
+ *   audio itself, so the native voice is a fallback only — an empty voice
+ *   makes Twilio reject a native-TTS turn with error 64106 ("TTS provider
+ *   rejected the request due to invalid parameters") and drop the call.
+ *   These providers have no registered native builder, so they resolve to
+ *   the ElevenLabs fallback voice.
  *
  * NOTE: STT provider and speech model are intentionally NOT part of this
- * profile. STT resolution is handled once in the voice webhook route
- * (`twilio-routes.ts`) via `resolveTelephonySttRouting()` to maintain a
- * single point of ownership.
+ * profile — the daemon owns STT on the media-stream transport (see
+ * `resolveTelephonySttCapability` in providers/speech-to-text/resolve.ts).
  */
 export function resolveVoiceQualityProfile(
   config?: ReturnType<typeof loadConfig>,