@vellumai/assistant 0.4.26 → 0.4.30

package/src/calls/call-domain.ts

@@ -5,24 +5,27 @@
  * to these functions so business logic lives in one place.
  */
 
-import { getTwilioUserPhoneNumber } from '../config/env.js';
-import { loadConfig } from '../config/loader.js';
-import { VALID_CALLER_IDENTITY_MODES } from '../config/schema.js';
-import type { AssistantConfig } from '../config/types.js';
-import { resolveCallbackUrl } from '../inbound/platform-callback-registration.js';
-import { getTwilioStatusCallbackUrl,getTwilioVoiceWebhookUrl } from '../inbound/public-ingress-urls.js';
-import { getOrCreateConversation } from '../memory/conversation-key-store.js';
-import { queueGenerateConversationTitle } from '../memory/conversation-title-service.js';
-import { upsertBinding } from '../memory/external-conversation-store.js';
-import { revokeScopedApprovalGrantsForContext } from '../memory/scoped-approval-grants.js';
-import { DAEMON_INTERNAL_ASSISTANT_ID } from '../runtime/assistant-scope.js';
-import { isGuardian } from '../runtime/channel-guardian-service.js';
-import { getSecureKey } from '../security/secure-keys.js';
-import { getLogger } from '../util/logger.js';
-import { isDeniedNumber } from './call-constants.js';
-import { addPointerMessage } from './call-pointer-messages.js';
-import { getCallController, unregisterCallController } from './call-state.js';
-import { isTerminalState } from './call-state-machine.js';
+import { getTwilioUserPhoneNumber } from "../config/env.js";
+import { loadConfig } from "../config/loader.js";
+import { VALID_CALLER_IDENTITY_MODES } from "../config/schema.js";
+import type { AssistantConfig } from "../config/types.js";
+import { resolveCallbackUrl } from "../inbound/platform-callback-registration.js";
+import {
+  getTwilioStatusCallbackUrl,
+  getTwilioVoiceWebhookUrl,
+} from "../inbound/public-ingress-urls.js";
+import { getOrCreateConversation } from "../memory/conversation-key-store.js";
+import { queueGenerateConversationTitle } from "../memory/conversation-title-service.js";
+import { upsertBinding } from "../memory/external-conversation-store.js";
+import { revokeScopedApprovalGrantsForContext } from "../memory/scoped-approval-grants.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { isGuardian } from "../runtime/channel-guardian-service.js";
+import { getSecureKey } from "../security/secure-keys.js";
+import { getLogger } from "../util/logger.js";
+import { isDeniedNumber } from "./call-constants.js";
+import { addPointerMessage } from "./call-pointer-messages.js";
+import { getCallController, unregisterCallController } from "./call-state.js";
+import { isTerminalState } from "./call-state-machine.js";
 import {
   answerPendingQuestion,
   createCallSession,
@@ -32,13 +35,13 @@ import {
   getCallSessionByCallSid,
   getPendingQuestion,
   updateCallSession,
-} from './call-store.js';
-import { activeRelayConnections } from './relay-server.js';
-import { getTwilioConfig } from './twilio-config.js';
-import { TwilioConversationRelayProvider } from './twilio-provider.js';
-import type { CallSession } from './types.js';
+} from "./call-store.js";
+import { activeRelayConnections } from "./relay-server.js";
+import { getTwilioConfig } from "./twilio-config.js";
+import { TwilioConversationRelayProvider } from "./twilio-provider.js";
+import type { CallSession } from "./types.js";
 
-const log = getLogger('call-domain');
+const log = getLogger("call-domain");
 
 const E164_REGEX = /^\+\d+$/;
 
@@ -48,7 +51,7 @@ export interface StartCallResult {
   ok: true;
   session: CallSession;
   callSid: string;
-  callerIdentityMode: 'assistant_number' | 'user_number';
+  callerIdentityMode: "assistant_number" | "user_number";
 }
 
 export interface CallError {
@@ -63,7 +66,7 @@ export type StartCallInput = {
   context?: string;
   conversationId: string;
   assistantId?: string;
-  callerIdentityMode?: 'assistant_number' | 'user_number';
+  callerIdentityMode?: "assistant_number" | "user_number";
 };
 
 export type CancelCallInput = {
@@ -85,10 +88,20 @@ export type RelayInstructionInput = {
 
 // ── Caller identity resolution ───────────────────────────────────────
 
-export type CallerIdentitySource = 'per_call_override' | 'implicit_default' | 'user_config' | 'secure_key' | 'env_var';
+export type CallerIdentitySource =
+  | "per_call_override"
+  | "implicit_default"
+  | "user_config"
+  | "secure_key"
+  | "env_var";
 
 export type CallerIdentityResult =
-  | { ok: true; mode: 'assistant_number' | 'user_number'; fromNumber: string; source: CallerIdentitySource }
+  | {
+      ok: true;
+      mode: "assistant_number" | "user_number";
+      fromNumber: string;
+      source: CallerIdentitySource;
+    }
   | { ok: false; error: string };
 
 /**
@@ -109,63 +122,88 @@ export type CallerIdentityResult =
  */
 export async function resolveCallerIdentity(
   config: AssistantConfig,
-  requestedMode?: 'assistant_number' | 'user_number',
+  requestedMode?: "assistant_number" | "user_number",
   assistantId?: string,
 ): Promise<CallerIdentityResult> {
   const identityConfig = config.calls.callerIdentity;
-  let mode: 'assistant_number' | 'user_number';
+  let mode: "assistant_number" | "user_number";
   let source: CallerIdentitySource;
 
   if (requestedMode != null) {
-    if (!(VALID_CALLER_IDENTITY_MODES as readonly string[]).includes(requestedMode)) {
-      return { ok: false, error: `Invalid callerIdentityMode: "${requestedMode}". Must be one of: ${VALID_CALLER_IDENTITY_MODES.join(', ')}` };
+    if (
+      !(VALID_CALLER_IDENTITY_MODES as readonly string[]).includes(
+        requestedMode,
+      )
+    ) {
+      return {
+        ok: false,
+        error: `Invalid callerIdentityMode: "${requestedMode}". Must be one of: ${VALID_CALLER_IDENTITY_MODES.join(
+          ", ",
+        )}`,
+      };
     }
     if (!identityConfig.allowPerCallOverride) {
-      log.warn({ requestedMode }, 'Caller identity override rejected — per-call override is disabled in configuration');
-      return { ok: false, error: 'Per-call caller identity override is disabled in configuration' };
+      log.warn(
+        { requestedMode },
+        "Caller identity override rejected — per-call override is disabled in configuration",
+      );
+      return {
+        ok: false,
+        error: "Per-call caller identity override is disabled in configuration",
+      };
     }
     mode = requestedMode;
-    source = 'per_call_override';
+    source = "per_call_override";
   } else {
     // Implicit calls always use assistant_number regardless of config
-    mode = 'assistant_number';
-    source = 'implicit_default';
+    mode = "assistant_number";
+    source = "implicit_default";
   }
 
-  if (mode === 'assistant_number') {
+  if (mode === "assistant_number") {
     const twilioConfig = getTwilioConfig(assistantId);
-    log.info({ mode, source, fromNumber: twilioConfig.phoneNumber }, 'Resolved caller identity');
+    log.info(
+      { mode, source, fromNumber: twilioConfig.phoneNumber },
+      "Resolved caller identity",
+    );
     return { ok: true, mode, fromNumber: twilioConfig.phoneNumber, source };
   }
 
   // user_number mode: resolve from config or secure key, tracking where the number came from
-  let userNumber = '';
+  let userNumber = "";
   let numberSource: CallerIdentitySource = source;
 
   if (identityConfig.userNumber) {
     userNumber = identityConfig.userNumber;
-    numberSource = 'user_config';
+    numberSource = "user_config";
   } else if (getTwilioUserPhoneNumber()) {
     userNumber = getTwilioUserPhoneNumber()!;
-    numberSource = 'env_var';
+    numberSource = "env_var";
   } else {
-    const secureKeyValue = getSecureKey('credential:twilio:user_phone_number');
+    const secureKeyValue = getSecureKey("credential:twilio:user_phone_number");
     if (secureKeyValue) {
       userNumber = secureKeyValue;
-      numberSource = 'secure_key';
+      numberSource = "secure_key";
     }
   }
 
   if (!userNumber) {
-    log.warn({ mode, source }, 'Caller identity resolution failed — no user phone number configured');
+    log.warn(
+      { mode, source },
+      "Caller identity resolution failed — no user phone number configured",
+    );
     return {
       ok: false,
-      error: 'user_number mode requires a user phone number. Set calls.callerIdentity.userNumber in config or store credential:twilio:user_phone_number via the credential_store tool.',
+      error:
+        "user_number mode requires a user phone number. Set calls.callerIdentity.userNumber in config or store credential:twilio:user_phone_number via the credential_store tool.",
     };
   }
 
   if (!E164_REGEX.test(userNumber)) {
-    log.warn({ mode, source: numberSource, userNumber }, 'User phone number is not in E.164 format');
+    log.warn(
+      { mode, source: numberSource, userNumber },
+      "User phone number is not in E.164 format",
+    );
     return {
       ok: false,
       error: `User phone number "${userNumber}" is not in E.164 format (must start with + followed by digits, e.g. +14155551234). Check calls.callerIdentity.userNumber in config or credential:twilio:user_phone_number.`,
@@ -176,11 +214,17 @@ export async function resolveCallerIdentity(
   const provider = new TwilioConversationRelayProvider();
   const eligibility = await provider.checkCallerIdEligibility(userNumber);
   if (!eligibility.eligible) {
-    log.warn({ mode, source: numberSource, userNumber, reason: eligibility.reason }, 'Caller ID eligibility check failed');
+    log.warn(
+      { mode, source: numberSource, userNumber, reason: eligibility.reason },
+      "Caller ID eligibility check failed",
+    );
     return { ok: false, error: eligibility.reason! };
   }
 
-  log.info({ mode, source: numberSource, fromNumber: userNumber }, 'Resolved caller identity');
+  log.info(
+    { mode, source: numberSource, fromNumber: userNumber },
+    "Resolved caller identity",
+  );
   return { ok: true, mode, fromNumber: userNumber, source: numberSource };
 }
 
@@ -209,31 +253,41 @@ export type CreateInboundVoiceSessionResult = {
 export function createInboundVoiceSession(
   input: CreateInboundVoiceSessionInput,
 ): CreateInboundVoiceSessionResult {
-  const { callSid, fromNumber, toNumber, assistantId = DAEMON_INTERNAL_ASSISTANT_ID } = input;
+  const {
+    callSid,
+    fromNumber,
+    toNumber,
+    assistantId = DAEMON_INTERNAL_ASSISTANT_ID,
+  } = input;
 
   // Check if a session already exists for this CallSid (replay protection)
   const existing = getCallSessionByCallSid(callSid);
   if (existing) {
-    log.info({ callSid, callSessionId: existing.id }, 'Reusing existing session for inbound CallSid');
+    log.info(
+      { callSid, callSessionId: existing.id },
+      "Reusing existing session for inbound CallSid",
+    );
     return { session: existing, created: false };
   }
 
   // Create a dedicated voice conversation keyed by CallSid so inbound calls
   // get their own conversation thread.
-  const voiceConvKey = assistantId && assistantId !== DAEMON_INTERNAL_ASSISTANT_ID
-    ? `asst:${assistantId}:voice:inbound:${callSid}`
-    : `voice:inbound:${callSid}`;
-  const { conversationId: voiceConversationId } = getOrCreateConversation(voiceConvKey);
+  const voiceConvKey =
+    assistantId && assistantId !== DAEMON_INTERNAL_ASSISTANT_ID
+      ? `asst:${assistantId}:voice:inbound:${callSid}`
+      : `voice:inbound:${callSid}`;
+  const { conversationId: voiceConversationId } =
+    getOrCreateConversation(voiceConvKey);
 
   upsertBinding({
     conversationId: voiceConversationId,
-    sourceChannel: 'voice',
+    sourceChannel: "voice",
     externalChatId: callSid,
   });
 
   const session = createCallSession({
     conversationId: voiceConversationId,
-    provider: 'twilio',
+    provider: "twilio",
     fromNumber,
     toNumber,
     assistantId,
@@ -242,17 +296,25 @@ export function createInboundVoiceSession(
   updateCallSession(session.id, { providerCallSid: callSid });
   session.providerCallSid = callSid;
 
-  const callerIsGuardian = isGuardian(assistantId, 'voice', fromNumber);
+  const callerIsGuardian = isGuardian(assistantId, "voice", fromNumber);
   const metadataHints: string[] = [
-    callerIsGuardian ? 'Caller is the guardian' : 'Caller is not the guardian (external caller)',
-    `Timestamp: ${new Date().toLocaleString('en-US', { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' })}`,
+    callerIsGuardian
+      ? "Caller is the guardian"
+      : "Caller is not the guardian (external caller)",
+    `Timestamp: ${new Date().toLocaleString("en-US", {
+      weekday: "short",
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+    })}`,
   ];
 
   queueGenerateConversationTitle({
     conversationId: voiceConversationId,
     context: {
-      origin: 'voice_inbound',
-      sourceChannel: 'voice',
+      origin: "voice_inbound",
+      sourceChannel: "voice",
       assistantId,
       systemHint: `Inbound call from ${fromNumber}`,
       metadataHints,
@@ -260,8 +322,15 @@ export function createInboundVoiceSession(
   });
 
   log.info(
-    { callSessionId: session.id, callSid, voiceConversationId, from: fromNumber, to: toNumber, assistantId },
-    'Created new inbound voice session',
+    {
+      callSessionId: session.id,
+      callSid,
+      voiceConversationId,
+      from: fromNumber,
+      to: toNumber,
+      assistantId,
+    },
+    "Created new inbound voice session",
   );
 
   return { session, created: true };
@@ -272,27 +341,49 @@ export function createInboundVoiceSession(
 /**
  * Initiate a new outbound call.
  */
-export async function startCall(input: StartCallInput): Promise<StartCallResult | CallError> {
-  const { phoneNumber, task, context: callContext, conversationId, callerIdentityMode, assistantId = DAEMON_INTERNAL_ASSISTANT_ID } = input;
-
-  if (!phoneNumber || typeof phoneNumber !== 'string') {
-    return { ok: false, error: 'phone_number is required and must be a string', status: 400 };
+export async function startCall(
+  input: StartCallInput,
+): Promise<StartCallResult | CallError> {
+  const {
+    phoneNumber,
+    task,
+    context: callContext,
+    conversationId,
+    callerIdentityMode,
+    assistantId = DAEMON_INTERNAL_ASSISTANT_ID,
+  } = input;
+
+  if (!phoneNumber || typeof phoneNumber !== "string") {
+    return {
+      ok: false,
+      error: "phone_number is required and must be a string",
+      status: 400,
+    };
   }
 
   if (!E164_REGEX.test(phoneNumber)) {
     return {
       ok: false,
-      error: 'phone_number must be in E.164 format (starts with + followed by digits, e.g. +14155551234)',
+      error:
+        "phone_number must be in E.164 format (starts with + followed by digits, e.g. +14155551234)",
       status: 400,
     };
   }
 
-  if (!task || typeof task !== 'string' || task.trim().length === 0) {
-    return { ok: false, error: 'task is required and must be a non-empty string', status: 400 };
+  if (!task || typeof task !== "string" || task.trim().length === 0) {
+    return {
+      ok: false,
+      error: "task is required and must be a non-empty string",
+      status: 400,
+    };
   }
 
   if (isDeniedNumber(phoneNumber)) {
-    return { ok: false, error: 'This phone number is not allowed to be called', status: 403 };
+    return {
+      ok: false,
+      error: "This phone number is not allowed to be called",
+      status: 403,
+    };
   }
 
   let sessionId: string | null = null;
@@ -302,7 +393,11 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     const provider = new TwilioConversationRelayProvider();
 
     // Resolve which phone number to use as caller ID
-    const identityResult = await resolveCallerIdentity(ingressConfig, callerIdentityMode, assistantId);
+    const identityResult = await resolveCallerIdentity(
+      ingressConfig,
+      callerIdentityMode,
+      assistantId,
+    );
     if (!identityResult.ok) {
       return { ok: false, error: identityResult.error, status: 400 };
     }
@@ -310,7 +405,7 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
 
     const session = createCallSession({
       conversationId,
-      provider: 'twilio',
+      provider: "twilio",
       fromNumber,
       toNumber: phoneNumber,
       task: callContext ? `${task}\n\nContext: ${callContext}` : task,
@@ -327,11 +422,12 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     const voiceConvKey = assistantId
       ? `asst:${assistantId}:voice:call:${session.id}`
       : `voice:call:${session.id}`;
-    const { conversationId: voiceConversationId } = getOrCreateConversation(voiceConvKey);
+    const { conversationId: voiceConversationId } =
+      getOrCreateConversation(voiceConvKey);
 
     upsertBinding({
       conversationId: voiceConversationId,
-      sourceChannel: 'voice',
+      sourceChannel: "voice",
       externalChatId: session.id,
     });
 
@@ -345,29 +441,45 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     queueGenerateConversationTitle({
       conversationId: voiceConversationId,
       context: {
-        origin: 'voice_outbound',
-        sourceChannel: 'voice',
+        origin: "voice_outbound",
+        sourceChannel: "voice",
         assistantId,
         systemHint: `Outbound call to ${phoneNumber}`,
         triggerTextSnippet: task,
         metadataHints: [
-          `Timestamp: ${new Date().toLocaleString('en-US', { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' })}`,
+          `Timestamp: ${new Date().toLocaleString("en-US", {
+            weekday: "short",
+            month: "short",
+            day: "numeric",
+            hour: "numeric",
+            minute: "2-digit",
+          })}`,
         ],
       },
     });
 
-    log.info({ callSessionId: session.id, voiceConversationId, initiatedFrom: conversationId, to: phoneNumber, from: fromNumber, task }, 'Initiating outbound call');
+    log.info(
+      {
+        callSessionId: session.id,
+        voiceConversationId,
+        initiatedFrom: conversationId,
+        to: phoneNumber,
+        from: fromNumber,
+        task,
+      },
+      "Initiating outbound call",
+    );
 
     const webhookUrl = await resolveCallbackUrl(
       () => getTwilioVoiceWebhookUrl(ingressConfig, session.id),
-      'webhooks/twilio/voice',
-      'twilio_voice',
+      "webhooks/twilio/voice",
+      "twilio_voice",
       { callSessionId: session.id },
     );
     const statusCallbackUrl = await resolveCallbackUrl(
       () => getTwilioStatusCallbackUrl(ingressConfig),
-      'webhooks/twilio/status',
-      'twilio_status',
+      "webhooks/twilio/status",
+      "twilio_status",
     );
 
     const { callSid } = await provider.initiateCall({
@@ -379,11 +491,17 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
 
     updateCallSession(session.id, { providerCallSid: callSid });
 
-    log.info({ callSessionId: session.id, callSid }, 'Call initiated successfully');
+    log.info(
+      { callSessionId: session.id, callSid },
+      "Call initiated successfully",
+    );
 
     // Post a concise pointer message in the initiating conversation
-    addPointerMessage(conversationId, 'started', phoneNumber).catch((err) => {
-      log.warn({ conversationId, err }, 'Failed to post call-started pointer message');
+    addPointerMessage(conversationId, "started", phoneNumber).catch((err) => {
+      log.warn(
+        { conversationId, err },
+        "Failed to post call-started pointer message",
+      );
     });
 
     return {
@@ -394,24 +512,37 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log.error({ err, phoneNumber }, 'Failed to initiate call');
+    log.error({ err, phoneNumber }, "Failed to initiate call");
 
     // FK constraint failure on conversation_id means the conversationId is invalid
-    if (err instanceof Error && msg.includes('FOREIGN KEY constraint failed') && !sessionId) {
-      return { ok: false, error: `Invalid conversationId: no conversation found with ID ${conversationId}`, status: 400 };
+    if (
+      err instanceof Error &&
+      msg.includes("FOREIGN KEY constraint failed") &&
+      !sessionId
+    ) {
+      return {
+        ok: false,
+        error: `Invalid conversationId: no conversation found with ID ${conversationId}`,
+        status: 400,
+      };
     }
 
     if (sessionId) {
       updateCallSession(sessionId, {
-        status: 'failed',
+        status: "failed",
         endedAt: Date.now(),
         lastError: msg,
       });
     }
 
     // Post a failure pointer message in the initiating conversation
-    addPointerMessage(conversationId, 'failed', phoneNumber, { reason: msg }).catch((pointerErr) => {
-      log.warn({ conversationId, err: pointerErr }, 'Failed to post call-failed pointer message');
+    addPointerMessage(conversationId, "failed", phoneNumber, {
+      reason: msg,
+    }).catch((pointerErr) => {
+      log.warn(
+        { conversationId, err: pointerErr },
+        "Failed to post call-failed pointer message",
+      );
     });
 
     return { ok: false, error: `Error initiating call: ${msg}`, status: 500 };
@@ -425,24 +556,45 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
 export function getCallStatus(
   callSessionId?: string,
   conversationId?: string,
-): { ok: true; session: CallSession; pendingQuestion?: { id: string; questionText: string } } | CallError {
+):
+  | {
+      ok: true;
+      session: CallSession;
+      pendingQuestion?: { id: string; questionText: string };
+    }
+  | CallError {
   let session: CallSession | null = null;
 
   if (callSessionId) {
     session = getCallSession(callSessionId);
     if (!session) {
-      return { ok: false, error: `No call session found with ID ${callSessionId}`, status: 404 };
+      return {
+        ok: false,
+        error: `No call session found with ID ${callSessionId}`,
+        status: 404,
+      };
     }
   } else if (conversationId) {
     session = getActiveCallSessionForConversation(conversationId);
     if (!session) {
-      return { ok: false, error: 'No active call found in the current conversation', status: 404 };
+      return {
+        ok: false,
+        error: "No active call found in the current conversation",
+        status: 404,
+      };
     }
   } else {
-    return { ok: false, error: 'Either callSessionId or conversationId is required', status: 400 };
+    return {
+      ok: false,
+      error: "Either callSessionId or conversationId is required",
+      status: 400,
+    };
   }
 
-  log.info({ callSessionId: session.id, status: session.status }, 'Checking call status');
+  log.info(
+    { callSessionId: session.id, status: session.status },
+    "Checking call status",
+  );
 
   const pendingQuestion = getPendingQuestion(session.id);
   return {
@@ -457,19 +609,29 @@ export function getCallStatus(
 /**
  * Cancel an active call. Cleans up relay connections and controllers.
  */
-export async function cancelCall(input: CancelCallInput): Promise<{ ok: true; session: CallSession } | CallError> {
+export async function cancelCall(
+  input: CancelCallInput,
+): Promise<{ ok: true; session: CallSession } | CallError> {
   const { callSessionId, reason } = input;
 
   const session = getCallSession(callSessionId);
   if (!session) {
-    return { ok: false, error: `No call session found with ID ${callSessionId}`, status: 404 };
+    return {
+      ok: false,
+      error: `No call session found with ID ${callSessionId}`,
+      status: 404,
+    };
   }
 
   if (isTerminalState(session.status)) {
-    return { ok: false, error: `Call session ${callSessionId} has already ended with status: ${session.status}`, status: 409 };
+    return {
+      ok: false,
+      error: `Call session ${callSessionId} has already ended with status: ${session.status}`,
+      status: 409,
+    };
   }
 
-  log.info({ callSessionId, reason }, 'Cancelling call');
+  log.info({ callSessionId, reason }, "Cancelling call");
 
   // Terminate the call via the provider API
   if (session.providerCallSid) {
@@ -477,7 +639,10 @@ export async function cancelCall(input: CancelCallInput): Promise<{ ok: true; se
       const provider = new TwilioConversationRelayProvider();
       await provider.endCall(session.providerCallSid);
     } catch (endErr) {
-      log.warn({ err: endErr, callSessionId, callSid: session.providerCallSid }, 'Failed to terminate call via provider API — proceeding with cleanup');
+      log.warn(
+        { err: endErr, callSessionId, callSid: session.providerCallSid },
+        "Failed to terminate call via provider API — proceeding with cleanup",
+      );
     }
   }
 
@@ -498,7 +663,7 @@ export async function cancelCall(input: CancelCallInput): Promise<{ ok: true; se
 
   // Update session status
   updateCallSession(callSessionId, {
-    status: 'cancelled',
+    status: "cancelled",
     endedAt: Date.now(),
   });
 
@@ -511,22 +676,41 @@ export async function cancelCall(input: CancelCallInput): Promise<{ ok: true; se
   // but always sets conversationId.
   try {
     revokeScopedApprovalGrantsForContext({ callSessionId });
-    revokeScopedApprovalGrantsForContext({ conversationId: session.conversationId });
+    revokeScopedApprovalGrantsForContext({
+      conversationId: session.conversationId,
+    });
   } catch (err) {
-    log.warn({ err, callSessionId }, 'Failed to revoke scoped grants on call cancel');
+    log.warn(
+      { err, callSessionId },
+      "Failed to revoke scoped grants on call cancel",
+    );
   }
 
   // Re-check final status: a concurrent transition (e.g. Twilio callback) may have
   // moved the session to a terminal state before our update, causing it to be skipped.
   const updated = getCallSession(callSessionId);
-  if (updated && updated.status !== 'cancelled') {
-    log.warn({ callSessionId, finalStatus: updated.status }, 'Cancel lost race — session already transitioned to terminal state');
-    return { ok: false, error: `Call session ${callSessionId} transitioned to ${updated.status} before cancellation could be applied`, status: 409 };
+  if (updated && updated.status !== "cancelled") {
+    log.warn(
+      { callSessionId, finalStatus: updated.status },
+      "Cancel lost race — session already transitioned to terminal state",
+    );
+    return {
+      ok: false,
+      error: `Call session ${callSessionId} transitioned to ${updated.status} before cancellation could be applied`,
+      status: 409,
+    };
   }
 
-  log.info({ callSessionId }, 'Call cancelled successfully');
+  log.info({ callSessionId }, "Call cancelled successfully");
 
-  return { ok: true, session: updated ?? { ...session, status: 'cancelled', endedAt: Date.now() } };
+  return {
+    ok: true,
+    session: updated ?? {
+      ...session,
+      status: "cancelled",
+      endedAt: Date.now(),
+    },
+  };
 }
 
 /**
@@ -537,17 +721,26 @@ export async function cancelCall(input: CancelCallInput): Promise<{ ok: true; se
  * state. This allows answers to arrive while the call is active and not paused,
  * as long as the referenced question is still pending.
  */
-export async function answerCall(input: AnswerCallInput): Promise<{ ok: true; questionId: string } | CallError> {
+export async function answerCall(
+  input: AnswerCallInput,
+): Promise<{ ok: true; questionId: string } | CallError> {
   const { callSessionId, answer, pendingQuestionId } = input;
 
-  if (!answer || typeof answer !== 'string') {
-    return { ok: false, error: 'Missing answer', status: 400 };
+  if (!answer || typeof answer !== "string") {
+    return { ok: false, error: "Missing answer", status: 400 };
   }
 
   const controller = getCallController(callSessionId);
   if (!controller) {
-    log.warn({ callSessionId }, 'answerCall: no active controller for call session');
-    return { ok: false, error: 'No active controller for this call', status: 409 };
+    log.warn(
+      { callSessionId },
+      "answerCall: no active controller for call session",
+    );
+    return {
+      ok: false,
+      error: "No active controller for this call",
+      status: 409,
+    };
   }
 
   // When a specific question is targeted, validate it matches the active
@@ -558,41 +751,54 @@ export async function answerCall(input: AnswerCallInput): Promise<{ ok: true; qu
     if (!activeQuestionId) {
       log.warn(
         { callSessionId, pendingQuestionId },
-        'answerCall: pendingQuestionId provided but no consultation is active',
+        "answerCall: pendingQuestionId provided but no consultation is active",
       );
-      return { ok: false, error: 'Referenced question is no longer pending', status: 409 };
+      return {
+        ok: false,
+        error: "Referenced question is no longer pending",
+        status: 409,
+      };
     }
     if (activeQuestionId !== pendingQuestionId) {
       log.warn(
         { callSessionId, pendingQuestionId, activeQuestionId },
-        'answerCall: pendingQuestionId does not match active consultation',
+        "answerCall: pendingQuestionId does not match active consultation",
       );
-      return { ok: false, error: 'Referenced question is stale — a newer consultation has superseded it', status: 409 };
+      return {
+        ok: false,
+        error:
+          "Referenced question is stale — a newer consultation has superseded it",
+        status: 409,
+      };
     }
   }
 
   // Look up the pending question in the store for record-keeping
   const question = getPendingQuestion(callSessionId);
   if (!question) {
-    return { ok: false, error: 'No pending question found', status: 404 };
+    return { ok: false, error: "No pending question found", status: 404 };
   }
 
   // When pendingQuestionId is given, double-check it matches the store record
   if (pendingQuestionId && question.id !== pendingQuestionId) {
     log.warn(
       { callSessionId, pendingQuestionId, storeQuestionId: question.id },
-      'answerCall: store pending question does not match requested pendingQuestionId',
+      "answerCall: store pending question does not match requested pendingQuestionId",
     );
-    return { ok: false, error: 'Referenced question is stale', status: 409 };
+    return { ok: false, error: "Referenced question is stale", status: 409 };
   }
 
   const accepted = await controller.handleUserAnswer(answer);
   if (!accepted) {
     log.warn(
       { callSessionId },
-      'answerCall: controller rejected the answer (no pending consultation)',
+      "answerCall: controller rejected the answer (no pending consultation)",
     );
-    return { ok: false, error: 'Controller is not waiting for an answer', status: 409 };
+    return {
+      ok: false,
+      error: "Controller is not waiting for an answer",
+      status: 409,
+    };
   }
 
   answerPendingQuestion(question.id, answer);
@@ -605,30 +811,52 @@ export async function answerCall(input: AnswerCallInput): Promise<{ ok: true; qu
  * Validates that the call is active and the instruction is non-empty
  * before injecting it into the controller's conversation.
  */
-export async function relayInstruction(input: RelayInstructionInput): Promise<{ ok: true } | CallError> {
+export async function relayInstruction(
+  input: RelayInstructionInput,
+): Promise<{ ok: true } | CallError> {
   const { callSessionId, instructionText } = input;
 
-  if (!instructionText || typeof instructionText !== 'string' || instructionText.trim().length === 0) {
-    return { ok: false, error: 'instructionText is required and must be a non-empty string', status: 400 };
+  if (
+    !instructionText ||
+    typeof instructionText !== "string" ||
+    instructionText.trim().length === 0
+  ) {
+    return {
+      ok: false,
+      error: "instructionText is required and must be a non-empty string",
+      status: 400,
+    };
   }
 
   const session = getCallSession(callSessionId);
   if (!session) {
-    return { ok: false, error: `No call session found with ID ${callSessionId}`, status: 404 };
+    return {
+      ok: false,
+      error: `No call session found with ID ${callSessionId}`,
+      status: 404,
+    };
   }
 
   if (isTerminalState(session.status)) {
-    return { ok: false, error: `Call session ${callSessionId} is not active (status: ${session.status})`, status: 409 };
+    return {
+      ok: false,
+      error: `Call session ${callSessionId} is not active (status: ${session.status})`,
+      status: 409,
+    };
   }
 
   const controller = getCallController(callSessionId);
   if (!controller) {
-    return { ok: false, error: 'No active controller for this call', status: 409 };
+    return {
+      ok: false,
+      error: "No active controller for this call",
+      status: 409,
+    };
   }
 
   await controller.handleUserInstruction(instructionText);
 
-  log.info({ callSessionId }, 'User instruction relayed to controller');
+  log.info({ callSessionId }, "User instruction relayed to controller");
 
   return { ok: true };
 }
@@ -657,10 +885,19 @@ export type StartGuardianVerificationCallResult =
 export async function startGuardianVerificationCall(
   input: StartGuardianVerificationCallInput,
 ): Promise<StartGuardianVerificationCallResult> {
-  const { phoneNumber, guardianVerificationSessionId, assistantId = DAEMON_INTERNAL_ASSISTANT_ID, originConversationId } = input;
+  const {
+    phoneNumber,
+    guardianVerificationSessionId,
+    assistantId = DAEMON_INTERNAL_ASSISTANT_ID,
+    originConversationId,
+  } = input;
 
   if (!phoneNumber || !E164_REGEX.test(phoneNumber)) {
-    return { ok: false, error: 'phone_number must be in E.164 format', status: 400 };
+    return {
+      ok: false,
+      error: "phone_number must be in E.164 format",
+      status: 400,
+    };
   }
 
   let sessionId: string | null = null;
@@ -670,7 +907,11 @@ export async function startGuardianVerificationCall(
     const provider = new TwilioConversationRelayProvider();
 
     // Resolve the assistant's Twilio number as the caller ID
-    const identityResult = await resolveCallerIdentity(config, undefined, assistantId);
+    const identityResult = await resolveCallerIdentity(
+      config,
+      undefined,
+      assistantId,
+    );
     if (!identityResult.ok) {
       return { ok: false, error: identityResult.error, status: 400 };
     }
@@ -683,16 +924,16 @@ export async function startGuardianVerificationCall(
 
     upsertBinding({
       conversationId,
-      sourceChannel: 'voice',
+      sourceChannel: "voice",
       externalChatId: `guardian-verify:${guardianVerificationSessionId}`,
     });
 
     const session = createCallSession({
       conversationId,
-      provider: 'twilio',
+      provider: "twilio",
       fromNumber: identityResult.fromNumber,
       toNumber: phoneNumber,
-      callMode: 'guardian_verification',
+      callMode: "guardian_verification",
       guardianVerificationSessionId,
       assistantId,
       initiatedFromConversationId: originConversationId,
@@ -701,14 +942,14 @@ export async function startGuardianVerificationCall(
 
     const webhookUrl = await resolveCallbackUrl(
       () => getTwilioVoiceWebhookUrl(config, session.id),
-      'webhooks/twilio/voice',
-      'twilio_voice',
+      "webhooks/twilio/voice",
+      "twilio_voice",
       { callSessionId: session.id },
     );
     const statusCallbackUrl = await resolveCallbackUrl(
       () => getTwilioStatusCallbackUrl(config),
-      'webhooks/twilio/status',
-      'twilio_status',
+      "webhooks/twilio/status",
+      "twilio_status",
     );
 
     const { callSid } = await provider.initiateCall({
@@ -724,23 +965,35 @@ export async function startGuardianVerificationCall(
     updateCallSession(session.id, { providerCallSid: callSid });
 
     log.info(
-      { callSessionId: session.id, callSid, guardianVerificationSessionId, to: phoneNumber },
-      'Guardian verification call initiated',
+      {
+        callSessionId: session.id,
+        callSid,
+        guardianVerificationSessionId,
+        to: phoneNumber,
+      },
+      "Guardian verification call initiated",
     );
 
     return { ok: true, callSessionId: session.id, callSid };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log.error({ err, phoneNumber, guardianVerificationSessionId }, 'Failed to initiate guardian verification call');
+    log.error(
+      { err, phoneNumber, guardianVerificationSessionId },
+      "Failed to initiate guardian verification call",
+    );
 
     if (sessionId) {
       updateCallSession(sessionId, {
-        status: 'failed',
+        status: "failed",
         endedAt: Date.now(),
         lastError: msg,
       });
     }
 
-    return { ok: false, error: `Error initiating guardian verification call: ${msg}`, status: 500 };
+    return {
+      ok: false,
+      error: `Error initiating guardian verification call: ${msg}`,
+      status: 500,
+    };
   }
 }