@ctchealth/plato-sdk 0.0.19 → 0.0.21

package/src/lib/plato-sdk.js

@@ -0,0 +1,809 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatoApiClient = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Copyright (c) 2025 ctcHealth. All rights reserved.
+ *
+ * This file is part of the ctcHealth Plato Platform, a proprietary software system developed by ctcHealth.
+ *
+ * This source code and all related materials are confidential and proprietary to ctcHealth.
+ * Unauthorized access, use, copying, modification, distribution, or disclosure is strictly prohibited
+ * and may result in disciplinary action and civil and/or criminal penalties.
+ *
+ * This software is intended solely for authorized use within ctcHealth and its designated partners.
+ *
+ * For internal use only.
+ */
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const web_1 = tslib_1.__importDefault(require("@vapi-ai/web"));
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+class PlatoApiClient {
+    config;
+    // 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;
+    // private currentCallId?: string;
+    // private receivedAnyTranscript = false;
+    // Vapi-native events (events that Vapi SDK supports)
+    // Exclude our custom SDK events from this list
+    vapiEventNames = [
+        'call-start',
+        'call-end',
+        'speech-start',
+        'speech-end',
+        'error',
+        'message',
+        'volume-level',
+    ];
+    // All event names including SDK-specific events
+    eventNames = [
+        'call-start',
+        'call-end',
+        'speech-start',
+        'speech-end',
+        'error',
+        'message',
+        'volume-level',
+        'call-details-ready',
+        'call-ended-reason',
+    ];
+    constructor(config) {
+        this.config = config;
+        if (!config.baseUrl) {
+            throw new Error('baseUrl is required');
+        }
+        if (config.baseUrl.endsWith('/')) {
+            config.baseUrl = config.baseUrl.slice(0, -1);
+        }
+        this.http = axios_1.default.create({
+            baseURL: config.baseUrl,
+            headers: {
+                'x-client-token': config.jwtToken,
+            },
+        });
+    }
+    /**
+     * Update the JWT token for all subsequent requests.
+     * Useful when the token is refreshed or when switching user context.
+     */
+    setJwtToken(jwtToken) {
+        this.http.defaults.headers.common['x-client-token'] = jwtToken;
+    }
+    /**
+     * Remove the JWT token from subsequent requests.
+     */
+    clearJwtToken() {
+        delete this.http.defaults.headers.common['x-client-token'];
+    }
+    /**
+     * Register a listener for a call event with strict typing.
+     * @param event Event name
+     * @param listener Listener function
+     */
+    on(event, listener) {
+        if (!this.eventListeners[event]) {
+            this.eventListeners[event] = [];
+        }
+        const listeners = this.eventListeners[event];
+        if (listeners) {
+            listeners.push(listener);
+        }
+        if (this.callControllerInstance && !this.eventsAttached) {
+            this.attachEvents();
+        }
+    }
+    /**
+     * Remove a listener for a call event with strict typing.
+     * @param event Event name
+     * @param listener Listener function
+     */
+    off(event, listener) {
+        const listeners = this.eventListeners[event];
+        if (!listeners)
+            return;
+        this.eventListeners[event] = listeners.filter(l => l !== listener);
+    }
+    /**
+     * Internal: Attach event listeners and propagate to registered listeners.
+     */
+    attachEvents() {
+        if (this.eventsAttached || !this.callControllerInstance)
+            return;
+        this.eventsAttached = true;
+        const vapi = this.callControllerInstance;
+        // Only attach Vapi-native events to the Vapi instance
+        this.vapiEventNames.forEach(event => {
+            vapi.on(event, (payload) => {
+                (this.eventListeners[event] || []).forEach(listener => listener(payload));
+            });
+        });
+    }
+    /**
+     * Internal: Emit SDK-specific events that are not part of Vapi.
+     */
+    emit(event, payload) {
+        const listeners = this.eventListeners[event];
+        if (listeners) {
+            listeners.forEach(listener => listener(payload));
+        }
+    }
+    // /**
+    //  * 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', {
+                ...createSimulationParams,
+            });
+            return {
+                simulationId: res.data.simulationId,
+                phase: res.data.phase,
+            };
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error creating simulation:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async checkSimulationStatus(simulationId) {
+        const res = await this.http.get(`/api/v1/simulation/status/${simulationId}`);
+        return res.data;
+    }
+    async getUserSimulations() {
+        try {
+            const res = await this.http.get('/api/v1/simulation/user/simulations');
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting user simulations:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async getSimulationDetails(simulationId) {
+        try {
+            const res = await this.http.get(`/api/v1/simulation/details/${simulationId}`);
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting simulation details:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    /**
+     * Deletes a simulation (assistant) from the server and Vapi.
+     * @param simulationId - MongoDB ObjectId of the simulation
+     * @throws 404 if simulation not found
+     */
+    async deleteSimulation(simulationId) {
+        try {
+            await this.http.delete(`/api/v1/simulation/${simulationId}`);
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error deleting simulation:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async getCallDetails(callId) {
+        try {
+            const res = await this.http.get(`/api/v1/simulation/call/${callId}`);
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting call details:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async getCallRecordings(queryParams) {
+        try {
+            const res = await this.http.get(`/api/v1/simulation/call/recordings`, {
+                params: queryParams,
+            });
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting call recordings:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async getCallRecording(callId) {
+        try {
+            const res = await this.http.get(`/api/v1/simulation/call/recordings/${callId}`);
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting call recording:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    /**
+     * Remove all listeners for all call events.
+     */
+    removeAllEventListeners() {
+        if (!this.callControllerInstance)
+            return;
+        this.eventNames.forEach(event => {
+            (this.eventListeners[event] || []).forEach(listener => {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-expect-error
+                this.callControllerInstance?.off(event, listener);
+            });
+            this.eventListeners[event] = [];
+        });
+        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) {
+        this.callControllerInstance = new web_1.default(this.config.publicKey, 'https://db41aykk1gw9e.cloudfront.net');
+        if (!this.eventsAttached) {
+            this.attachEvents();
+        }
+        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', () => {
+            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;
+        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 {
+            const apiCall = await this.createCall({
+                callId: call.id,
+                assistantId: call.assistantId,
+            });
+            callId = apiCall._id;
+            return {
+                stopCall: () => {
+                    this.callControllerInstance?.stop();
+                    stopPolling?.();
+                },
+                callId: apiCall._id,
+                on: (event, listener) => this.on(event, listener),
+                off: (event, listener) => this.off(event, listener),
+            };
+        }
+        catch (e) {
+            this.callControllerInstance?.stop();
+            this.removeAllEventListeners();
+            throw e;
+        }
+    }
+    // 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,
+        });
+        return response.data;
+    }
+    async uploadPdfSlides(file) {
+        try {
+            const checkResult = (0, utils_1.checkFile)(file, constants_1.MAX_PDF_FILE_SIZE, constants_1.ALLOWED_PDF_MIME_TYPES);
+            if (checkResult !== true) {
+                throw new Error(checkResult);
+            }
+            // Check PDF page count before proceeding
+            const pageCount = await (0, utils_1.getPdfPageCount)(file);
+            if (pageCount > constants_1.MAX_PDF_PAGES) {
+                throw new Error(`PDF has ${pageCount} pages, which exceeds the maximum allowed page count of ${constants_1.MAX_PDF_PAGES} pages.`);
+            }
+            const contentHash = await (0, utils_1.calculateHash)(file);
+            const filename = file instanceof File ? file.name : file.filename;
+            if (!filename) {
+                throw new Error('Invalid input: could not extract filename from the provided file or blob.');
+            }
+            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', {
+                contentHash,
+                filename,
+            })).data;
+            const formData = new FormData();
+            Object.entries(presignedPost.fields).forEach(([key, value]) => {
+                formData.append(key, value);
+            });
+            formData.append('file', file);
+            try {
+                await axios_1.default.post(presignedPost.url, formData, {
+                    headers: {
+                        'Content-Type': 'multipart/form-data',
+                    },
+                });
+            }
+            catch (uploadError) {
+                // S3 upload failed - clean up the MongoDB record created during request-upload
+                try {
+                    await this.deleteSlideAnalysis(pdfId);
+                }
+                catch {
+                    // console.error('Failed to clean up PDF record after upload failure:', deleteError);
+                }
+                throw uploadError;
+            }
+            /*
+            // replace const { presignedPost, pdfId } with const { presignedPost, objectKey, pdfId }
+            // Uncomment this block if you are testing locally without AWS EventBridge
+            await this.http.post('/api/v1/pdfSlides/test-event-bridge', {
+              s3Name: objectKey,
+            });
+            */
+            return pdfId;
+        }
+        catch (e) {
+            // 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;
+        }
+    }
+    async getRecommendations() {
+        try {
+            const res = await this.http.get('/api/v1/recommendations');
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.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.isAxiosError(e)) {
+            //   console.error('Error getting PDF slides analysis:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async getSlideAnalysis(id) {
+        try {
+            const res = await this.http.get(`/api/v1/pdfSlides/${id}`);
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting PDF slide analysis by ID:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async deleteSlideAnalysis(id) {
+        try {
+            await this.http.delete(`/api/v1/pdfSlides/${id}`);
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error deleting PDF slide analysis:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async checkPdfStatus(id) {
+        try {
+            const res = await this.http.get(`/api/v1/pdfSlides/status/${id}`);
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error checking PDF status:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    async getAssistantImages() {
+        try {
+            const res = await this.http.get('/api/v1/assistant-images');
+            return res.data;
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error getting assistant images:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+    /**
+     * Deletes a call and all associated data (messages, recommendations, recording).
+     * Only the owner of the call can delete it.
+     * @param callId - MongoDB ObjectId of the call
+     * @throws 404 if call not found
+     * @throws 403 if the caller is not the call owner
+     */
+    async deleteCall(callId) {
+        try {
+            await this.http.delete(`/api/v1/simulation/call/${callId}`);
+        }
+        catch (e) {
+            // if (axios.isAxiosError(e)) {
+            //   console.error('Error deleting call:', e.response?.data.message);
+            // }
+            throw e;
+        }
+    }
+}
+exports.PlatoApiClient = PlatoApiClient;
+//# sourceMappingURL=plato-sdk.js.map