@vapi-ai/web 2.4.0 → 2.5.0

package/api.ts

@@ -18143,6 +18143,15 @@ export interface CreateWebCallDTO {
   workflow?: CreateWorkflowDTO;
   /** These are the overrides for the `workflow` or `workflowId`'s settings and template variables. */
   workflowOverrides?: WorkflowOverrides;
+  /**
+   * 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;
 }
 
 export interface UpdateCallDTO {

package/dist/api.d.ts

@@ -11558,6 +11558,15 @@ export interface CreateWebCallDTO {
     workflow?: CreateWorkflowDTO;
     /** These are the overrides for the `workflow` or `workflowId`'s settings and template variables. */
     workflowOverrides?: WorkflowOverrides;
+    /**
+     * 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;
 }
 export interface UpdateCallDTO {
     /**

package/dist/vapi.d.ts

@@ -2,6 +2,9 @@ import type { ChatCompletionMessageParam } from 'openai/resources';
 import { DailyCall, DailyAdvancedConfig, DailyFactoryOptions, DailyParticipant, DailyVideoSendSettings } from '@daily-co/daily-js';
 import EventEmitter from 'events';
 import { Call, CreateSquadDTO, CreateAssistantDTO, AssistantOverrides, CreateWorkflowDTO, WorkflowOverrides } from './api';
+export interface EndCallMessage {
+    type: 'end-call';
+}
 export interface AddMessageMessage {
     type: 'add-message';
     message: ChatCompletionMessageParam;
@@ -19,7 +22,7 @@ export interface SayMessage {
     interruptionsEnabled?: boolean;
     interruptAssistantEnabled?: boolean;
 }
-type VapiClientToServerMessage = AddMessageMessage | ControlMessages | SayMessage;
+type VapiClientToServerMessage = AddMessageMessage | ControlMessages | SayMessage | EndCallMessage;
 type VapiEventNames = 'call-end' | 'call-start' | 'volume-level' | 'speech-start' | 'speech-end' | 'message' | 'video' | 'error' | 'camera-error' | 'network-quality-change' | 'network-connection' | 'daily-participant-updated' | 'call-start-progress' | 'call-start-success' | 'call-start-failed';
 interface CallStartProgressEvent {
     stage: string;
@@ -58,6 +61,47 @@ type VapiEventListeners = {
     'call-start-success': (event: CallStartSuccessEvent) => void;
     'call-start-failed': (event: CallStartFailedEvent) => void;
 };
+type StartCallOptions = {
+    /**
+     * 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;
+        };
+    };
+};
 declare class VapiEventEmitter extends EventEmitter {
     on<E extends VapiEventNames>(event: E, listener: VapiEventListeners[E]): this;
     once<E extends VapiEventNames>(event: E, listener: VapiEventListeners[E]): this;
@@ -76,19 +120,43 @@ export default class Vapi extends VapiEventEmitter {
     private cleanup;
     private isMobileDevice;
     private sleep;
-    start(assistant?: CreateAssistantDTO | string, assistantOverrides?: AssistantOverrides, squad?: CreateSquadDTO | string, workflow?: CreateWorkflowDTO | string, workflowOverrides?: WorkflowOverrides): Promise<Call | null>;
+    start(assistant?: CreateAssistantDTO | string, assistantOverrides?: AssistantOverrides, squad?: CreateSquadDTO | string, workflow?: CreateWorkflowDTO | string, workflowOverrides?: WorkflowOverrides, options?: StartCallOptions): Promise<Call | null>;
     private onAppMessage;
     private handleRemoteParticipantsAudioLevel;
+    /**
+     * 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.
+     */
     stop(): Promise<void>;
+    /**
+     * Sends a Live Call Control message to the Vapi server.
+     *
+     * Docs: https://docs.vapi.ai/calls/call-features
+     */
     send(message: VapiClientToServerMessage): void;
     setMuted(mute: boolean): void;
     isMuted(): boolean;
     say(message: string, endCallAfterSpoken?: boolean, interruptionsEnabled?: boolean, interruptAssistantEnabled?: boolean): void;
+    /**
+     * 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.
+     */
+    end(): void;
     setInputDevicesAsync(options: Parameters<DailyCall['setInputDevicesAsync']>[0]): Promise<void>;
     increaseMicLevel(gain: number): Promise<void>;
     setOutputDeviceAsync(options: Parameters<DailyCall['setOutputDeviceAsync']>[0]): void;
     getDailyCallObject(): DailyCall | null;
     startScreenSharing(displayMediaOptions?: DisplayMediaStreamOptions, screenVideoSendSettings?: DailyVideoSendSettings): void;
     stopScreenSharing(): void;
+    /**
+     * Reconnects to an active call.
+     *
+     *
+     * @param webCall
+     */
+    reconnect(webCall: WebCall): Promise<void>;
 }
 export {};

package/dist/vapi.js

@@ -90,7 +90,7 @@ class Vapi extends VapiEventEmitter {
     async sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    async start(assistant, assistantOverrides, squad, workflow, workflowOverrides) {
+    async start(assistant, assistantOverrides, squad, workflow, workflowOverrides, options) {
         const startTime = Date.now();
         // Input validation with detailed error messages
         if (!assistant && !squad && !workflow) {
@@ -140,6 +140,7 @@ class Vapi extends VapiEventEmitter {
                 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', {
@@ -587,6 +588,12 @@ class Vapi extends VapiEventEmitter {
             this.speakingTimeout = null;
         }, 1000);
     }
+    /**
+     * 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() {
         this.started = false;
         if (this.call) {
@@ -595,6 +602,11 @@ class Vapi extends VapiEventEmitter {
         }
         this.speakingTimeout = null;
     }
+    /**
+     * Sends a Live Call Control message to the Vapi server.
+     *
+     * Docs: https://docs.vapi.ai/calls/call-features
+     */
     send(message) {
         this.call?.sendAppMessage(JSON.stringify(message));
     }
@@ -616,6 +628,17 @@ class Vapi extends VapiEventEmitter {
             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.
+     */
+    end() {
+        this.send({
+            type: 'end-call',
+        });
+        this.stop();
+    }
     setInputDevicesAsync(options) {
         return (0, daily_guards_1.safeSetInputDevicesAsync)(this.call, options);
     }
@@ -654,5 +677,370 @@ class Vapi extends VapiEventEmitter {
     stopScreenSharing() {
         this.call?.stopScreenShare();
     }
+    /**
+     * Reconnects to an active call.
+     *
+     *
+     * @param webCall
+     */
+    async reconnect(webCall) {
+        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';
+            // 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 = daily_js_1.default.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) {
+                    this.call?.stopRecording();
+                }
+                this.cleanup().catch(console.error);
+            });
+            this.call.on('error', (error) => {
+                this.emit('error', error);
+                if (isVideoRecordingEnabled) {
+                    this.call?.stopRecording();
+                }
+            });
+            this.call.on('camera-error', (error) => {
+                this.emit('camera-error', error);
+            });
+            this.call.on('network-quality-change', (event) => {
+                this.emit('network-quality-change', event);
+            });
+            this.call.on('network-connection', (event) => {
+                this.emit('network-connection', event);
+            });
+            this.call.on('track-started', async (e) => {
+                if (!e || !e.participant) {
+                    return;
+                }
+                if (e.participant?.local) {
+                    return;
+                }
+                if (e.participant?.user_name !== 'Vapi Speaker') {
+                    return;
+                }
+                if (e.track.kind === 'video') {
+                    this.emit('video', e.track);
+                }
+                if (e.track.kind === 'audio') {
+                    await buildAudioPlayer(e.track, e.participant.session_id);
+                }
+                this.call?.sendAppMessage('playable');
+            });
+            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;
+                }
+                destroyAudioPlayer(e.participant.session_id);
+            });
+            this.call.on('remote-participants-audio-level', (e) => {
+                if (e)
+                    this.handleRemoteParticipantsAudioLevel(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 === 'audio-processor-error') {
+                    this.call
+                        ?.updateInputSettings({
+                        audio: {
+                            processor: {
+                                type: 'none',
+                            },
+                        },
+                    })
+                        .then(() => {
+                        (0, daily_guards_1.safeSetLocalAudio)(this.call, true);
+                    });
+                }
+            });
+            // 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();
+            await this.call.join({
+                url: webCall.webCallUrl,
+                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) {
+                this.emit('call-start-progress', {
+                    stage: 'video-recording-setup',
+                    status: 'started',
+                    timestamp: new Date().toISOString()
+                });
+                const recordingStartTime = Date.now();
+                const recordingRequestedTime = new Date().getTime();
+                try {
+                    this.call.startRecording({
+                        width: 1280,
+                        height: 720,
+                        backgroundColor: '#FF1F2D3D',
+                        layout: {
+                            preset: 'default',
+                        },
+                    });
+                    const recordingSetupDuration = Date.now() - recordingStartTime;
+                    this.emit('call-start-progress', {
+                        stage: 'video-recording-setup',
+                        status: 'completed',
+                        duration: recordingSetupDuration,
+                        timestamp: new Date().toISOString()
+                    });
+                    this.call.on('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,
+                        });
+                    });
+                }
+                catch (error) {
+                    const recordingSetupDuration = Date.now() - recordingStartTime;
+                    this.emit('call-start-progress', {
+                        stage: 'video-recording-setup',
+                        status: 'failed',
+                        duration: recordingSetupDuration,
+                        timestamp: new Date().toISOString(),
+                        metadata: { error: error?.toString() }
+                    });
+                    // 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;
+                this.emit('call-start-progress', {
+                    stage: 'audio-observer-setup',
+                    status: 'failed',
+                    duration: audioObserverDuration,
+                    timestamp: new Date().toISOString(),
+                    metadata: { error: error?.toString() }
+                });
+                // 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 {
+                this.call.updateInputSettings({
+                    audio: {
+                        processor: {
+                            type: 'noise-cancellation',
+                        },
+                    },
+                });
+                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;
+                this.emit('call-start-progress', {
+                    stage: 'audio-processing-setup',
+                    status: 'failed',
+                    duration: audioProcessingDuration,
+                    timestamp: new Date().toISOString(),
+                    metadata: { error: error?.toString() }
+                });
+                // 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;
+            this.emit('call-start-failed', {
+                stage: 'reconnect',
+                totalDuration,
+                error: e?.toString() || 'Unknown error occurred',
+                errorStack: e instanceof Error ? e.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: e,
+                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;
+        }
+    }
 }
 exports.default = Vapi;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vapi-ai/web",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "",
   "main": "dist/vapi.js",
   "types": "dist/vapi.d.ts",
@@ -14,7 +14,8 @@
     "test:example": "npm run pack:local && cd example && npm install && npm run build",
     "pack:local": "./scripts/build-latest.sh",
     "clean-builds": "rm -f vapi-ai-web-*.tgz && echo '🧹 Cleaned up all build tarballs'",
-    "dev:example": "npm run pack:local && cd example && npm install && npm run dev"
+    "dev:example": "npm run pack:local && cd example && npm install && npm run dev",
+    "re-build-local-example": "./scripts/re-build-local-example.sh"
   },
   "repository": {
     "type": "git",

package/vapi.ts

@@ -28,6 +28,10 @@ import {
   safeSetInputDevicesAsync,
 } from './daily-guards';
 
+export interface EndCallMessage {
+  type: 'end-call';
+}
+
 export interface AddMessageMessage {
   type: 'add-message';
   message: ChatCompletionMessageParam;
@@ -51,7 +55,8 @@ export interface SayMessage {
 type VapiClientToServerMessage =
   | AddMessageMessage
   | ControlMessages
-  | SayMessage;
+  | SayMessage
+  | EndCallMessage;
 
 type VapiEventNames =
   | 'call-end'
@@ -111,6 +116,43 @@ type VapiEventListeners = {
   'call-start-failed': (event: CallStartFailedEvent) => void;
 };
 
+type StartCallOptions = {
+  /**
+   * 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 } };
+}
+
 async function startAudioPlayer(
   player: HTMLAudioElement,
   track: MediaStreamTrack,
@@ -246,6 +288,7 @@ export default class Vapi extends VapiEventEmitter {
     squad?: CreateSquadDTO | string,
     workflow?: CreateWorkflowDTO | string,
     workflowOverrides?: WorkflowOverrides,
+    options?: StartCallOptions
   ): Promise<Call | null> {
     const startTime = Date.now();
     
@@ -304,6 +347,7 @@ export default class Vapi extends VapiEventEmitter {
           workflow: typeof workflow === 'string' ? undefined : workflow,
           workflowId: typeof workflow === 'string' ? workflow : undefined,
           workflowOverrides,
+          roomDeleteOnUserLeaveEnabled: options?.roomDeleteOnUserLeaveEnabled,
         })
       ).data;
       
@@ -802,6 +846,12 @@ export default class Vapi extends VapiEventEmitter {
     }, 1000);
   }
 
+  /**
+   * 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> {
     this.started = false;
     if (this.call) {
@@ -811,6 +861,11 @@ export default class Vapi extends VapiEventEmitter {
     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));
   }
@@ -837,6 +892,18 @@ export default class Vapi extends VapiEventEmitter {
     });
   }
 
+  /**
+   * 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],
   ) {
@@ -889,4 +956,413 @@ export default class Vapi extends VapiEventEmitter {
   public stopScreenSharing() {
     this.call?.stopScreenShare();
   }
+
+  /**
+   * 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';
+
+      // 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) {
+          this.call?.stopRecording();
+        }
+        this.cleanup().catch(console.error);
+      });
+
+      this.call.on('error', (error: any) => {
+        this.emit('error', error);
+        if (isVideoRecordingEnabled) {
+          this.call?.stopRecording();
+        }
+      });
+
+      this.call.on('camera-error', (error: any) => {
+        this.emit('camera-error', error);
+      });
+
+      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('track-started', async (e) => {
+        if (!e || !e.participant) {
+          return;
+        }
+        if (e.participant?.local) {
+          return;
+        }
+        if (e.participant?.user_name !== 'Vapi Speaker') {
+          return;
+        }
+        if (e.track.kind === 'video') {
+          this.emit('video', e.track);
+        }
+        if (e.track.kind === 'audio') {
+          await buildAudioPlayer(e.track, e.participant.session_id);
+        }
+        this.call?.sendAppMessage('playable');
+      });
+
+      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;
+        }
+        destroyAudioPlayer(e.participant.session_id);
+      });
+
+      this.call.on('remote-participants-audio-level', (e) => {
+        if (e) this.handleRemoteParticipantsAudioLevel(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 === 'audio-processor-error') {
+          this.call
+            ?.updateInputSettings({
+              audio: {
+                processor: {
+                  type: 'none',
+                },
+              },
+            })
+            .then(() => {
+              safeSetLocalAudio(this.call, true);
+            });
+        }
+      });
+
+      // 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();
+      await this.call.join({
+        url: webCall.webCallUrl,
+        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) {
+        this.emit('call-start-progress', {
+          stage: 'video-recording-setup',
+          status: 'started',
+          timestamp: new Date().toISOString()
+        });
+        
+        const recordingStartTime = Date.now();
+        const recordingRequestedTime = new Date().getTime();
+
+        try {
+          this.call.startRecording({
+            width: 1280,
+            height: 720,
+            backgroundColor: '#FF1F2D3D',
+            layout: {
+              preset: 'default',
+            },
+          });
+
+          const recordingSetupDuration = Date.now() - recordingStartTime;
+          this.emit('call-start-progress', {
+            stage: 'video-recording-setup',
+            status: 'completed',
+            duration: recordingSetupDuration,
+            timestamp: new Date().toISOString()
+          });
+
+          this.call.on('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,
+            });
+          });
+        } catch (error) {
+          const recordingSetupDuration = Date.now() - recordingStartTime;
+          this.emit('call-start-progress', {
+            stage: 'video-recording-setup',
+            status: 'failed',
+            duration: recordingSetupDuration,
+            timestamp: new Date().toISOString(),
+            metadata: { error: error?.toString() }
+          });
+          // 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;
+        this.emit('call-start-progress', {
+          stage: 'audio-observer-setup',
+          status: 'failed',
+          duration: audioObserverDuration,
+          timestamp: new Date().toISOString(),
+          metadata: { error: error?.toString() }
+        });
+        // 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 {
+        this.call.updateInputSettings({
+          audio: {
+            processor: {
+              type: 'noise-cancellation',
+            },
+          },
+        });
+        
+        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;
+        this.emit('call-start-progress', {
+          stage: 'audio-processing-setup',
+          status: 'failed',
+          duration: audioProcessingDuration,
+          timestamp: new Date().toISOString(),
+          metadata: { error: error?.toString() }
+        });
+        // 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;
+      
+      this.emit('call-start-failed', {
+        stage: 'reconnect',
+        totalDuration,
+        error: e?.toString() || 'Unknown error occurred',
+        errorStack: e instanceof Error ? e.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: e,
+        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;
+    }
+  }
 }