@ctchealth/plato-sdk 0.0.20 → 0.0.22

package/src/lib/plato-sdk.js

@@ -21,13 +21,14 @@ const utils_1 = require("./utils");
 const constants_1 = require("./constants");
 class PlatoApiClient {
     config;
-    static ACTIVE_CALL_STORAGE_KEY = 'plato_active_call';
+    // private static readonly ACTIVE_CALL_STORAGE_KEY = 'plato_active_call';
     http;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     eventListeners = {};
     callControllerInstance;
     eventsAttached = false;
-    currentCallId;
+    // private currentCallId?: string;
+    // private receivedAnyTranscript = false;
     // Vapi-native events (events that Vapi SDK supports)
     // Exclude our custom SDK events from this list
     vapiEventNames = [
@@ -49,6 +50,7 @@ class PlatoApiClient {
         'message',
         'volume-level',
         'call-details-ready',
+        'call-ended-reason',
     ];
     constructor(config) {
         this.config = config;
@@ -130,132 +132,125 @@ class PlatoApiClient {
             listeners.forEach(listener => listener(payload));
         }
     }
-    /**
-     * Store active call state in localStorage for recovery purposes.
-     * @private
-     */
-    storeCallState(state) {
-        try {
-            localStorage.setItem(PlatoApiClient.ACTIVE_CALL_STORAGE_KEY, JSON.stringify(state));
-        }
-        catch (error) {
-            console.warn('Failed to store call state:', error);
-        }
-    }
-    /**
-     * Retrieve active call state from localStorage.
-     * Validates the stored data and clears it if invalid.
-     * @private
-     * @returns The stored call state or null if not found or invalid
-     */
-    getStoredCallState() {
-        try {
-            const stored = localStorage.getItem(PlatoApiClient.ACTIVE_CALL_STORAGE_KEY);
-            if (!stored) {
-                return null;
-            }
-            const parsed = JSON.parse(stored);
-            // Validate required fields
-            if (!parsed.callId || !parsed.externalCallId || !parsed.simulationId || !parsed.startedAt) {
-                console.warn('Invalid stored call state, clearing');
-                this.clearCallState();
-                return null;
-            }
-            return parsed;
-        }
-        catch (error) {
-            console.warn('Failed to retrieve call state:', error);
-            return null;
-        }
-    }
-    /**
-     * Clear active call state from localStorage.
-     * @private
-     */
-    clearCallState() {
-        try {
-            localStorage.removeItem(PlatoApiClient.ACTIVE_CALL_STORAGE_KEY);
-        }
-        catch (error) {
-            console.warn('Failed to clear call state:', error);
-        }
-    }
-    /**
-     * Check if a stored call is considered abandoned based on age.
-     * Calls older than 5 minutes are considered abandoned.
-     * @private
-     * @param state The call state to check
-     * @returns true if the call is abandoned, false otherwise
-     */
-    isCallAbandoned(state) {
-        const ABANDONMENT_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
-        const startedAt = new Date(state.startedAt).getTime();
-        const now = Date.now();
-        const age = now - startedAt;
-        return age > ABANDONMENT_THRESHOLD_MS;
-    }
-    /**
-     * Recover and clean up any abandoned calls from previous sessions.
-     *
-     * This method should be called during application initialization,
-     * typically in ngOnInit() or useEffect(). It detects calls that were
-     * active when the page was last refreshed and notifies the backend
-     * to process them if they're older than 5 minutes.
-     *
-     * The backend endpoint is idempotent, so calling this method multiple
-     * times for the same call is safe.
-     *
-     * @returns Promise<boolean> - true if an abandoned call was recovered and processed
-     *
-     * @example
-     * // In Angular component
-     * async ngOnInit(): Promise<void> {
-     *   const recovered = await this.platoClient.recoverAbandonedCall();
-     *   if (recovered) {
-     *     console.log('Recovered abandoned call from previous session');
-     *   }
-     * }
-     *
-     * @example
-     * // In React component
-     * useEffect(() => {
-     *   platoClient.recoverAbandonedCall()
-     *     .then(recovered => {
-     *       if (recovered) {
-     *         console.log('Recovered abandoned call');
-     *       }
-     *     })
-     *     .catch(console.error);
-     * }, []);
-     */
-    async recoverAbandonedCall() {
-        try {
-            const storedState = this.getStoredCallState();
-            if (!storedState) {
-                return false;
-            }
-            if (!this.isCallAbandoned(storedState)) {
-                return false;
-            }
-            console.log('Detected abandoned call, notifying backend:', storedState.callId);
-            try {
-                const response = await this.http.post('/api/v1/postcall/call-ended', {
-                    callId: storedState.callId,
-                });
-                console.log('Backend notified of abandoned call:', response.data);
-            }
-            catch (error) {
-                console.error('Failed to notify backend of abandoned call:', error);
-            }
-            this.clearCallState();
-            return true;
-        }
-        catch (error) {
-            console.error('Error during call recovery:', error);
-            this.clearCallState();
-            return false;
-        }
-    }
+    // /**
+    //  * Store active call state in localStorage for recovery purposes.
+    //  * @private
+    //  */
+    // private storeCallState(state: ActiveCallState): void {
+    //   try {
+    //     localStorage.setItem(PlatoApiClient.ACTIVE_CALL_STORAGE_KEY, JSON.stringify(state));
+    //   } catch (error) {
+    //     console.warn('Failed to store call state:', error);
+    //   }
+    // }
+    // /**
+    //  * Retrieve active call state from localStorage.
+    //  * Validates the stored data and clears it if invalid.
+    //  * @private
+    //  * @returns The stored call state or null if not found or invalid
+    //  */
+    // private getStoredCallState(): ActiveCallState | null {
+    //   try {
+    //     const stored = localStorage.getItem(PlatoApiClient.ACTIVE_CALL_STORAGE_KEY);
+    //     if (!stored) {
+    //       return null;
+    //     }
+    //     const parsed = JSON.parse(stored) as ActiveCallState;
+    //     // Validate required fields
+    //     if (!parsed.callId || !parsed.externalCallId || !parsed.simulationId || !parsed.startedAt) {
+    //       this.clearCallState();
+    //       return null;
+    //     }
+    //     return parsed;
+    //   } catch {
+    //     return null;
+    //   }
+    // }
+    // /**
+    //  * Clear active call state from localStorage.
+    //  * @private
+    //  */
+    // private clearCallState(): void {
+    //   try {
+    //     localStorage.removeItem(PlatoApiClient.ACTIVE_CALL_STORAGE_KEY);
+    //   } catch {
+    //     // ignore
+    //   }
+    // }
+    // /**
+    //  * Check if a stored call is considered abandoned based on age.
+    //  * Calls older than 5 minutes are considered abandoned.
+    //  * @private
+    //  * @param state The call state to check
+    //  * @returns true if the call is abandoned, false otherwise
+    //  */
+    // private isCallAbandoned(state: ActiveCallState): boolean {
+    //   const ABANDONMENT_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+    //   const startedAt = new Date(state.startedAt).getTime();
+    //   const now = Date.now();
+    //   const age = now - startedAt;
+    //   return age > ABANDONMENT_THRESHOLD_MS;
+    // }
+    // /**
+    //  * Recover and clean up any abandoned calls from previous sessions.
+    //  *
+    //  * This method should be called during application initialization,
+    //  * typically in ngOnInit() or useEffect(). It detects calls that were
+    //  * active when the page was last refreshed and notifies the backend
+    //  * to process them if they're older than 5 minutes.
+    //  *
+    //  * The backend endpoint is idempotent, so calling this method multiple
+    //  * times for the same call is safe.
+    //  *
+    //  * @returns Promise<boolean> - true if an abandoned call was recovered and processed
+    //  *
+    //  * @example
+    //  * // In Angular component
+    //  * async ngOnInit(): Promise<void> {
+    //  *   const recovered = await this.platoClient.recoverAbandonedCall();
+    //  *   if (recovered) {
+    //  *     console.log('Recovered abandoned call from previous session');
+    //  *   }
+    //  * }
+    //  *
+    //  * @example
+    //  * // In React component
+    //  * useEffect(() => {
+    //  *   platoClient.recoverAbandonedCall()
+    //  *     .then(recovered => {
+    //  *       if (recovered) {
+    //  *         console.log('Recovered abandoned call');
+    //  *       }
+    //  *     })
+    //  *     .catch(console.error);
+    //  * }, []);
+    //  */
+    // async recoverAbandonedCall(): Promise<boolean> {
+    //   try {
+    //     const storedState = this.getStoredCallState();
+    //     if (!storedState) {
+    //       return false;
+    //     }
+    //     if (!this.isCallAbandoned(storedState)) {
+    //       return false;
+    //     }
+    //     console.log('Detected abandoned call, notifying backend:', storedState.callId);
+    //     try {
+    //       const response = await this.http.post('/api/v1/postcall/call-ended', {
+    //         callId: storedState.callId,
+    //       });
+    //       console.log('Backend notified of abandoned call:', response.data);
+    //     } catch (error) {
+    //       console.error('Failed to notify backend of abandoned call:', error);
+    //     }
+    //     this.clearCallState();
+    //     return true;
+    //   } catch (error) {
+    //     console.error('Error during call recovery:', error);
+    //     this.clearCallState();
+    //     return false;
+    //   }
+    // }
     async createSimulation(createSimulationParams) {
         try {
             const res = await this.http.post('/api/v1/simulation', {
@@ -267,9 +262,9 @@ class PlatoApiClient {
             };
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error creating simulation:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error creating simulation:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -283,9 +278,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting user simulations:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting user simulations:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -295,9 +290,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting simulation details:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting simulation details:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -311,9 +306,9 @@ class PlatoApiClient {
             await this.http.delete(`/api/v1/simulation/${simulationId}`);
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error deleting simulation:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error deleting simulation:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -323,9 +318,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting call details:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting call details:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -337,9 +332,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting call recordings:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting call recordings:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -349,9 +344,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting call recording:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting call recording:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -371,39 +366,218 @@ class PlatoApiClient {
         });
         this.eventsAttached = false;
     }
+    // async startCall(simulationId: string) {
+    //   // Check for any previous call state before starting new call
+    //   // If found, notify backend to ensure it gets processed
+    //   const storedState = this.getStoredCallState();
+    //   if (storedState) {
+    //     try {
+    //       await this.http.post('/api/v1/postcall/call-ended', {
+    //         callId: storedState.callId,
+    //       });
+    //     } catch {
+    //       // ignore
+    //     }
+    //   }
+    //
+    //   // Now clear the state before starting new call
+    //   this.clearCallState();
+    //
+    //   this.callControllerInstance = new Vapi(
+    //     this.config.publicKey,
+    //     'https://db41aykk1gw9e.cloudfront.net' // base url
+    //   );
+    //   if (!this.eventsAttached) {
+    //     this.attachEvents();
+    //   }
+    //
+    //   this.receivedAnyTranscript = false;
+    //   this.callControllerInstance.on(
+    //     'message',
+    //     (msg: { transcript?: string; type?: string; status?: string; endedReason?: string }) => {
+    //       if (msg.transcript && msg.transcript.trim().length > 0) {
+    //         this.receivedAnyTranscript = true;
+    //       }
+    //       if (msg.type === 'status-update' && msg.status === 'ended' && msg.endedReason) {
+    //         const reason = msg.endedReason;
+    //         const isInactivity = /silence|inactivity/i.test(reason);
+    //         this.emit('call-ended-reason', { reason, isInactivity });
+    //       }
+    //     }
+    //   );
+    //
+    //   // Internal call-end listener
+    //   this.callControllerInstance.on('call-end', () => {
+    //     this.onCallEnded().catch(() => {
+    //       // ignore
+    //     });
+    //   });
+    //
+    //   const { data } = await this.http.get(`/api/v1/simulation/${simulationId}`);
+    //   const assistantId = data as string;
+    //
+    //   let capturedVapiError: unknown;
+    //   const vapiErrorCapture = (error: unknown) => {
+    //     capturedVapiError = error;
+    //   };
+    //   this.callControllerInstance.on('error', vapiErrorCapture);
+    //
+    //   let call: Call | null;
+    //   try {
+    //     call = await this.callControllerInstance.start(assistantId);
+    //   } catch (e) {
+    //     this.callControllerInstance.off('error', vapiErrorCapture);
+    //     this.callControllerInstance?.stop();
+    //     this.removeAllEventListeners();
+    //     this.clearCallState();
+    //     throw e;
+    //   }
+    //
+    //   this.callControllerInstance.off('error', vapiErrorCapture);
+    //
+    //   if (!call || !call.assistantId) {
+    //     this.callControllerInstance?.stop();
+    //     this.removeAllEventListeners();
+    //     this.clearCallState();
+    //     if (isCallConcurrencyError(capturedVapiError)) {
+    //       throw new CallConcurrencyLimitError();
+    //     }
+    //     throw new Error('Cannot start a call, please try again later');
+    //   }
+    //   try {
+    //     const apiCall = await this.createCall({
+    //       callId: call.id,
+    //       assistantId: call.assistantId,
+    //     });
+    //
+    //     this.currentCallId = apiCall._id;
+    //
+    //     this.storeCallState({
+    //       callId: apiCall._id,
+    //       externalCallId: call.id,
+    //       simulationId: simulationId,
+    //       startedAt: new Date().toISOString(),
+    //       version: 1,
+    //     });
+    //
+    //     return {
+    //       stopCall: () => {
+    //         this.callControllerInstance?.stop();
+    //       },
+    //       callId: apiCall._id,
+    //       on: <K extends CallEventNames>(event: K, listener: CallEventListener<K>) =>
+    //         this.on(event, listener),
+    //       off: <K extends CallEventNames>(event: K, listener: CallEventListener<K>) =>
+    //         this.off(event, listener),
+    //     };
+    //   } catch (e) {
+    //     this.callControllerInstance?.stop();
+    //     this.removeAllEventListeners();
+    //     this.clearCallState();
+    //     throw e;
+    //   }
+    // }
+    /**
+     * Starts a call for the given simulation.
+     * Polls the backend after call-end until the call is finalized, then emits 'call-details-ready'.
+     */
     async startCall(simulationId) {
-        // Check for any previous call state before starting new call
-        // If found, notify backend to ensure it gets processed
-        const storedState = this.getStoredCallState();
-        if (storedState) {
-            console.log('Found previous call state, notifying backend before starting new call:', storedState.callId);
-            try {
-                await this.http.post('/api/v1/postcall/call-ended', {
-                    callId: storedState.callId,
-                });
-                console.log('Backend notified of previous call');
-            }
-            catch (error) {
-                console.error('Failed to notify backend of previous call:', error);
-            }
-        }
-        // Now clear the state before starting new call
-        this.clearCallState();
-        this.callControllerInstance = new web_1.default(this.config.publicKey, 'https://db41aykk1gw9e.cloudfront.net' // base url
-        );
+        this.callControllerInstance = new web_1.default(this.config.publicKey, 'https://db41aykk1gw9e.cloudfront.net');
         if (!this.eventsAttached) {
             this.attachEvents();
         }
-        // Internal call-end listener
+        this.callControllerInstance.on('message', (msg) => {
+            if (msg.type === 'status-update' && msg.status === 'ended' && msg.endedReason) {
+                const reason = msg.endedReason;
+                const isInactivity = /silence|inactivity/i.test(reason);
+                this.emit('call-ended-reason', { reason, isInactivity });
+            }
+        });
+        let callId;
+        let stopPolling;
         this.callControllerInstance.on('call-end', () => {
-            this.onCallEnded().catch(error => {
-                console.error('Error in onCallEnded: ', error);
-            });
+            if (!callId)
+                return;
+            const callAge = Date.now() - callStartedAt;
+            // console.log(`[PlatoSDK] Call ended. Age: ${callAge}ms (${(callAge / 1000).toFixed(2)}s)`);
+            if (callAge < 20000) {
+                // Call ended within 20s — return whatever is in the DB without requiring a transcript
+                const fetchAndEmit = async () => {
+                    try {
+                        // console.log('[PlatoSDK] Early end (<20s) — fetching call details immediately (no transcript check)');
+                        const { data } = await this.http.get(`/api/v1/simulation/call/${callId}`);
+                        this.emit('call-details-ready', data);
+                    }
+                    catch (e) {
+                        this.emit('error', e instanceof Error ? e : new Error('Failed to fetch call details'));
+                    }
+                    finally {
+                        this.removeAllEventListeners();
+                    }
+                };
+                void fetchAndEmit();
+                return;
+            }
+            let stopped = false;
+            let nextPollTimer;
+            const poll = async () => {
+                if (stopped)
+                    return;
+                try {
+                    // console.log('[PlatoSDK] Polling for call details (waiting for transcript)...');
+                    const { data } = await this.http.get(`/api/v1/simulation/call/${callId}`);
+                    if (data.transcript) {
+                        stopped = true;
+                        clearTimeout(globalTimer);
+                        // console.log('[PlatoSDK] Transcript ready — emitting call-details-ready');
+                        this.emit('call-details-ready', data);
+                        this.removeAllEventListeners();
+                        return;
+                    }
+                }
+                catch {
+                    // ignore transient errors, keep polling
+                }
+                nextPollTimer = setTimeout(() => void poll(), 3000);
+            };
+            nextPollTimer = setTimeout(() => void poll(), 3000);
+            const globalTimer = setTimeout(() => {
+                stopped = true;
+                clearTimeout(nextPollTimer);
+                this.removeAllEventListeners();
+            }, 60000);
+            stopPolling = () => {
+                stopped = true;
+                clearTimeout(nextPollTimer);
+                clearTimeout(globalTimer);
+            };
         });
         const { data } = await this.http.get(`/api/v1/simulation/${simulationId}`);
         const assistantId = data;
-        const call = await this.callControllerInstance.start(assistantId);
+        let capturedVapiError;
+        const vapiErrorCapture = (error) => {
+            capturedVapiError = error;
+        };
+        this.callControllerInstance.on('error', vapiErrorCapture);
+        const callStartedAt = Date.now();
+        // console.log('[PlatoSDK] Call start initiated at:', new Date(callStartedAt).toISOString());
+        let call;
+        try {
+            call = await this.callControllerInstance.start(assistantId);
+        }
+        catch (e) {
+            this.callControllerInstance.off('error', vapiErrorCapture);
+            this.callControllerInstance.stop();
+            this.removeAllEventListeners();
+            throw e;
+        }
+        this.callControllerInstance.off('error', vapiErrorCapture);
         if (!call || !call.assistantId) {
+            this.callControllerInstance.stop();
+            this.removeAllEventListeners();
+            if ((0, utils_1.isCallConcurrencyError)(capturedVapiError)) {
+                throw new utils_1.CallConcurrencyLimitError();
+            }
             throw new Error('Cannot start a call, please try again later');
         }
         try {
@@ -411,82 +585,62 @@ class PlatoApiClient {
                 callId: call.id,
                 assistantId: call.assistantId,
             });
-            // Store the callId for use in onCallEnded
-            this.currentCallId = apiCall._id;
-            // Store call state in localStorage for recovery
-            this.storeCallState({
-                callId: apiCall._id,
-                externalCallId: call.id,
-                simulationId: simulationId,
-                startedAt: new Date().toISOString(),
-                version: 1,
-            });
-            // Return stopCall, callId, and event subscription methods with strict typing
+            callId = apiCall._id;
             return {
                 stopCall: () => {
                     this.callControllerInstance?.stop();
-                    this.removeAllEventListeners();
-                    this.clearCallState();
+                    stopPolling?.();
                 },
                 callId: apiCall._id,
-                /**
-                 * Subscribe to call events for this call with strict typing.
-                 * @param event Event name
-                 * @param listener Listener function
-                 */
                 on: (event, listener) => this.on(event, listener),
-                /**
-                 * Unsubscribe from call events for this call with strict typing.
-                 * @param event Event name
-                 * @param listener Listener function
-                 */
                 off: (event, listener) => this.off(event, listener),
             };
         }
         catch (e) {
             this.callControllerInstance?.stop();
             this.removeAllEventListeners();
-            this.clearCallState();
             throw e;
         }
     }
-    async onCallEnded() {
-        let callIdForRetry;
-        try {
-            if (!this.currentCallId) {
-                return;
-            }
-            callIdForRetry = this.currentCallId;
-            // First attempt
-            let response = await this.http.post('/api/v1/postcall/call-ended', {
-                callId: callIdForRetry,
-            });
-            // If status is "processing", retry once immediately
-            if (response.data?.status === 'processing') {
-                response = await this.http.post('/api/v1/postcall/call-ended', {
-                    callId: callIdForRetry,
-                });
-            }
-            // After onCallEnded completes successfully, fetch and emit call details
-            try {
-                const callDetails = await this.getCallDetails(callIdForRetry);
-                this.emit('call-details-ready', callDetails);
-            }
-            catch (error) {
-                console.error('Error fetching call details after call ended:', error);
-                // Don't throw - we don't want to break the onCallEnded flow
-            }
-        }
-        catch {
-            // Silently handle errors in post-call processing
-        }
-        finally {
-            // Clean up the callId after processing (success or failure)
-            this.currentCallId = undefined;
-            // Clear stored call state after normal call end
-            this.clearCallState();
-        }
-    }
+    // private async onCallEnded(): Promise<void> {
+    //   let callIdForRetry: string | undefined;
+    //   try {
+    //     if (!this.currentCallId) {
+    //       return;
+    //     }
+    //
+    //     if (!this.receivedAnyTranscript) {
+    //       return;
+    //     }
+    //
+    //     callIdForRetry = this.currentCallId;
+    //
+    //     // First attempt
+    //     let response = await this.http.post('/api/v1/postcall/call-ended', {
+    //       callId: callIdForRetry,
+    //     });
+    //
+    //     // If status is "processing", retry once immediately
+    //     if (response.data?.status === 'processing') {
+    //       response = await this.http.post('/api/v1/postcall/call-ended', {
+    //         callId: callIdForRetry,
+    //       });
+    //     }
+    //
+    //     try {
+    //       const callDetails = await this.getCallDetails(callIdForRetry);
+    //       this.emit('call-details-ready', callDetails);
+    //     } catch {
+    //       // ignore
+    //     }
+    //   } catch {
+    //     // ignore
+    //   } finally {
+    //     this.currentCallId = undefined;
+    //     this.clearCallState();
+    //     this.removeAllEventListeners();
+    //   }
+    // }
     async createCall(payload) {
         const response = await this.http.post('/api/v1/simulation/call', {
             ...payload,
@@ -512,10 +666,16 @@ class PlatoApiClient {
             if (/[^a-zA-Z0-9._ -]/.test(filename)) {
                 throw new Error('Filename contains invalid characters. Only English letters, numbers, dots, hyphens, and underscores are allowed.');
             }
-            const { presignedPost, pdfId } = (await this.http.post('/api/v1/pdfSlides/request-upload', {
+            const { presignedPost, pdfId, alreadyExists } = (await this.http.post('/api/v1/pdfSlides/request-upload', {
                 contentHash,
                 filename,
             })).data;
+            if (alreadyExists) {
+                throw new utils_1.PdfAlreadyExistsError(pdfId);
+            }
+            if (!presignedPost) {
+                throw new Error('[uploadPdfSlides] No presigned post URL returned from server.');
+            }
             const formData = new FormData();
             Object.entries(presignedPost.fields).forEach(([key, value]) => {
                 formData.append(key, value);
@@ -533,8 +693,8 @@ class PlatoApiClient {
                 try {
                     await this.deleteSlideAnalysis(pdfId);
                 }
-                catch (deleteError) {
-                    console.error('Failed to clean up PDF record after upload failure:', deleteError);
+                catch {
+                    // console.error('Failed to clean up PDF record after upload failure:', deleteError);
                 }
                 throw uploadError;
             }
@@ -548,12 +708,14 @@ class PlatoApiClient {
             return pdfId;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error uploading PDF slides:', e.response?.data?.message || e.message);
-            }
-            else {
-                console.error('Error uploading PDF slides:', e instanceof Error ? e.message : 'Unknown error');
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error uploading PDF slides:', e.response?.data?.message || e.message);
+            // } else {
+            //   console.error(
+            //     'Error uploading PDF slides:',
+            //     e instanceof Error ? e.message : 'Unknown error'
+            //   );
+            // }
             throw e;
         }
     }
@@ -563,23 +725,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting recommendations:', e.response?.data.message);
-            }
-            throw e;
-        }
-    }
-    async getSlidesAnalysis(queryParams) {
-        try {
-            const res = await this.http.get('/api/v1/pdfSlides', {
-                params: queryParams,
-            });
-            return res.data;
-        }
-        catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting PDF slides analysis:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting recommendations:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -589,9 +737,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting PDF slide analysis by ID:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting PDF slide analysis by ID:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -600,9 +748,9 @@ class PlatoApiClient {
             await this.http.delete(`/api/v1/pdfSlides/${id}`);
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error deleting PDF slide analysis:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error deleting PDF slide analysis:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -612,9 +760,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error checking PDF status:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error checking PDF status:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -624,9 +772,9 @@ class PlatoApiClient {
             return res.data;
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error getting assistant images:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting assistant images:', e.response?.data.message);
+            // }
             throw e;
         }
     }
@@ -642,9 +790,9 @@ class PlatoApiClient {
             await this.http.delete(`/api/v1/simulation/call/${callId}`);
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                console.error('Error deleting call:', e.response?.data.message);
-            }
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error deleting call:', e.response?.data.message);
+            // }
             throw e;
         }
     }