vapi.ts

import type { ChatCompletionMessageParam } from 'openai/resources';

import DailyIframe, {
  DailyCall,
  DailyAdvancedConfig,
  DailyFactoryOptions,
  DailyEventObjectAppMessage,
  DailyEventObjectLocalAudioLevel,
  DailyEventObjectNoPayload,
  DailyEventObjectParticipant,
  DailyEventObjectTrack,
  DailyEventObjectRecordingError,
  DailyEventObjectRecordingStarted,
  DailyEventObjectRecordingStopped,
  DailyEventObjectRemoteParticipantsAudioLevel,
  DailyParticipant,
  DailyVideoSendSettings,
} from '@daily-co/daily-js';
import EventEmitter from 'events';

import {
  Call,
  CreateSquadDTO,
  CreateAssistantDTO,
  AssistantOverrides,
  CreateWorkflowDTO,
  WorkflowOverrides,
} from './api';
import { client } from './client';
import {
  createSafeDailyConfig,
  createSafeDailyFactoryOptions,
  safeSetLocalAudio,
  safeSetInputDevicesAsync,
} from './daily-guards';

export interface EndCallMessage {
  type: 'end-call';
}

export interface AddMessageMessage {
  type: 'add-message';
  message: ChatCompletionMessageParam;
  triggerResponseEnabled?: boolean;
}

export interface ControlMessages {
  type: 'control';
  control: 'mute-assistant' | 'unmute-assistant' | 'say-first-message';
  videoRecordingStartDelaySeconds?: number;
}

export interface SayMessage {
  type: 'say';
  message: string;
  endCallAfterSpoken?: boolean;
  interruptionsEnabled?: boolean;
  interruptAssistantEnabled?: boolean;
}

type VapiClientToServerMessage =
  | AddMessageMessage
  | ControlMessages
  | SayMessage
  | EndCallMessage;

type VapiEventNames =
  | 'call-end'
  | 'call-start'
  | 'volume-level'
  | 'local-volume-level'
  | 'local-audio-level-observer-error'
  | 'speech-start'
  | 'speech-end'
  | 'message'
  | 'video'
  | 'audio'
  | 'error'
  | 'camera-error'
  | 'network-quality-change'
  | 'network-connection'
  | 'daily-participant-updated'
  | 'call-start-progress'
  | 'call-start-success'
  | 'call-start-failed'
  | 'recording-started'
  | 'recording-stopped'
  | 'recording-stats'
  | 'recording-error'
  | 'recording-upload-completed';

interface CallStartProgressEvent {
  stage: string;
  status: 'started' | 'completed' | 'failed';
  duration?: number;
  timestamp: string;
  metadata?: Record<string, any>;
}

interface CallStartSuccessEvent {
  totalDuration: number;
  callId?: string;
  timestamp: string;
}

interface CallStartFailedEvent {
  stage: string;
  totalDuration: number;
  error: string;
  errorStack?: string;
  timestamp: string;
  context: Record<string, any>;
}

interface SerializedError {
  message: string;
  name?: string;
  stack?: string;
  code?: string | number;
  cause?: string;
  [key: string]: any;
}

/**
 * Extracts error details into a plain object that serializes properly to JSON.
 * Error objects don't serialize well because their properties (message, stack, name) 
 * are not enumerable and get lost when using JSON.stringify().
 */
function serializeError(error: unknown): SerializedError {
  if (error === null || error === undefined) {
    return { message: 'Unknown error (null or undefined)' };
  }
  
  if (error instanceof Error) {
    const serialized: SerializedError = {
      message: error.message,
      name: error.name,
      stack: error.stack,
    };
    
    // Include any additional properties that might be on the error
    const errorAsAny = error as any;
    if (errorAsAny.code !== undefined) {
      serialized.code = errorAsAny.code;
    }
    if (errorAsAny.cause !== undefined) {
      serialized.cause = String(errorAsAny.cause);
    }
    if (errorAsAny.reason !== undefined) {
      serialized.reason = errorAsAny.reason;
    }
    if (errorAsAny.details !== undefined) {
      serialized.details = errorAsAny.details;
    }
    // Daily.co specific error properties
    if (errorAsAny.errorMsg !== undefined) {
      serialized.errorMsg = errorAsAny.errorMsg;
    }
    if (errorAsAny.error !== undefined && typeof errorAsAny.error === 'string') {
      serialized.errorDetail = errorAsAny.error;
    }
    
    return serialized;
  }
  
  if (typeof error === 'string') {
    return { message: error };
  }
  
  if (typeof error === 'object') {
    // It's already a plain object, but let's ensure message exists
    const errorObj = error as Record<string, any>;
    return {
      message: errorObj.message || errorObj.error || JSON.stringify(error),
      ...errorObj
    };
  }
  
  return { message: String(error) };
}

type VapiEventListeners = {
  'call-end': () => void;
  'call-start': () => void;
  'volume-level': (volume: number) => void;
  'local-volume-level': (volume: number) => void;
  'local-audio-level-observer-error': (error: any) => void;
  'speech-start': () => void;
  'speech-end': () => void;
  video: (track: MediaStreamTrack) => void;
  audio: (player: HTMLAudioElement) => void;
  message: (message: any) => void;
  error: (error: any) => void;
  'camera-error': (error: any) => void;
  'network-quality-change': (event: any) => void;
  'network-connection': (event: any) => void;
  'daily-participant-updated': (participant: DailyParticipant) => void;
  'call-start-progress': (event: CallStartProgressEvent) => void;
  'call-start-success': (event: CallStartSuccessEvent) => void;
  'call-start-failed': (event: CallStartFailedEvent) => void;
  'recording-started': (event: DailyEventObjectRecordingStarted) => void;
  'recording-stopped': (event: DailyEventObjectRecordingStopped) => void;
  'recording-stats': (event: DailyEventObjectNoPayload) => void;
  'recording-error': (event: DailyEventObjectRecordingError) => void;
  'recording-upload-completed': (event: DailyEventObjectNoPayload) => void;
};

type StartCallOptions = {
  /** Acquire the microphone before creating a backend call. Defaults to true. */
  microphonePreflightEnabled?: boolean;
  /**
   * This determines whether the daily room will be deleted and all participants will be kicked once the user leaves the room.
   * If set to `false`, the room will be kept alive even after the user leaves, allowing clients to reconnect to the same room.
   * If set to `true`, the room will be deleted and reconnection will not be allowed.
   *
   * Defaults to `true`.
   * @example true
   */
  roomDeleteOnUserLeaveEnabled?: boolean;
}

type WebCall = {
  /**
   * The Vapi WebCall URL. This is the URL that the call will be joined on.
   * 
   * call.webCallUrl or call.transport.callUrl
   */
  webCallUrl: string;
  /**
   * The Vapi WebCall ID. This is the ID of the call.
   * 
   * call.id
   */
  id?: string;
  /**
   * The Vapi WebCall artifact plan. This is the artifact plan of the call.
   */
  artifactPlan?: { videoRecordingEnabled?: boolean };
  /**
   * The Vapi WebCall assistant. This is the assistant of the call.
   *
   * call.assistant
   */
  assistant?: { voice?: { provider?: string } };
  /**
   * The Vapi WebCall transport. When video recording is enabled, the server
   * sets `callToken` to a Daily meeting token that auto-starts the cloud
   * recording on join.
   *
   * call.transport
   */
  transport?: { callToken?: string };
}

async function startAudioPlayer(
  player: HTMLAudioElement,
  track: MediaStreamTrack,
) {
  player.muted = false;
  player.autoplay = true;
  if (track != null) {
    player.srcObject = new MediaStream([track]);
    await player.play();
  }
}

async function buildAudioPlayer(
  track: MediaStreamTrack,
  participantId: string,
  volume?: number | null,
) {
  const player = document.createElement('audio');
  player.dataset.participantId = participantId;
  // Before play(), so an already-flowing track never plays at full volume first.
  if (typeof volume === 'number') {
    player.volume = volume;
  }
  document.body.appendChild(player);
  try {
    await startAudioPlayer(player, track);
  } catch (error) {
    // Appended before playback was attempted, so a failure would strand it.
    player.remove();
    throw error;
  }
  return player;
}

function destroyAudioPlayer(participantId: string) {
  const player = document.querySelector(
    `audio[data-participant-id="${participantId}"]`,
  );
  player?.remove();
}

function subscribeToTracks(
  e: DailyEventObjectParticipant,
  call: DailyCall,
  isVideoRecordingEnabled?: boolean,
  isVideoEnabled?: boolean,
) {
  if (e.participant.local) return;

  call.updateParticipant(e.participant.session_id, {
    setSubscribedTracks: {
      audio: true,
      video: isVideoRecordingEnabled || isVideoEnabled,
    },
  });
}

class VapiEventEmitter extends EventEmitter {
  on<E extends VapiEventNames>(
    event: E,
    listener: VapiEventListeners[E],
  ): this {
    super.on(event, listener);
    return this;
  }
  once<E extends VapiEventNames>(
    event: E,
    listener: VapiEventListeners[E],
  ): this {
    super.once(event, listener);
    return this;
  }
  emit<E extends VapiEventNames>(
    event: E,
    ...args: Parameters<VapiEventListeners[E]>
  ): boolean {
    return super.emit(event, ...args);
  }
  removeListener<E extends VapiEventNames>(
    event: E,
    listener: VapiEventListeners[E],
  ): this {
    super.removeListener(event, listener);
    return this;
  }
  removeAllListeners(event?: VapiEventNames): this {
    super.removeAllListeners(event);
    return this;
  }
}

export default class Vapi extends VapiEventEmitter {
  private started: boolean = false;
  private call: DailyCall | null = null;
  private audioPlayer: HTMLAudioElement | null = null;
  // Survives teardown so the caller's choice persists across calls.
  private desiredVolume: number | null = null;
  // Builds are tracked individually, not by one counter: several can be in
  // flight, they finish out of order, and a teardown must invalidate only the
  // builds belonging to the participant that left.
  private audioBuildSequence = 0;
  private pendingAudioBuilds = new Map<number, string>();
  private attachedAudioBuild = 0;
  private speakingTimeout: NodeJS.Timeout | null = null;
  private dailyCallConfig: DailyAdvancedConfig = {};
  private dailyCallObject: DailyFactoryOptions = {};
  private microphoneTrack: MediaStreamTrack | null = null;
  private cancelMicrophonePreflight: (() => void) | null = null;

  private async microphoneAcquire(): Promise<MediaStreamTrack> {
    const source = this.dailyCallObject.audioSource;
    if (source && typeof source === 'object') {
      if (source.readyState === 'ended') {
        throw new DOMException('The supplied microphone track has ended.', 'NotReadableError');
      }
      return source;
    }
    return new Promise<MediaStreamTrack>((resolve, reject) => {
      let cancelled = false;
      this.cancelMicrophonePreflight = () => {
        cancelled = true;
        reject(new DOMException('Microphone preflight cancelled.', 'AbortError'));
      };
      navigator.mediaDevices.getUserMedia({
        audio: typeof source === 'string' ? { deviceId: { exact: source } } : true,
      }).then((stream) => {
        const track = stream.getAudioTracks()[0];
        if (cancelled || !track || track.readyState === 'ended') {
          stream.getTracks().forEach((item) => item.stop());
          reject(new DOMException('No live microphone track available.', 'NotFoundError'));
          return;
        }
        stream.getTracks().filter((item) => item !== track).forEach((item) => item.stop());
        this.microphoneTrack = track;
        resolve(track);
      }, reject);
    }).finally(() => {
      this.cancelMicrophonePreflight = null;
    });
  }

  private hasEmittedCallEndedStatus: boolean = false;

  constructor(
    apiToken: string,
    apiBaseUrl?: string,
    dailyCallConfig?: Pick<
      DailyAdvancedConfig,
      'avoidEval' | 'alwaysIncludeMicInPermissionPrompt'
    >,
    dailyCallObject?: Pick<DailyFactoryOptions, 'audioSource' | 'startAudioOff'>,
  ) {
    super();
    client.baseUrl = apiBaseUrl ?? 'https://api.vapi.ai';
    client.setSecurityData(apiToken);
    this.dailyCallConfig = createSafeDailyConfig(dailyCallConfig);
    this.dailyCallObject = createSafeDailyFactoryOptions(dailyCallObject);
  }

  private async cleanup() {
    this.microphoneTrack?.stop();
    this.microphoneTrack = null;
    this.started = false;
    this.hasEmittedCallEndedStatus = false;
    if (this.call) {
      await this.call.destroy();
      this.call = null;
    }
    this.audioPlayer = null;
    this.pendingAudioBuilds.clear();
    this.speakingTimeout = null;
  }

  private isMobileDevice() {
    if (typeof navigator === 'undefined') {
      return false;
    }
    const userAgent = navigator.userAgent;
    return /android|iphone|ipad|ipod|iemobile|blackberry|bada/i.test(
      userAgent.toLowerCase(),
    );
  }

  private async sleep(ms: number) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }

  /**
   * Reports a failed audio processing update on the SDK's `error` event.
   *
   * Daily applies input settings inside its remotely loaded call machine, so a
   * failure - Krisp's `KrispInitError: Canceled`, for example - arrives as a
   * rejected promise, which a synchronous try/catch around
   * `updateInputSettings()` cannot see. Without this the rejection escapes to
   * the page as an unhandled rejection instead of reaching the listeners
   * consumers register. Audio processing is non-critical, so the call continues.
   */
  private emitAudioProcessingError(
    stage: 'audio-processing-setup' | 'audio-processor-recovery',
    error: unknown,
  ) {
    this.emit('error', {
      type: `${stage}-error`,
      stage,
      error: serializeError(error),
      timestamp: new Date().toISOString(),
    });
  }

  /**
   * Starts Daily's local (microphone) audio level observer.
   *
   * Only runs when something is listening for 'local-volume-level'. The observer
   * costs an AudioContext plus an AudioWorklet for the lifetime of the call and
   * nothing else in the SDK reads the level, so starting it unconditionally
   * charges every consumer for a feature almost none of them use. Listeners
   * attached after the call is under way should call the public
   * `startLocalAudioLevelObserver()`.
   *
   * Must run after the noise-cancellation processor has settled. Krisp replaces
   * the microphone track, Daily reacts to any local track change by closing the
   * AudioContext its in-flight `audioWorklet.addModule()` is still loading into,
   * and Chrome and Firefox reject that load with "AbortError: Unable to load a
   * worklet's module". Daily answers by stopping the observer for the rest of
   * the call, so losing this race costs the feature, not just console noise.
   * Tracked upstream at https://github.com/daily-co/daily-js/issues/317.
   */
  private async maybeStartLocalAudioLevelObserver(): Promise<void> {
    if (!this.call || this.listenerCount('local-volume-level') === 0) {
      return;
    }

    try {
      await this.call.startLocalAudioLevelObserver(100);
    } catch (error) {
      this.emit('local-audio-level-observer-error', serializeError(error));
    }
  }

  async start(
    assistant?: CreateAssistantDTO | string,
    assistantOverrides?: AssistantOverrides,
    squad?: CreateSquadDTO | string,
    workflow?: CreateWorkflowDTO | string,
    workflowOverrides?: WorkflowOverrides,
    options?: StartCallOptions
  ): Promise<Call | null> {
    const startTime = Date.now();
    
    // Input validation with detailed error messages
    if (!assistant && !squad && !workflow) {
      const error = new Error('Assistant or Squad or Workflow must be provided.');
      this.emit('error', { 
        type: 'validation-error', 
        stage: 'input-validation',
        error: serializeError(error),
        timestamp: new Date().toISOString()
      });
      throw error;
    }

    if (this.started) {
      this.emit('call-start-progress', {
        stage: 'validation',
        status: 'failed',
        timestamp: new Date().toISOString(),
        metadata: { reason: 'already-started' }
      });
      return null;
    }
    
    this.emit('call-start-progress', {
      stage: 'initialization',
      status: 'started',
      timestamp: new Date().toISOString(),
      metadata: {
        hasAssistant: !!assistant,
        hasSquad: !!squad,
        hasWorkflow: !!workflow
      }
    });
    
    this.started = true;

    let failureStage = 'microphone-preflight';
    try {
      if (this.call) {
        await this.cleanup();
        this.started = true;
      }
      const audioSource = options?.microphonePreflightEnabled === false
        ? this.dailyCallObject.audioSource ?? true
        : await this.microphoneAcquire();
      failureStage = 'unknown';
            // Stage 1: Create web call
      this.emit('call-start-progress', {
        stage: 'web-call-creation',
        status: 'started',
        timestamp: new Date().toISOString()
      });
      
      const webCallStartTime = Date.now();
      
      const webCall = (
        await client.call.callControllerCreateWebCall({
          assistant: typeof assistant === 'string' ? undefined : assistant,
          assistantId: typeof assistant === 'string' ? assistant : undefined,
          assistantOverrides,
          squad: typeof squad === 'string' ? undefined : squad,
          squadId: typeof squad === 'string' ? squad : undefined,
          workflow: typeof workflow === 'string' ? undefined : workflow,
          workflowId: typeof workflow === 'string' ? workflow : undefined,
          workflowOverrides,
          roomDeleteOnUserLeaveEnabled: options?.roomDeleteOnUserLeaveEnabled,
        })
      ).data;
      
      const webCallDuration = Date.now() - webCallStartTime;
      this.emit('call-start-progress', {
        stage: 'web-call-creation',
        status: 'completed',
        duration: webCallDuration,
        timestamp: new Date().toISOString(),
        metadata: {
          callId: webCall?.id || 'unknown',
          videoRecordingEnabled: webCall?.artifactPlan?.videoRecordingEnabled ?? false,
          voiceProvider: webCall?.assistant?.voice?.provider || 'unknown'
        }
      });

      const isVideoRecordingEnabled =
        webCall?.artifactPlan?.videoRecordingEnabled ?? false;

      const isVideoEnabled = webCall?.assistant?.voice?.provider === 'tavus';

      // When video recording is enabled, the server sends a Daily meeting
      // token that auto-starts the cloud recording on join — more reliable
      // than calling startRecording() from a weak client network. Older
      // servers don't send one; then the client starts the recording itself.
      const callToken = (
        webCall?.transport as { callToken?: string } | undefined
      )?.callToken;

      // Stage 2: Create Daily call object
      this.emit('call-start-progress', {
        stage: 'daily-call-object-creation',
        status: 'started',
        timestamp: new Date().toISOString(),
        metadata: {
          audioSource: this.dailyCallObject.audioSource ?? true,
          videoSource: this.dailyCallObject.videoSource ?? isVideoRecordingEnabled,
          isVideoRecordingEnabled,
          isVideoEnabled
        }
      });
      
      const dailyCallStartTime = Date.now();
      
      try {
        this.call = DailyIframe.createCallObject({
          audioSource,
          videoSource: this.dailyCallObject.videoSource ?? isVideoRecordingEnabled,
          dailyConfig: this.dailyCallConfig,
        });
        
        const dailyCallDuration = Date.now() - dailyCallStartTime;
        this.emit('call-start-progress', {
          stage: 'daily-call-object-creation',
          status: 'completed',
          duration: dailyCallDuration,
          timestamp: new Date().toISOString()
        });
      } catch (error) {
        const dailyCallDuration = Date.now() - dailyCallStartTime;
        const serializedError = serializeError(error);
        this.emit('call-start-progress', {
          stage: 'daily-call-object-creation',
          status: 'failed',
          duration: dailyCallDuration,
          timestamp: new Date().toISOString(),
          metadata: { error: serializedError.message }
        });
        this.emit('error', {
          type: 'daily-call-object-creation-error',
          stage: 'daily-call-object-creation',
          error: serializedError,
          timestamp: new Date().toISOString()
        });
        throw error;
      }
      
      this.call.iframe()?.style.setProperty('display', 'none');

      this.call.on('left-meeting', () => {
        this.emit('call-end');
        if (!this.hasEmittedCallEndedStatus) {
          this.emit('message', {
            type: 'status-update',
            status: 'ended',
            'endedReason': 'customer-ended-call',
          });
          this.hasEmittedCallEndedStatus = true;
        }
        if (isVideoRecordingEnabled) {
          // When using a token, the recording doesn't stop automatically on
          // leave, so still stop it manually to preserve existing behavior.
          this.call?.stopRecording();
        }
        this.cleanup().catch(console.error);
      });

      this.call.on('error', (error: any) => {
        this.emit('error', {
          type: 'daily-error',
          error: serializeError(error),
          timestamp: new Date().toISOString()
        });
        if (isVideoRecordingEnabled) {
          this.call?.stopRecording();
        }
      });

      this.call.on('camera-error', (error: any) => {
        this.emit('camera-error', {
          type: 'camera-error',
          error: serializeError(error),
          timestamp: new Date().toISOString()
        });
      });

      this.call.on('network-quality-change', (event: any) => {
        this.emit('network-quality-change', event);
      });

      this.call.on('network-connection', (event: any) => {
        this.emit('network-connection', event);
      });

      this.call.on('recording-started', (event) => {
        if (event) this.emit('recording-started', event);
      });

      this.call.on('recording-stopped', (event) => {
        if (event) this.emit('recording-stopped', event);
      });

      this.call.on('recording-stats', (event) => {
        if (event) this.emit('recording-stats', event);
      });

      this.call.on('recording-error', (event) => {
        if (event) this.emit('recording-error', event);
      });

      this.call.on('recording-upload-completed', (event) => {
        if (event) this.emit('recording-upload-completed', event);
      });

      this.call.on('track-started', (e) => this.handleTrackStarted(e));

      this.call.on('participant-joined', (e) => {
        if (!e || !this.call) return;
        subscribeToTracks(
          e,
          this.call,
          isVideoRecordingEnabled,
          isVideoEnabled,
        );
      });

      this.call.on('participant-updated', (e) => {
        if (!e) {
          return;
        }
        this.emit('daily-participant-updated', e.participant);
      });

      this.call.on('participant-left', (e) => {
        if (!e) {
          return;
        }
        this.detachAudioPlayer(e.participant.session_id);
      });

      // Registered before join(): a token-auto-started recording can begin
      // while join() is still in flight, so a listener added after join
      // could miss the event.
      let recordingRequestedTime = 0;
      if (isVideoRecordingEnabled) {
        this.call.once('recording-started', () => {
          const totalRecordingDelay = (new Date().getTime() - recordingRequestedTime) / 1000;
          this.emit('call-start-progress', {
            stage: 'video-recording-started',
            status: 'completed',
            timestamp: new Date().toISOString(),
            metadata: { delaySeconds: totalRecordingDelay }
          });

          this.send({
            type: 'control',
            control: 'say-first-message',
            videoRecordingStartDelaySeconds: totalRecordingDelay,
          });
        });
      }

      // Stage 3: Mobile device handling and permissions
      const isMobile = this.isMobileDevice();
      this.emit('call-start-progress', {
        stage: 'mobile-permissions',
        status: 'started',
        timestamp: new Date().toISOString(),
        metadata: { isMobile }
      });
      
      if (isMobile) {
        const mobileWaitStartTime = Date.now();
        await this.sleep(1000);
        const mobileWaitDuration = Date.now() - mobileWaitStartTime;
        this.emit('call-start-progress', {
          stage: 'mobile-permissions',
          status: 'completed',
          duration: mobileWaitDuration,
          timestamp: new Date().toISOString(),
          metadata: { action: 'permissions-wait' }
        });
      } else {
        this.emit('call-start-progress', {
          stage: 'mobile-permissions',
          status: 'completed',
          timestamp: new Date().toISOString(),
          metadata: { action: 'skipped-not-mobile' }
        });
      }

      // Stage 4: Join the call
      this.emit('call-start-progress', {
        stage: 'daily-call-join',
        status: 'started',
        timestamp: new Date().toISOString()
      });
      
      const joinStartTime = Date.now();
      recordingRequestedTime = joinStartTime;

      try {
        await this.call.join({
          // @ts-expect-error This exists
          url: webCall.webCallUrl,
          // daily-js rejects a `token` key that is present but undefined, so
          // only include it when the server actually sent one.
          ...(callToken ? { token: callToken } : {}),
          subscribeToTracksAutomatically: false,
        });
        
        const joinDuration = Date.now() - joinStartTime;
        this.emit('call-start-progress', {
          stage: 'daily-call-join',
          status: 'completed',
          duration: joinDuration,
          timestamp: new Date().toISOString()
        });
      } catch (error) {
        const joinDuration = Date.now() - joinStartTime;
        const serializedError = serializeError(error);
        this.emit('call-start-progress', {
          stage: 'daily-call-join',
          status: 'failed',
          duration: joinDuration,
          timestamp: new Date().toISOString(),
          metadata: { error: serializedError.message }
        });
        this.emit('error', {
          type: 'daily-call-join-error',
          stage: 'daily-call-join',
          error: serializedError,
          duration: joinDuration,
          timestamp: new Date().toISOString()
        });
        throw error;
      }

      // Stage 5: Video recording setup (if enabled)
      if (isVideoRecordingEnabled && callToken) {
        // The meeting token auto-started the recording at join, so there is
        // nothing to request from the client.
        this.emit('call-start-progress', {
          stage: 'video-recording-setup',
          status: 'completed',
          timestamp: new Date().toISOString(),
          metadata: { action: 'auto-started-via-meeting-token' }
        });
      } else if (isVideoRecordingEnabled) {
        this.emit('call-start-progress', {
          stage: 'video-recording-setup',
          status: 'started',
          timestamp: new Date().toISOString()
        });

        const recordingStartTime = Date.now();

        try {
          recordingRequestedTime = new Date().getTime();
          this.startRecording();

          const recordingSetupDuration = Date.now() - recordingStartTime;
          this.emit('call-start-progress', {
            stage: 'video-recording-setup',
            status: 'completed',
            duration: recordingSetupDuration,
            timestamp: new Date().toISOString()
          });
        } catch (error) {
          const recordingSetupDuration = Date.now() - recordingStartTime;
          const serializedError = serializeError(error);
          this.emit('call-start-progress', {
            stage: 'video-recording-setup',
            status: 'failed',
            duration: recordingSetupDuration,
            timestamp: new Date().toISOString(),
            metadata: { error: serializedError.message }
          });
          this.emit('error', {
            type: 'video-recording-setup-error',
            stage: 'video-recording-setup',
            error: serializedError,
            timestamp: new Date().toISOString()
          });
          // Don't throw here, video recording is optional
        }
      } else {
        this.emit('call-start-progress', {
          stage: 'video-recording-setup',
          status: 'completed',
          timestamp: new Date().toISOString(),
          metadata: { action: 'skipped-not-enabled' }
        });
      }

      // Stage 6: Audio level observer setup
      this.emit('call-start-progress', {
        stage: 'audio-observer-setup',
        status: 'started',
        timestamp: new Date().toISOString()
      });
      
      const audioObserverStartTime = Date.now();
      
      try {
        this.call.startRemoteParticipantsAudioLevelObserver(100);
        const audioObserverDuration = Date.now() - audioObserverStartTime;
        this.emit('call-start-progress', {
          stage: 'audio-observer-setup',
          status: 'completed',
          duration: audioObserverDuration,
          timestamp: new Date().toISOString()
        });
      } catch (error) {
        const audioObserverDuration = Date.now() - audioObserverStartTime;
        const serializedError = serializeError(error);
        this.emit('call-start-progress', {
          stage: 'audio-observer-setup',
          status: 'failed',
          duration: audioObserverDuration,
          timestamp: new Date().toISOString(),
          metadata: { error: serializedError.message }
        });
        this.emit('error', {
          type: 'audio-observer-setup-error',
          stage: 'audio-observer-setup',
          error: serializedError,
          timestamp: new Date().toISOString()
        });
        // Don't throw here, this is non-critical
      }

      this.call.on('remote-participants-audio-level', (e) => {
        if (e) this.handleRemoteParticipantsAudioLevel(e);
      });

      this.call.on('local-audio-level', (e) => {
        if (e) this.handleLocalAudioLevel(e);
      });

      this.call.on('app-message', (e) => this.onAppMessage(e));

      this.call.on('nonfatal-error', (e) => {
        // https://docs.daily.co/reference/daily-js/events/meeting-events#type-audio-processor-error
        if (e?.type === 'local-audio-level-observer-error') {
          this.emit('local-audio-level-observer-error', serializeError(e));
        }
        if (e?.type === 'audio-processor-error') {
          this.call
            ?.updateInputSettings({
              audio: {
                processor: {
                  type: 'none',
                },
              },
            })
            .then(() => {
              safeSetLocalAudio(this.call, true);
            })
            .catch((error) => {
              this.emitAudioProcessingError('audio-processor-recovery', error);
            });
        }
      });

      // Stage 7: Audio processing setup
      this.emit('call-start-progress', {
        stage: 'audio-processing-setup',
        status: 'started',
        timestamp: new Date().toISOString()
      });
      
      const audioProcessingStartTime = Date.now();
      
      try {
        const audioProcessingUpdate = this.call.updateInputSettings({
          audio: {
            processor: {
              type: 'noise-cancellation',
            },
          },
        });

        audioProcessingUpdate.catch((error) => {
          this.emitAudioProcessingError('audio-processing-setup', error);
        });

        // The observer waits for this update rather than starting alongside the
        // remote one above, so that Krisp has already swapped the microphone
        // track. See maybeStartLocalAudioLevelObserver().
        //
        // A separate chain, not another link on the one above: EventEmitter
        // rethrows out of emit('error') when a consumer registered no 'error'
        // listener, and whether the observer starts must not hinge on that.
        audioProcessingUpdate
          .catch(() => {})
          .then(() => this.maybeStartLocalAudioLevelObserver());

        const audioProcessingDuration = Date.now() - audioProcessingStartTime;
        this.emit('call-start-progress', {
          stage: 'audio-processing-setup',
          status: 'completed',
          duration: audioProcessingDuration,
          timestamp: new Date().toISOString()
        });
      } catch (error) {
        const audioProcessingDuration = Date.now() - audioProcessingStartTime;
        const serializedError = serializeError(error);
        this.emit('call-start-progress', {
          stage: 'audio-processing-setup',
          status: 'failed',
          duration: audioProcessingDuration,
          timestamp: new Date().toISOString(),
          metadata: { error: serializedError.message }
        });
        this.emit('error', {
          type: 'audio-processing-setup-error',
          stage: 'audio-processing-setup',
          error: serializedError,
          timestamp: new Date().toISOString()
        });
        // Don't throw here, this is non-critical
      }

      const totalDuration = Date.now() - startTime;
      this.emit('call-start-success', {
        totalDuration,
        callId: webCall?.id || 'unknown',
        timestamp: new Date().toISOString()
      });

      return webCall;
    } catch (e) {
      const totalDuration = Date.now() - startTime;
      const serializedError = serializeError(e);
      await this.cleanup();
      
      this.emit('call-start-failed', {
        stage: failureStage,
        totalDuration,
        error: serializedError.message,
        errorStack: serializedError.stack || 'No stack trace available',
        timestamp: new Date().toISOString(),
        context: {
          hasAssistant: !!assistant,
          hasSquad: !!squad,
          hasWorkflow: !!workflow,
          isMobile: this.isMobileDevice()
        }
      });
      
      // Also emit the generic error event for backward compatibility
      this.emit('error', {
        type: failureStage === 'microphone-preflight'
          ? `microphone-preflight-${e && typeof e === 'object' && 'name' in e ? e.name : 'error'}`
          : 'start-method-error',
        stage: failureStage,
        error: serializedError,
        totalDuration,
        timestamp: new Date().toISOString(),
        context: {
          hasAssistant: !!assistant,
          hasSquad: !!squad,
          hasWorkflow: !!workflow,
          isMobile: this.isMobileDevice()
        }
      });
      
      return null;
    }
  }

  private onAppMessage(e?: DailyEventObjectAppMessage) {
    if (!e) {
      return;
    }
    try {
      if (e.data === 'listening') {
        return this.emit('call-start');
      } else {
        try {
          const parsedMessage = JSON.parse(e.data);
          this.emit('message', parsedMessage);
          if (parsedMessage && 'type' in parsedMessage && 'status' in parsedMessage && parsedMessage.type === 'status-update' && parsedMessage.status === 'ended') {
            this.hasEmittedCallEndedStatus = true;
          }
        } catch (parseError) {
          console.log('Error parsing message data: ', parseError);
        }
      }
    } catch (e) {
      console.error(e);
    }
  }

  private handleRemoteParticipantsAudioLevel(
    e: DailyEventObjectRemoteParticipantsAudioLevel,
  ) {
    const speechLevel = Object.values(e.participantsAudioLevel).reduce(
      (a, b) => a + b,
      0,
    );

    this.emit('volume-level', Math.min(1, speechLevel / 0.15));

    const isSpeaking = speechLevel > 0.01;

    if (!isSpeaking) {
      return;
    }

    if (this.speakingTimeout) {
      clearTimeout(this.speakingTimeout);
      this.speakingTimeout = null;
    } else {
      this.emit('speech-start');
    }

    this.speakingTimeout = setTimeout(() => {
      this.emit('speech-end');
      this.speakingTimeout = null;
    }, 1000);
  }

  private handleLocalAudioLevel(e: DailyEventObjectLocalAudioLevel) {
    this.emit('local-volume-level', e.audioLevel);
  }

  /**
   * Stops the call by destroying the Daily call object.
   * 
   * If `roomDeleteOnUserLeaveEnabled` is set to `false`, the Vapi call will be kept alive, allowing reconnections to the same call using the `reconnect` method.
   * If `roomDeleteOnUserLeaveEnabled` is set to `true`, the Vapi call will also be destroyed, preventing any reconnections.
   */
  async stop(): Promise<void> {
    if (this.cancelMicrophonePreflight) {
      this.cancelMicrophonePreflight();
      return;
    }
    this.microphoneTrack?.stop();
    this.microphoneTrack = null;
    this.started = false;
    if (this.call) {
      await this.call.destroy();
      this.call = null;
    }
    this.audioPlayer = null;
    this.pendingAudioBuilds.clear();
    this.speakingTimeout = null;
  }

  /**
   * Sends a Live Call Control message to the Vapi server.
   * 
   * Docs: https://docs.vapi.ai/calls/call-features
   */
  send(message: VapiClientToServerMessage): void {
    this.call?.sendAppMessage(JSON.stringify(message));
  }

  /**
   * The two places this class touches the DOM, behind indirections so the
   * lifecycle logic around them is testable without a browser.
   */
  private audioPlayerBuild(
    track: MediaStreamTrack,
    participantId: string,
    volume?: number | null,
  ): Promise<HTMLAudioElement> {
    return buildAudioPlayer(track, participantId, volume);
  }

  private audioPlayerDestroy(participantId: string): void {
    destroyAudioPlayer(participantId);
  }

  /**
   * The remembered volume, bounded, or null if there is nothing to apply.
   * Shared by both callers so they cannot disagree: the DOM throws on a
   * non-finite or out-of-range volume, and that throw would stall the call.
   */
  private desiredVolumeResolve(): number | null {
    if (this.desiredVolume === null || !Number.isFinite(this.desiredVolume)) {
      return null;
    }
    return Math.min(1, Math.max(0, this.desiredVolume));
  }

  /** Shared by the initial and reconnect paths so the two cannot drift. */
  private async handleTrackStarted(e?: DailyEventObjectTrack) {
    if (!e || !e.participant) {
      return;
    }
    if (e.participant?.local) {
      return;
    }
    if (e.participant?.user_name !== 'Vapi Speaker') {
      return;
    }
    if (e.track.kind === 'video') {
      this.emitToConsumer('video', e.track);
    }
    if (e.track.kind === 'audio') {
      // play() pends for the whole of media startup, so the call can end or
      // the participant can leave while the player is still being built.
      const call = this.call;
      const build = ++this.audioBuildSequence;
      this.pendingAudioBuilds.set(build, e.participant.session_id);

      let player: HTMLAudioElement;
      try {
        player = await this.audioPlayerBuild(
          e.track,
          e.participant.session_id,
          this.desiredVolumeResolve(),
        );
      } catch (error) {
        // Usually autoplay policy, which is recoverable, so consumers get a
        // signal to prompt for a gesture. Safe with no 'error' listener:
        // emitToConsumer catches EventEmitter's unlistened-'error' throw.
        this.pendingAudioBuilds.delete(build);
        console.error('[vapi] could not start assistant audio', error);
        this.emitToConsumer('error', {
          type: 'audio-start-failed',
          error: serializeError(error),
        });
        return;
      }

      const stillPending = this.pendingAudioBuilds.delete(build);
      if (
        !call ||
        this.call !== call ||
        !stillPending ||
        build < this.attachedAudioBuild
      ) {
        player.remove();
        return;
      }
      this.attachedAudioBuild = build;
      this.attachAudioPlayer(player);
    }
    this.call?.sendAppMessage('playable');
  }

  /**
   * Assigns before emitting, since emit is synchronous and a listener may call
   * getAudioPlayer or setVolume during the event.
   */
  private attachAudioPlayer(player: HTMLAudioElement) {
    // Renegotiation reuses the participant id, so a superseded element would
    // still match the selector teardown uses and be removed in its place.
    if (this.audioPlayer && this.audioPlayer !== player) {
      this.audioPlayer.remove();
    }
    // Reapplied in case the volume changed while the player was building.
    const volume = this.desiredVolumeResolve();
    if (volume !== null) {
      player.volume = volume;
    }
    this.audioPlayer = player;
    this.emitToConsumer('audio', player);
  }

  /**
   * A listener that throws must not take down the caller: track-started still
   * has to signal that playback is ready. Not routed to the `error` event,
   * which EventEmitter throws on when nothing is listening.
   */
  private emitToConsumer<E extends VapiEventNames>(
    event: E,
    ...args: Parameters<VapiEventListeners[E]>
  ) {
    try {
      this.emit(event, ...args);
    } catch (error) {
      console.error(`[vapi] ${event} event listener threw`, error);
    }
  }

  /** Drops the reference before removing, so nothing hands out a detached element. */
  private detachAudioPlayer(participantId: string) {
    if (this.audioPlayer?.dataset.participantId === participantId) {
      this.audioPlayer = null;
    }
    // Scoped to this participant: the call check cannot catch these, since the
    // call itself has not changed, and an unrelated leave must not invalidate
    // the assistant's build.
    for (const [build, id] of this.pendingAudioBuilds) {
      if (id === participantId) {
        this.pendingAudioBuilds.delete(build);
      }
    }
    this.audioPlayerDestroy(participantId);
  }

  /**
   * The <audio> element playing the assistant, or null before its track has
   * arrived. Pair with the `audio` event when you need it the moment it exists.
   */
  public getAudioPlayer(): HTMLAudioElement | null {
    return this.audioPlayer;
  }

  /**
   * Sets assistant playback volume, 0 to 1.
   *
   * The setting is remembered, so it can be applied before the assistant's
   * audio track has arrived and it survives across calls and mid-call track
   * replacement. Callers do not have to race the start of the call.
   *
   * Values outside 0 to 1 are clamped and non-finite values are ignored, since
   * the DOM rejects both rather than saturating.
   *
   * Only volume set through this method is remembered. Writing `volume`
   * directly on the element from getAudioPlayer() or the `audio` event applies
   * to that element alone, and is overwritten the next time one is attached.
   *
   * This is playback only. It does not change what the assistant hears, and it
   * does not affect the levels reported by the `volume-level` event.
   */
  public setVolume(volume: number) {
    if (!Number.isFinite(volume)) {
      return;
    }
    this.desiredVolume = Math.min(1, Math.max(0, volume));
    if (this.audioPlayer) {
      this.audioPlayer.volume = this.desiredVolume;
    }
  }

  public setMuted(mute: boolean) {
    safeSetLocalAudio(this.call, !mute);
  }

  public isMuted() {
    if (!this.call) {
      return false;
    }
    return this.call.localAudio() === false;
  }

  public say(message: string, endCallAfterSpoken?: boolean, 
    interruptionsEnabled?: boolean, interruptAssistantEnabled?: boolean) {
    this.send({
      type: 'say',
      message,
      endCallAfterSpoken,
      interruptionsEnabled: interruptionsEnabled ?? false,
      interruptAssistantEnabled: interruptAssistantEnabled ?? false,
    });
  }

  /**
   * Ends the call immediately by sending a `end-call` message using Live Call Control, and destroys the Daily call object.
   * 
   * This method always ends the call, regardless of the `roomDeleteOnUserLeaveEnabled` option.
   */
  public end() {
    this.send({
      type: 'end-call',
    });
    this.stop();
  }

  public setInputDevicesAsync(
    options: Parameters<DailyCall['setInputDevicesAsync']>[0],
  ) {
    return safeSetInputDevicesAsync(this.call, options);
  }

  public async increaseMicLevel(gain: number) {
    if (!this.call) {
      throw new Error('Call object is not available.');
    }
    
    try {
      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
      const audioContext = new AudioContext();
  
      const source = audioContext.createMediaStreamSource(stream);
      
      const gainNode = audioContext.createGain();
      gainNode.gain.value = gain;
      
      source.connect(gainNode);
      
      const destination = audioContext.createMediaStreamDestination();
      gainNode.connect(destination);
  
      const [boostedTrack] = destination.stream.getAudioTracks();
      await safeSetInputDevicesAsync(this.call, { audioSource: boostedTrack });      
    } catch (error) {
      console.error("Error adjusting microphone level:", error);
    }
  }  

  public setOutputDeviceAsync(
    options: Parameters<DailyCall['setOutputDeviceAsync']>[0],
  ) {
    this.call?.setOutputDeviceAsync(options);
  }

  public getDailyCallObject(): DailyCall | null {
    return this.call;
  }

  /**
   * Returns the most recent local (microphone) audio level, a number between 0 and 1.
   *
   * Useful for detecting when the local participant's microphone is not picking up any
   * audio (e.g. wrong input device selected, OS-level input volume at 0, or muted
   * hardware) so you can surface a "we can't hear you" style warning in your UI.
   *
   * Returns 0 when there is no active call.
   */
  public getLocalAudioLevel(): number {
    if (!this.call) {
      return 0;
    }
    return this.call.getLocalAudioLevel();
  }

  /**
   * Starts (or restarts) the local audio level observer. The observer is started
   * automatically when a call begins, but this can be used to change the sampling
   * interval or restart it if it was stopped.
   *
   * While running, the Vapi instance emits 'local-volume-level' events with the local
   * microphone audio level (0 to 1).
   *
   * @param interval How often, in milliseconds, to emit audio level events. Defaults to Daily's default.
   */
  public async startLocalAudioLevelObserver(interval?: number): Promise<void> {
    if (!this.call) {
      throw new Error('Call object is not available.');
    }
    await this.call.startLocalAudioLevelObserver(interval);
  }

  /**
   * Stops the local audio level observer. After calling this, 'local-volume-level'
   * events will no longer be emitted until the observer is started again.
   */
  public stopLocalAudioLevelObserver(): void {
    this.call?.stopLocalAudioLevelObserver();
  }

  /**
   * Returns whether the local audio level observer is currently running.
   */
  public isLocalAudioLevelObserverRunning(): boolean {
    if (!this.call) {
      return false;
    }
    return this.call.isLocalAudioLevelObserverRunning();
  }

  public startScreenSharing(displayMediaOptions?: DisplayMediaStreamOptions, screenVideoSendSettings?: DailyVideoSendSettings) {
    this.call?.startScreenShare({
      displayMediaOptions,
      screenVideoSendSettings,
    });
  }

  public stopScreenSharing() {
    this.call?.stopScreenShare();
  }

  /**
   * Starts (or retries) a cloud recording of the call.
   *
   * Recording start is asynchronous: success is signaled by the
   * 'recording-started' event and failure by 'recording-error'. Daily does not
   * retry automatically, so if you receive 'recording-error' (e.g. the
   * recording start timed out), you can call this method again a few seconds
   * later to retry.
   */
  public startRecording(): void {
    if (!this.call) {
      throw new Error('Call object is not available.');
    }
    this.call.startRecording({
      width: 1280,
      height: 720,
      backgroundColor: '#FF1F2D3D',
      layout: {
        preset: 'default',
      },
    });
  }

  /**
   * Stops the in-progress recording. Completion is signaled by the
   * 'recording-stopped' event.
   */
  public stopRecording(): void {
    this.call?.stopRecording();
  }

  /**
   * Reconnects to an active call.
   * 
   * 
   * @param webCall 
   */
  async reconnect(webCall: WebCall): Promise<void> {
    const startTime = Date.now();
    
    if (this.started) {
      throw new Error('Cannot reconnect while a call is already in progress. Call stop() first.');
    }

    if (!webCall.webCallUrl) {
      throw new Error('webCallUrl is required for reconnection.');
    }

    this.emit('call-start-progress', {
      stage: 'reconnect-initialization',
      status: 'started',
      timestamp: new Date().toISOString(),
      metadata: {
        callId: webCall.id || 'unknown',
        hasVideoRecording: !!webCall?.artifactPlan?.videoRecordingEnabled,
        voiceProvider: webCall?.assistant?.voice?.provider || 'unknown'
      }
    });

    this.started = true;

    try {
      // Clean up any existing call object
      if (this.call) {
        this.emit('call-start-progress', {
          stage: 'cleanup-existing-call',
          status: 'started',
          timestamp: new Date().toISOString()
        });
        await this.cleanup();
        this.emit('call-start-progress', {
          stage: 'cleanup-existing-call',
          status: 'completed',
          timestamp: new Date().toISOString()
        });
      }

      const isVideoRecordingEnabled = webCall?.artifactPlan?.videoRecordingEnabled ?? false;
      const isVideoEnabled = webCall?.assistant?.voice?.provider === 'tavus';

      // Same auto-start token as in start(). Rejoining with it while the
      // recording is still running is safe; if the recording stopped when the
      // user left, the token starts a new one.
      const callToken = webCall?.transport?.callToken;

      // Stage 1: Create Daily call object
      this.emit('call-start-progress', {
        stage: 'daily-call-object-creation',
        status: 'started',
        timestamp: new Date().toISOString(),
        metadata: {
          audioSource: this.dailyCallObject.audioSource ?? true,
          videoSource: this.dailyCallObject.videoSource ?? isVideoRecordingEnabled,
          isVideoRecordingEnabled,
          isVideoEnabled
        }
      });

      const dailyCallStartTime = Date.now();
      this.call = DailyIframe.createCallObject({
        audioSource: this.dailyCallObject.audioSource ?? true,
        videoSource: this.dailyCallObject.videoSource ?? isVideoRecordingEnabled,
        dailyConfig: this.dailyCallConfig,
      });

      const dailyCallDuration = Date.now() - dailyCallStartTime;
      this.emit('call-start-progress', {
        stage: 'daily-call-object-creation',
        status: 'completed',
        duration: dailyCallDuration,
        timestamp: new Date().toISOString()
      });

      this.call.iframe()?.style.setProperty('display', 'none');

      // Set up event listeners
      this.call.on('left-meeting', () => {
        this.emit('call-end');
        if (!this.hasEmittedCallEndedStatus) {
          this.emit('message', {
            type: 'status-update',
            status: 'ended',
            'endedReason': 'customer-ended-call',
          });
          this.hasEmittedCallEndedStatus = true;
        }
        if (isVideoRecordingEnabled) {
          // When using a token, the recording doesn't stop automatically on
          // leave, so still stop it manually to preserve existing behavior.
          this.call?.stopRecording();
        }
        this.cleanup().catch(console.error);
      });

      this.call.on('error', (error: any) => {
        this.emit('error', {
          type: 'daily-error',
          error: serializeError(error),
          timestamp: new Date().toISOString()
        });
        if (isVideoRecordingEnabled) {
          this.call?.stopRecording();
        }
      });

      this.call.on('camera-error', (error: any) => {
        this.emit('camera-error', {
          type: 'camera-error',
          error: serializeError(error),
          timestamp: new Date().toISOString()
        });
      });

      this.call.on('network-quality-change', (event: any) => {
        this.emit('network-quality-change', event);
      });

      this.call.on('network-connection', (event: any) => {
        this.emit('network-connection', event);
      });

      this.call.on('recording-started', (event) => {
        if (event) this.emit('recording-started', event);
      });

      this.call.on('recording-stopped', (event) => {
        if (event) this.emit('recording-stopped', event);
      });

      this.call.on('recording-stats', (event) => {
        if (event) this.emit('recording-stats', event);
      });

      this.call.on('recording-error', (event) => {
        if (event) this.emit('recording-error', event);
      });

      this.call.on('recording-upload-completed', (event) => {
        if (event) this.emit('recording-upload-completed', event);
      });

      this.call.on('track-started', (e) => this.handleTrackStarted(e));

      this.call.on('participant-joined', (e) => {
        if (!e || !this.call) return;
        subscribeToTracks(
          e,
          this.call,
          isVideoRecordingEnabled,
          isVideoEnabled,
        );
      });

      this.call.on('participant-updated', (e) => {
        if (!e) {
          return;
        }
        this.emit('daily-participant-updated', e.participant);
      });

      this.call.on('participant-left', (e) => {
        if (!e) {
          return;
        }
        this.detachAudioPlayer(e.participant.session_id);
      });

      this.call.on('remote-participants-audio-level', (e) => {
        if (e) this.handleRemoteParticipantsAudioLevel(e);
      });

      this.call.on('local-audio-level', (e) => {
        if (e) this.handleLocalAudioLevel(e);
      });

      this.call.on('app-message', (e) => this.onAppMessage(e));

      this.call.on('nonfatal-error', (e) => {
        // https://docs.daily.co/reference/daily-js/events/meeting-events#type-audio-processor-error
        if (e?.type === 'local-audio-level-observer-error') {
          this.emit('local-audio-level-observer-error', serializeError(e));
        }
        if (e?.type === 'audio-processor-error') {
          this.call
            ?.updateInputSettings({
              audio: {
                processor: {
                  type: 'none',
                },
              },
            })
            .then(() => {
              safeSetLocalAudio(this.call, true);
            })
            .catch((error) => {
              this.emitAudioProcessingError('audio-processor-recovery', error);
            });
        }
      });

      // Registered before join(): a token-auto-started recording can begin
      // while join() is still in flight, so a listener added after join
      // could miss the event.
      let recordingRequestedTime = 0;
      if (isVideoRecordingEnabled) {
        this.call.once('recording-started', () => {
          const totalRecordingDelay = (new Date().getTime() - recordingRequestedTime) / 1000;
          this.emit('call-start-progress', {
            stage: 'video-recording-started',
            status: 'completed',
            timestamp: new Date().toISOString(),
            metadata: { delaySeconds: totalRecordingDelay }
          });

          this.send({
            type: 'control',
            control: 'say-first-message',
            videoRecordingStartDelaySeconds: totalRecordingDelay,
          });
        });
      }

      // Stage 2: Mobile device handling and permissions
      const isMobile = this.isMobileDevice();
      this.emit('call-start-progress', {
        stage: 'mobile-permissions',
        status: 'started',
        timestamp: new Date().toISOString(),
        metadata: { isMobile }
      });
      
      if (isMobile) {
        const mobileWaitStartTime = Date.now();
        await this.sleep(1000);
        const mobileWaitDuration = Date.now() - mobileWaitStartTime;
        this.emit('call-start-progress', {
          stage: 'mobile-permissions',
          status: 'completed',
          duration: mobileWaitDuration,
          timestamp: new Date().toISOString(),
          metadata: { action: 'permissions-wait' }
        });
      } else {
        this.emit('call-start-progress', {
          stage: 'mobile-permissions',
          status: 'completed',
          timestamp: new Date().toISOString(),
          metadata: { action: 'skipped-not-mobile' }
        });
      }

      // Stage 3: Join the call
      this.emit('call-start-progress', {
        stage: 'daily-call-join',
        status: 'started',
        timestamp: new Date().toISOString()
      });
      
      const joinStartTime = Date.now();
      recordingRequestedTime = joinStartTime;
      await this.call.join({
        url: webCall.webCallUrl,
        // daily-js rejects a `token` key that is present but undefined, so
        // only include it when the server actually sent one.
        ...(callToken ? { token: callToken } : {}),
        subscribeToTracksAutomatically: false,
      });
      
      const joinDuration = Date.now() - joinStartTime;
      this.emit('call-start-progress', {
        stage: 'daily-call-join',
        status: 'completed',
        duration: joinDuration,
        timestamp: new Date().toISOString()
      });

      // Stage 4: Video recording setup (if enabled)
      if (isVideoRecordingEnabled && callToken) {
        // The meeting token auto-started the recording at join, so there is
        // nothing to request from the client.
        this.emit('call-start-progress', {
          stage: 'video-recording-setup',
          status: 'completed',
          timestamp: new Date().toISOString(),
          metadata: { action: 'auto-started-via-meeting-token' }
        });
      } else if (isVideoRecordingEnabled) {
        this.emit('call-start-progress', {
          stage: 'video-recording-setup',
          status: 'started',
          timestamp: new Date().toISOString()
        });

        const recordingStartTime = Date.now();

        try {
          recordingRequestedTime = new Date().getTime();
          this.startRecording();

          const recordingSetupDuration = Date.now() - recordingStartTime;
          this.emit('call-start-progress', {
            stage: 'video-recording-setup',
            status: 'completed',
            duration: recordingSetupDuration,
            timestamp: new Date().toISOString()
          });
        } catch (error) {
          const recordingSetupDuration = Date.now() - recordingStartTime;
          const serializedError = serializeError(error);
          this.emit('call-start-progress', {
            stage: 'video-recording-setup',
            status: 'failed',
            duration: recordingSetupDuration,
            timestamp: new Date().toISOString(),
            metadata: { error: serializedError.message }
          });
          // Don't throw here, video recording is optional
        }
      } else {
        this.emit('call-start-progress', {
          stage: 'video-recording-setup',
          status: 'completed',
          timestamp: new Date().toISOString(),
          metadata: { action: 'skipped-not-enabled' }
        });
      }

      // Stage 5: Audio level observer setup
      this.emit('call-start-progress', {
        stage: 'audio-observer-setup',
        status: 'started',
        timestamp: new Date().toISOString()
      });
      
      const audioObserverStartTime = Date.now();
      
      try {
        this.call.startRemoteParticipantsAudioLevelObserver(100);
        const audioObserverDuration = Date.now() - audioObserverStartTime;
        this.emit('call-start-progress', {
          stage: 'audio-observer-setup',
          status: 'completed',
          duration: audioObserverDuration,
          timestamp: new Date().toISOString()
        });
      } catch (error) {
        const audioObserverDuration = Date.now() - audioObserverStartTime;
        const serializedError = serializeError(error);
        this.emit('call-start-progress', {
          stage: 'audio-observer-setup',
          status: 'failed',
          duration: audioObserverDuration,
          timestamp: new Date().toISOString(),
          metadata: { error: serializedError.message }
        });
        // Don't throw here, this is non-critical
      }

      // Stage 6: Audio processing setup
      this.emit('call-start-progress', {
        stage: 'audio-processing-setup',
        status: 'started',
        timestamp: new Date().toISOString()
      });
      
      const audioProcessingStartTime = Date.now();
      
      try {
        const audioProcessingUpdate = this.call.updateInputSettings({
          audio: {
            processor: {
              type: 'noise-cancellation',
            },
          },
        });

        audioProcessingUpdate.catch((error) => {
          this.emitAudioProcessingError('audio-processing-setup', error);
        });

        // The observer waits for this update rather than starting alongside the
        // remote one above, so that Krisp has already swapped the microphone
        // track. See maybeStartLocalAudioLevelObserver().
        //
        // A separate chain, not another link on the one above: EventEmitter
        // rethrows out of emit('error') when a consumer registered no 'error'
        // listener, and whether the observer starts must not hinge on that.
        audioProcessingUpdate
          .catch(() => {})
          .then(() => this.maybeStartLocalAudioLevelObserver());

        const audioProcessingDuration = Date.now() - audioProcessingStartTime;
        this.emit('call-start-progress', {
          stage: 'audio-processing-setup',
          status: 'completed',
          duration: audioProcessingDuration,
          timestamp: new Date().toISOString()
        });
      } catch (error) {
        const audioProcessingDuration = Date.now() - audioProcessingStartTime;
        const serializedError = serializeError(error);
        this.emit('call-start-progress', {
          stage: 'audio-processing-setup',
          status: 'failed',
          duration: audioProcessingDuration,
          timestamp: new Date().toISOString(),
          metadata: { error: serializedError.message }
        });
        // Don't throw here, this is non-critical
      }

      const totalDuration = Date.now() - startTime;
      this.emit('call-start-success', {
        totalDuration,
        callId: webCall?.id || 'unknown',
        timestamp: new Date().toISOString()
      });

      this.emit('call-start');

    } catch (e) {
      const totalDuration = Date.now() - startTime;
      const serializedError = serializeError(e);
      
      this.emit('call-start-failed', {
        stage: 'reconnect',
        totalDuration,
        error: serializedError.message,
        errorStack: serializedError.stack || 'No stack trace available',
        timestamp: new Date().toISOString(),
        context: {
          isReconnect: true,
          callId: webCall?.id || 'unknown',
          hasVideoRecording: !!webCall?.artifactPlan?.videoRecordingEnabled,
          voiceProvider: webCall?.assistant?.voice?.provider || 'unknown',
          isMobile: this.isMobileDevice()
        }
      });
      
      // Also emit the generic error event for backward compatibility
      this.emit('error', {
        type: 'reconnect-error',
        error: serializedError,
        totalDuration,
        timestamp: new Date().toISOString(),
        context: {
          isReconnect: true,
          callId: webCall?.id || 'unknown',
          hasVideoRecording: !!webCall?.artifactPlan?.videoRecordingEnabled,
          voiceProvider: webCall?.assistant?.voice?.provider || 'unknown',
          isMobile: this.isMobileDevice()
        }
      });
      
      await this.cleanup();
      throw e;
    }
  }

  /**
   * Runs all network connectivity tests for pre-call diagnostics.
   * Creates a temporary Daily call object for testing purposes.
   * 
   * Tests performed:
   * 1. Network connectivity (TURN server) - Tests if traffic can be relayed through TURN servers
   * 2. Websocket connectivity - Tests if websocket connections can be established  
   * 3. Call quality - Tests overall call quality metrics (if available in SDK version)
   * 
   * @returns {Promise<Record<string, any>>} Test results object with status for each test
   * 
   * @example
   * // Run pre-call network diagnostics
   * const results = await Vapi.runNetworkTestsStandalone();
   * if (results.networkConnectivity?.result === 'failed') {
   *   console.warn('Network issues detected - calls may not work properly');
   * }
   * 
   * @static
   */
  public static async runNetworkTestsStandalone(): Promise<Record<string, any>> {
    console.log('Starting standalone network connectivity tests...');
    
    const results: Record<string, any> = {};
    let tempCall: DailyCall | null = null;
    
    try {
      // Create a temporary call object for testing
      console.log('Creating temporary call object for testing...');
      tempCall = DailyIframe.createCallObject({
        audioSource: true,
        videoSource: true,
      });

      // Test 1: Network Connectivity (TURN server test)
      console.log('\n1. Testing network connectivity (TURN server)...');
      let videoTrack: MediaStreamTrack | null = null;
      
      try {
        // Create a dummy video track for the test
        const stream = await navigator.mediaDevices.getUserMedia({ video: true });
        videoTrack = stream.getVideoTracks()[0];
        
        const networkTest = await tempCall.testNetworkConnectivity(videoTrack);
        results.networkConnectivity = networkTest;
        console.log('Network connectivity test result:', networkTest);
      } catch (error) {
        results.networkConnectivity = { result: 'error', error: error?.toString() };
        console.error('Network connectivity test error:', error);
      } finally {
        // Clean up the video track
        if (videoTrack) {
          videoTrack.stop();
        }
      }

      // Test 2: Websocket Connectivity
      console.log('\n2. Testing websocket connectivity...');
      try {
        const websocketTest = await tempCall.testWebsocketConnectivity();
        results.websocketConnectivity = websocketTest;
        console.log('Websocket connectivity test result:', websocketTest);
      } catch (error) {
        results.websocketConnectivity = { result: 'error', error: error?.toString() };
        console.error('Websocket connectivity test error:', error);
      }

      // Test 3: Call Quality (if available)
      console.log('\n3. Testing call quality...');
      try {
        // Check if the method exists
        if (typeof tempCall.testCallQuality === 'function') {
          // Call quality test requires startCamera to initialize call state
          try {
            // Use startCamera to initialize the call state without needing a room
            console.log('Initializing call state with startCamera...');
            await tempCall.startCamera();
            
            // Now run the call quality test
            const callQualityTest = await tempCall.testCallQuality();
            results.callQuality = callQualityTest;
            console.log('Call quality test result:', callQualityTest);
            
            // Camera will be cleaned up when we destroy the call object
          } catch (startCameraError: any) {
            // If startCamera fails, it might be due to permissions or other issues
            console.error('Failed to start camera for call quality test:', startCameraError);
            results.callQuality = { 
              result: 'error', 
              error: startCameraError?.toString(),
              message: 'Failed to initialize camera for call quality test. Check camera permissions.' 
            };
          }
        } else {
          results.callQuality = { result: 'not-available', message: 'testCallQuality method not available' };
          console.log('Call quality test not available in current Daily.co version');
        }
      } catch (error: any) {
        results.callQuality = { result: 'error', error: error?.toString() };
        console.error('Call quality test error:', error);
      }

    } catch (error) {
      console.error('Failed to create temporary call object:', error);
      results.error = error?.toString();
    } finally {
      // Clean up the temporary call object
      if (tempCall) {
        try {
          console.log('Cleaning up temporary call object...');
          await tempCall.destroy();
        } catch (error) {
          console.error('Error destroying temporary call object:', error);
        }
      }
    }

    // Summary
    console.log('\n=== Network Test Summary ===');
    console.log('Results:', JSON.stringify(results, null, 2));
    
    return results;
  }

}