vellum 0.2.0 → 0.2.2

package/src/calls/call-domain.ts

@@ -0,0 +1,276 @@
+/**
+ * Shared domain functions for call operations.
+ *
+ * Both the tool implementations and the HTTP route handlers delegate
+ * to these functions so business logic lives in one place.
+ */
+
+import { getLogger } from '../util/logger.js';
+import { isDeniedNumber } from './call-constants.js';
+import {
+  createCallSession,
+  getCallSession,
+  getActiveCallSessionForConversation,
+  updateCallSession,
+  getPendingQuestion,
+  answerPendingQuestion,
+  expirePendingQuestions,
+} from './call-store.js';
+import { getCallOrchestrator, unregisterCallOrchestrator } from './call-state.js';
+import { activeRelayConnections } from './relay-server.js';
+import { TwilioConversationRelayProvider } from './twilio-provider.js';
+import { getTwilioConfig } from './twilio-config.js';
+import type { CallSession } from './types.js';
+
+const log = getLogger('call-domain');
+
+const E164_REGEX = /^\+\d+$/;
+
+// ── Result types ─────────────────────────────────────────────────────
+
+export interface StartCallResult {
+  ok: true;
+  session: CallSession;
+  callSid: string;
+}
+
+export interface CallError {
+  ok: false;
+  error: string;
+  status?: number;
+}
+
+export type StartCallInput = {
+  phoneNumber: string;
+  task: string;
+  context?: string;
+  conversationId: string;
+};
+
+export type CancelCallInput = {
+  callSessionId: string;
+  reason?: string;
+};
+
+export type AnswerCallInput = {
+  callSessionId: string;
+  answer: string;
+};
+
+// ── Domain operations ────────────────────────────────────────────────
+
+/**
+ * Initiate a new outbound call.
+ */
+export async function startCall(input: StartCallInput): Promise<StartCallResult | CallError> {
+  const { phoneNumber, task, context: callContext, conversationId } = 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)',
+      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 };
+  }
+
+  let sessionId: string | null = null;
+
+  try {
+    const config = getTwilioConfig();
+    const provider = new TwilioConversationRelayProvider();
+
+    const session = createCallSession({
+      conversationId,
+      provider: 'twilio',
+      fromNumber: config.phoneNumber,
+      toNumber: phoneNumber,
+      task: callContext ? `${task}\n\nContext: ${callContext}` : task,
+    });
+    sessionId = session.id;
+
+    log.info({ callSessionId: session.id, to: phoneNumber, task }, 'Initiating outbound call');
+
+    const baseUrl = config.webhookBaseUrl.replace(/\/$/, '');
+    const { callSid } = await provider.initiateCall({
+      from: config.phoneNumber,
+      to: phoneNumber,
+      webhookUrl: `${baseUrl}/webhooks/twilio/voice?callSessionId=${session.id}`,
+      statusCallbackUrl: `${baseUrl}/webhooks/twilio/status`,
+    });
+
+    updateCallSession(session.id, { providerCallSid: callSid });
+
+    log.info({ callSessionId: session.id, callSid }, 'Call initiated successfully');
+
+    return {
+      ok: true,
+      session: { ...session, providerCallSid: callSid },
+      callSid,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    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 (sessionId) {
+      updateCallSession(sessionId, {
+        status: 'failed',
+        endedAt: Date.now(),
+        lastError: msg,
+      });
+    }
+
+    return { ok: false, error: `Error initiating call: ${msg}`, status: 500 };
+  }
+}
+
+/**
+ * Get the status of a call session. If no callSessionId is provided,
+ * looks up the active call for the given conversationId.
+ */
+export function getCallStatus(
+  callSessionId?: string,
+  conversationId?: string,
+): { 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 };
+    }
+  } else if (conversationId) {
+    session = getActiveCallSessionForConversation(conversationId);
+    if (!session) {
+      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 };
+  }
+
+  log.info({ callSessionId: session.id, status: session.status }, 'Checking call status');
+
+  const pendingQuestion = getPendingQuestion(session.id);
+  return {
+    ok: true,
+    session,
+    pendingQuestion: pendingQuestion
+      ? { id: pendingQuestion.id, questionText: pendingQuestion.questionText }
+      : undefined,
+  };
+}
+
+/**
+ * Cancel an active call. Cleans up relay connections and orchestrators.
+ */
+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 };
+  }
+
+  if (session.status === 'completed' || session.status === 'failed' || session.status === 'cancelled') {
+    return { ok: false, error: `Call session ${callSessionId} has already ended with status: ${session.status}`, status: 409 };
+  }
+
+  log.info({ callSessionId, reason }, 'Cancelling call');
+
+  // Terminate the call via the provider API
+  if (session.providerCallSid) {
+    try {
+      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');
+    }
+  }
+
+  // End the relay connection if active
+  const relayConnection = activeRelayConnections.get(callSessionId);
+  if (relayConnection) {
+    relayConnection.endSession(reason);
+    relayConnection.destroy();
+    activeRelayConnections.delete(callSessionId);
+  }
+
+  // Clean up orchestrator
+  const orchestrator = getCallOrchestrator(callSessionId);
+  if (orchestrator) {
+    orchestrator.destroy();
+    unregisterCallOrchestrator(callSessionId);
+  }
+
+  // Update session status
+  updateCallSession(callSessionId, {
+    status: 'cancelled',
+    endedAt: Date.now(),
+  });
+
+  // Expire any pending questions so they don't linger
+  expirePendingQuestions(callSessionId);
+
+  // 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 };
+  }
+
+  log.info({ callSessionId }, 'Call cancelled successfully');
+
+  return { ok: true, session: updated ?? { ...session, status: 'cancelled', endedAt: Date.now() } };
+}
+
+/**
+ * Answer a pending question for an active call.
+ */
+export async function answerCall(input: AnswerCallInput): Promise<{ ok: true; questionId: string } | CallError> {
+  const { callSessionId, answer } = input;
+
+  if (!answer || typeof answer !== 'string') {
+    return { ok: false, error: 'Missing answer', status: 400 };
+  }
+
+  const question = getPendingQuestion(callSessionId);
+  if (!question) {
+    return { ok: false, error: 'No pending question found', status: 404 };
+  }
+
+  const orchestrator = getCallOrchestrator(callSessionId);
+  if (!orchestrator) {
+    log.warn({ callSessionId }, 'answerCall: no active orchestrator for call session');
+    return { ok: false, error: 'No active orchestrator for this call', status: 409 };
+  }
+
+  const accepted = await orchestrator.handleUserAnswer(answer);
+  if (!accepted) {
+    log.warn(
+      { callSessionId },
+      'answerCall: orchestrator rejected the answer (not in waiting_on_user state)',
+    );
+    return { ok: false, error: 'Orchestrator is not waiting for an answer', status: 409 };
+  }
+
+  answerPendingQuestion(question.id, answer);
+
+  return { ok: true, questionId: question.id };
+}

package/src/calls/call-orchestrator.ts

@@ -0,0 +1,390 @@
+/**
+ * LLM-driven call orchestrator.
+ *
+ * Manages the conversation loop for an active phone call: receives caller
+ * utterances, sends them to Claude via the Anthropic streaming API, and
+ * streams text tokens back through the RelayConnection for real-time TTS.
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import { getConfig } from '../config/loader.js';
+import { getLogger } from '../util/logger.js';
+import {
+  getCallSession,
+  updateCallSession,
+  recordCallEvent,
+  createPendingQuestion,
+  expirePendingQuestions,
+} from './call-store.js';
+import { getMaxCallDurationMs, getUserConsultationTimeoutMs, SILENCE_TIMEOUT_MS } from './call-constants.js';
+import type { RelayConnection } from './relay-server.js';
+import { registerCallOrchestrator, unregisterCallOrchestrator, fireCallQuestionNotifier, fireCallCompletionNotifier } from './call-state.js';
+import type { PromptSpeakerContext } from './speaker-identification.js';
+
+const log = getLogger('call-orchestrator');
+
+type OrchestratorState = 'idle' | 'processing' | 'waiting_on_user' | 'speaking';
+
+const ASK_USER_REGEX = /\[ASK_USER:\s*(.+?)\]/;
+const END_CALL_MARKER = '[END_CALL]';
+
+export class CallOrchestrator {
+  private callSessionId: string;
+  private relay: RelayConnection;
+  private state: OrchestratorState = 'idle';
+  private conversationHistory: Array<{ role: 'user' | 'assistant'; content: string }> = [];
+  private abortController: AbortController = new AbortController();
+  private callStartTime: number = Date.now();
+  private silenceTimer: ReturnType<typeof setTimeout> | null = null;
+  private durationTimer: ReturnType<typeof setTimeout> | null = null;
+  private durationWarningTimer: ReturnType<typeof setTimeout> | null = null;
+  private consultationTimer: ReturnType<typeof setTimeout> | null = null;
+  private durationEndTimer: ReturnType<typeof setTimeout> | null = null;
+  private task: string | null;
+
+  constructor(callSessionId: string, relay: RelayConnection, task: string | null) {
+    this.callSessionId = callSessionId;
+    this.relay = relay;
+    this.task = task;
+    this.startDurationTimer();
+    this.resetSilenceTimer();
+    registerCallOrchestrator(callSessionId, this);
+  }
+
+  /**
+   * Returns the current orchestrator state.
+   */
+  getState(): OrchestratorState {
+    return this.state;
+  }
+
+  /**
+   * Handle a final caller utterance from the ConversationRelay.
+   */
+  async handleCallerUtterance(transcript: string, speaker?: PromptSpeakerContext): Promise<void> {
+    // If we're already processing or speaking, abort the in-flight generation
+    if (this.state === 'processing' || this.state === 'speaking') {
+      this.abortController.abort();
+      this.abortController = new AbortController();
+    }
+
+    this.state = 'processing';
+    this.resetSilenceTimer();
+
+    // Append caller utterance
+    this.conversationHistory.push({
+      role: 'user',
+      content: this.formatCallerUtterance(transcript, speaker),
+    });
+
+    await this.runLlm();
+  }
+
+  /**
+   * Called when the user (in the chat UI) answers a pending question.
+   */
+  async handleUserAnswer(answerText: string): Promise<boolean> {
+    if (this.state !== 'waiting_on_user') {
+      log.warn(
+        { callSessionId: this.callSessionId, state: this.state },
+        'handleUserAnswer called but orchestrator is not in waiting_on_user state',
+      );
+      return false;
+    }
+
+    // Clear the consultation timeout
+    if (this.consultationTimer) {
+      clearTimeout(this.consultationTimer);
+      this.consultationTimer = null;
+    }
+
+    this.state = 'processing';
+    updateCallSession(this.callSessionId, { status: 'in_progress' });
+
+    // Append the user's answer as a special message the model recognizes
+    this.conversationHistory.push({ role: 'user', content: `[USER_ANSWERED: ${answerText}]` });
+
+    // Fire-and-forget: unblock the caller so the HTTP response and answer
+    // persistence happen immediately, before LLM streaming begins.
+    this.runLlm().catch((err) =>
+      log.error({ err, callSessionId: this.callSessionId }, 'runLlm failed after user answer'),
+    );
+    return true;
+  }
+
+  /**
+   * Handle caller interrupting the assistant's speech.
+   */
+  handleInterrupt(): void {
+    this.abortController.abort();
+    this.abortController = new AbortController();
+    this.state = 'idle';
+  }
+
+  /**
+   * Tear down all timers and abort any in-flight work.
+   */
+  destroy(): void {
+    if (this.silenceTimer) clearTimeout(this.silenceTimer);
+    if (this.durationTimer) clearTimeout(this.durationTimer);
+    if (this.durationWarningTimer) clearTimeout(this.durationWarningTimer);
+    if (this.consultationTimer) clearTimeout(this.consultationTimer);
+    if (this.durationEndTimer) { clearTimeout(this.durationEndTimer); this.durationEndTimer = null; }
+    this.abortController.abort();
+    unregisterCallOrchestrator(this.callSessionId);
+    log.info({ callSessionId: this.callSessionId }, 'CallOrchestrator destroyed');
+  }
+
+  // ── Private ──────────────────────────────────────────────────────
+
+  private buildSystemPrompt(): string {
+    const config = getConfig();
+    const disclosureRule = config.calls.disclosure.enabled
+      ? `1. ${config.calls.disclosure.text}`
+      : '1. Begin the conversation naturally.';
+
+    return [
+      'You are on a live phone call on behalf of your user.',
+      this.task ? `Task: ${this.task}` : '',
+      '',
+      'You are speaking directly to the person who answered the phone.',
+      'Respond naturally and conversationally — speak as you would in a real phone conversation.',
+      '',
+      'IMPORTANT RULES:',
+      disclosureRule,
+      '2. Be concise — phone conversations should be brief and natural.',
+      '3. If the callee asks something you don\'t know, include [ASK_USER: your question here] in your response along with a hold message like "Let me check on that for you."',
+      '4. If the callee provides information preceded by [USER_ANSWERED: ...], use that answer naturally in the conversation.',
+      '5. When the call\'s purpose is fulfilled, include [END_CALL] in your response along with a polite goodbye.',
+      '6. Do not make up information — ask the user if unsure.',
+      '7. Keep responses short — 1-3 sentences is ideal for phone conversation.',
+      '8. When caller text includes [SPEAKER id="..." label="..."], treat each speaker as a distinct person and personalize responses using that speaker\'s prior context in this call.',
+    ]
+      .filter(Boolean)
+      .join('\n');
+  }
+
+  private formatCallerUtterance(transcript: string, speaker?: PromptSpeakerContext): string {
+    if (!speaker) return transcript;
+    const safeId = speaker.speakerId.replaceAll('"', '\'');
+    const safeLabel = speaker.speakerLabel.replaceAll('"', '\'');
+    const confidencePart = speaker.speakerConfidence !== null ? ` confidence="${speaker.speakerConfidence.toFixed(2)}"` : '';
+    return `[SPEAKER id="${safeId}" label="${safeLabel}" source="${speaker.source}"${confidencePart}] ${transcript}`;
+  }
+
+  /**
+   * Run the LLM with the current conversation history and stream
+   * the response back through the relay.
+   */
+  private async runLlm(): Promise<void> {
+    const apiKey = getConfig().apiKeys.anthropic ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      log.error({ callSessionId: this.callSessionId }, 'No Anthropic API key available');
+      this.relay.sendTextToken('I\'m sorry, I\'m having a technical issue. Please try again later.', true);
+      this.state = 'idle';
+      return;
+    }
+
+    const client = new Anthropic({ apiKey });
+
+    try {
+      this.state = 'speaking';
+
+      const stream = client.messages.stream(
+        {
+          model: 'claude-sonnet-4-20250514',
+          max_tokens: 512,
+          system: this.buildSystemPrompt(),
+          messages: this.conversationHistory.map((m) => ({
+            role: m.role,
+            content: m.content,
+          })),
+        },
+        { signal: this.abortController.signal },
+      );
+
+      // Buffer incoming tokens so we can strip control markers ([ASK_USER:...], [END_CALL])
+      // before they reach TTS. We hold text whenever an unmatched '[' appears, since it
+      // could be the start of a control marker.
+      let ttsBuffer = '';
+
+      const flushSafeText = (_force: boolean): void => {
+        if (ttsBuffer.length === 0) return;
+        const bracketIdx = ttsBuffer.indexOf('[');
+        if (bracketIdx === -1) {
+          // No bracket at all — safe to flush everything
+          this.relay.sendTextToken(ttsBuffer, false);
+          ttsBuffer = '';
+        } else {
+          // Flush everything before the bracket
+          if (bracketIdx > 0) {
+            this.relay.sendTextToken(ttsBuffer.slice(0, bracketIdx), false);
+            ttsBuffer = ttsBuffer.slice(bracketIdx);
+          }
+
+          // Only hold the buffer if the bracket text could be the start of a
+          // known control marker. Otherwise flush immediately so ordinary
+          // bracketed text (e.g. "[A]", "[note]") doesn't stall TTS.
+          //
+          // The check must be bidirectional:
+          //  - When the buffer is shorter than the prefix (e.g. "[ASK"), the
+          //    buffer is a prefix of the control tag → hold it.
+          //  - When the buffer is longer than the prefix (e.g. "[ASK_USER: what"),
+          //    the buffer starts with the control tag prefix → hold it (the
+          //    variable-length payload hasn't been closed yet).
+          const afterBracket = ttsBuffer;
+          const couldBeControl =
+            '[ASK_USER:'.startsWith(afterBracket) ||
+            '[END_CALL]'.startsWith(afterBracket) ||
+            afterBracket.startsWith('[ASK_USER:') ||
+            afterBracket === '[END_CALL' ||
+            afterBracket.startsWith('[END_CALL]');
+
+          if (!couldBeControl) {
+            // Not a control marker prefix — flush up to the next '[' (if any)
+            // so we don't accidentally flush a later partial control marker.
+            const nextBracket = ttsBuffer.indexOf('[', 1);
+            if (nextBracket === -1) {
+              this.relay.sendTextToken(ttsBuffer, false);
+              ttsBuffer = '';
+            } else {
+              this.relay.sendTextToken(ttsBuffer.slice(0, nextBracket), false);
+              ttsBuffer = ttsBuffer.slice(nextBracket);
+            }
+          }
+          // Otherwise hold it — might be a control marker still being streamed
+        }
+      };
+
+      stream.on('text', (text) => {
+        ttsBuffer += text;
+
+        // If the buffer contains a complete control marker, strip it
+        if (ASK_USER_REGEX.test(ttsBuffer)) {
+          ttsBuffer = ttsBuffer.replace(ASK_USER_REGEX, '');
+        }
+        if (ttsBuffer.includes(END_CALL_MARKER)) {
+          ttsBuffer = ttsBuffer.replace(END_CALL_MARKER, '');
+        }
+
+        flushSafeText(false);
+      });
+
+      const finalMessage = await stream.finalMessage();
+
+      // Final sweep: strip any remaining control markers from the buffer
+      ttsBuffer = ttsBuffer.replace(ASK_USER_REGEX, '').replace(END_CALL_MARKER, '');
+      if (ttsBuffer.length > 0) {
+        this.relay.sendTextToken(ttsBuffer, false);
+      }
+
+      // Signal end of this turn's speech
+      this.relay.sendTextToken('', true);
+
+      const responseText =
+        finalMessage.content
+          .filter((b): b is Anthropic.TextBlock => b.type === 'text')
+          .map((b) => b.text)
+          .join('') || '';
+
+      // Record the assistant response
+      this.conversationHistory.push({ role: 'assistant', content: responseText });
+      recordCallEvent(this.callSessionId, 'assistant_spoke', { text: responseText });
+
+      // Check for ASK_USER pattern
+      const askMatch = responseText.match(ASK_USER_REGEX);
+      if (askMatch) {
+        const questionText = askMatch[1];
+        createPendingQuestion(this.callSessionId, questionText);
+        this.state = 'waiting_on_user';
+        updateCallSession(this.callSessionId, { status: 'waiting_on_user' });
+        recordCallEvent(this.callSessionId, 'user_question_asked', { question: questionText });
+
+        // Notify the conversation that a question was asked
+        const session = getCallSession(this.callSessionId);
+        if (session) {
+          fireCallQuestionNotifier(session.conversationId, this.callSessionId, questionText);
+        }
+
+        // Set a consultation timeout
+        this.consultationTimer = setTimeout(() => {
+          if (this.state === 'waiting_on_user') {
+            log.info({ callSessionId: this.callSessionId }, 'User consultation timed out');
+            this.relay.sendTextToken(
+              'I\'m sorry, I wasn\'t able to get that information in time. Let me move on.',
+              true,
+            );
+            this.state = 'idle';
+            updateCallSession(this.callSessionId, { status: 'in_progress' });
+            expirePendingQuestions(this.callSessionId);
+          }
+        }, getUserConsultationTimeoutMs());
+        return;
+      }
+
+      // Check for END_CALL marker
+      if (responseText.includes(END_CALL_MARKER)) {
+        this.relay.endSession('Call completed');
+        updateCallSession(this.callSessionId, { status: 'completed', endedAt: Date.now() });
+        recordCallEvent(this.callSessionId, 'call_ended', { reason: 'completed' });
+
+        // Notify the conversation that the call completed
+        const endSession = getCallSession(this.callSessionId);
+        if (endSession) {
+          fireCallCompletionNotifier(endSession.conversationId, this.callSessionId);
+        }
+        this.state = 'idle';
+        return;
+      }
+
+      // Normal turn complete
+      this.state = 'idle';
+    } catch (err: unknown) {
+      // Aborted requests are expected (interruptions, rapid utterances)
+      if (err instanceof Error && err.name === 'AbortError') {
+        log.debug({ callSessionId: this.callSessionId }, 'LLM request aborted');
+        return;
+      }
+      log.error({ err, callSessionId: this.callSessionId }, 'LLM streaming error');
+      this.relay.sendTextToken('I\'m sorry, I encountered a technical issue. Could you repeat that?', true);
+      this.state = 'idle';
+    }
+  }
+
+  private startDurationTimer(): void {
+    const maxDurationMs = getMaxCallDurationMs();
+    const warningMs = maxDurationMs - 2 * 60 * 1000; // 2 minutes before max
+
+    if (warningMs > 0) {
+      this.durationWarningTimer = setTimeout(() => {
+        log.info({ callSessionId: this.callSessionId }, 'Call duration warning');
+        this.relay.sendTextToken(
+          'Just to let you know, we\'re running low on time for this call.',
+          true,
+        );
+      }, warningMs);
+    }
+
+    this.durationTimer = setTimeout(() => {
+      log.info({ callSessionId: this.callSessionId }, 'Call duration limit reached');
+      this.relay.sendTextToken(
+        'I\'m sorry, but we\'ve reached the maximum time for this call. Thank you for your time. Goodbye!',
+        true,
+      );
+      // Give TTS a moment to play, then end
+      this.durationEndTimer = setTimeout(() => {
+        this.relay.endSession('Maximum call duration reached');
+        updateCallSession(this.callSessionId, { status: 'completed', endedAt: Date.now() });
+        recordCallEvent(this.callSessionId, 'call_ended', { reason: 'max_duration' });
+      }, 3000);
+    }, maxDurationMs);
+  }
+
+  private resetSilenceTimer(): void {
+    if (this.silenceTimer) clearTimeout(this.silenceTimer);
+    this.silenceTimer = setTimeout(() => {
+      log.info({ callSessionId: this.callSessionId }, 'Silence timeout triggered');
+      this.relay.sendTextToken('Are you still there?', true);
+    }, SILENCE_TIMEOUT_MS);
+  }
+}