@eka-care/medassist-core 1.0.69 → 1.0.71

package/dist/esm/media/file/File.js

@@ -1,159 +0,0 @@
-/**
- * Class to store file states
- * Helpers: Zipping, uploading to presigned url, etc.
- */
-import { FileError, normalizeError } from "../../internal/Error/Error";
-export const MAX_FILE_SIZE = 3 * 1024 * 1024; // 3MB
-export class Filemanager {
-    pendingFiles = [];
-    pendingMessage = "";
-    pendingFormats = [];
-    /**
-     * Set the files for upload
-     */
-    setFilesForUpload(files, message) {
-        if (this.pendingFiles.length > 0) {
-            this.clearPendingFilesState();
-        }
-        const validFiles = files.filter((file) => this.validateFile(file));
-        if (validFiles.length === 0) {
-            throw new FileError("File not supported", {
-                context: { stage: "setFilesForUpload" },
-            });
-        }
-        this.pendingFiles = validFiles;
-        if (message && message.trim()) {
-            this.pendingMessage = message;
-        }
-        this.pendingFormats = validFiles.map(file => file.type);
-    }
-    /**
-     * Get the pending file state
-     */
-    getPendingFileState() {
-        return {
-            files: this.pendingFiles,
-            message: this.pendingMessage || "",
-            formats: this.pendingFormats || [],
-        };
-    }
-    /**
-     * Upload files to presigned URLs
-     */
-    async uploadFilesToPresignedUrl(presignedUrls) {
-        let successIds = [];
-        // Filter out invalid URLs
-        const validUrls = presignedUrls.filter((url) => url.url && url.url.trim());
-        try {
-            if (validUrls.length === 0) {
-                throw new FileError("No valid presigned URLs provided", {
-                    context: { stage: "uploadFilesToPresignedUrl" },
-                });
-            }
-            if (!this.pendingFiles.length) {
-                throw new FileError("No files to upload", {
-                    context: { stage: "uploadFilesToPresignedUrl" },
-                });
-            }
-            for (let i = 0; i < validUrls.length; i++) {
-                const url = validUrls[i].url;
-                const response = await fetch(url, {
-                    method: "PUT",
-                    body: this.pendingFiles[i],
-                    headers: {
-                        "Content-Type": this.pendingFiles[i].type,
-                        "x-ms-blob-type": "BlockBlob",
-                    },
-                });
-                if (!response.ok) {
-                    throw new FileError(`Failed to upload ${this.pendingFiles[i].name} to URL ${i + 1}: ${response.status} ${response.statusText}`, {
-                        context: { stage: "uploadFilesToPresignedUrl" },
-                    });
-                }
-                successIds.push(validUrls[i].id);
-            }
-            // Call sendFileUploadComplete only once with the first presigned URL
-            // this.sendFileUploadComplete(validUrls[0]);
-            return successIds;
-        }
-        catch (error) {
-            if (successIds.length > 0) {
-                // this.sendFileUploadComplete(validUrls[0]);
-                return successIds;
-            }
-            throw normalizeError(error, FileError, "Failed to upload files to presigned URL", { context: { stage: "uploadFilesToPresignedUrl" } });
-        }
-    }
-    // /**
-    //  * Zips multiple files into a single zip file
-    //  * @param files Array of files to zip
-    //  * @param zipFileName Name for the zip file (without extension)
-    //  * @returns Promise<Blob> - The zipped file as a blob
-    //  */
-    // public async zipFiles(): Promise<Blob> {
-    //   const zip = new JSZip();
-    //   // Add each file to the zip
-    //   this.pendingFiles.forEach((file) => {
-    //     zip.file(file.name, file);
-    //   });
-    //   // Generate the zip file as a blob
-    //   const zipBlob = await zip.generateAsync({ type: "blob" });
-    //   return zipBlob;
-    // }
-    /**
-     * Creates a File object from a blob with a specific name
-     * @param blob The blob to convert
-     * @param fileName The name for the file
-     * @returns File object
-     */
-    blobToFile(blob, fileName) {
-        return new File([blob], fileName, { type: blob.type });
-    }
-    // /**
-    //  * Checks if multiple files should be zipped
-    //  * @param files Array of files
-    //  * @returns boolean - true if files should be zipped
-    //  */
-    // public shouldZipFiles(): boolean {
-    //   return this.pendingFiles.length > 1;
-    // }
-    // /**
-    //  * Gets the appropriate file name for upload (either zip or single file)
-    //  * @param files Array of files
-    //  * @returns string - the file name to use for upload
-    //  */
-    // public getUploadFileName(): string {
-    //   if (this.shouldZipFiles()) {
-    //     return `uploaded_files_${Date.now()}.zip`;
-    //   }
-    //   return this.pendingFiles[0]?.name || "file";
-    // }
-    /**
-     * Validate file types
-     * @param file The file to validate
-     * @returns boolean - true if file type is supported
-     */
-    validateFile(file) {
-        const validFormats = [
-            "application/pdf",
-            "image/jpeg",
-            "image/png",
-            "image/jpg",
-            // "image/tiff",
-            // "text/plain",
-            // "text/markdown",
-            // "image/heif",
-            // "image/heic",
-            // "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        ];
-        return validFormats.includes(file.type) && file.size < MAX_FILE_SIZE;
-    }
-    /**
-     * Clears the pending files
-     */
-    clearPendingFilesState() {
-        this.pendingFiles = [];
-        this.pendingMessage = "";
-        this.pendingFormats = [];
-    }
-}

package/dist/esm/messages/MessageManager.js

@@ -1,476 +0,0 @@
-import { SOCKET_CONTENT_TYPES, SOCKET_EVENTS, } from "../events/Events";
-import { Filemanager } from "../media/file/File";
-import { SYNAPSE_REALTIME_ERROR_CODES, SYNAPSE_REALTIME_EVENTS, SYNAPSE_REALTIME_RESERVED_EVENTS, } from "./types";
-import { AudioManager } from "../media/audio/Audio";
-import { ConnectionError, FileError, MessageError, RecordingError, normalizeError, } from "../internal/Error/Error";
-export class MessageManager {
-    connection = null;
-    callbacks = null;
-    fileManager = null;
-    audioManager = null;
-    outgoingBuffer = null;
-    constructor(callbacks) {
-        this.callbacks = callbacks || null;
-    }
-    setConnection(connection) {
-        this.connection = connection;
-    }
-    /**
-     * Handle file upload process
-     */
-    handleFileUploadProcess({ files, message, urls, tool_declined, tool_result }) {
-        if (!this.fileManager) {
-            this.fileManager = new Filemanager();
-        }
-        let fileUploadMessage;
-        if (files && files.length > 0) {
-            //stage 1. of file upload process
-            //--store files temproary in memory
-            this.fileManager.setFilesForUpload(files, message);
-            fileUploadMessage = {
-                ev: SOCKET_EVENTS.CHAT,
-                ct: SOCKET_CONTENT_TYPES.FILE,
-                _id: Date.now().toString(),
-                ts: Date.now(),
-                data: {
-                    extensions: this.fileManager.getPendingFileState().formats,
-                    ...(tool_declined && { tool_declined }),
-                    ...(tool_result && { tool_result })
-                },
-            };
-        }
-        else if (urls && urls.length > 0) {
-            //--stage 3. of file upload process
-            //--only requirement is url
-            //--send file upload acknowledgement to client
-            const text = this.fileManager.getPendingFileState().message;
-            fileUploadMessage = {
-                ev: SOCKET_EVENTS.CHAT,
-                ct: SOCKET_CONTENT_TYPES.FILE,
-                _id: Date.now().toString(),
-                ts: Date.now(),
-                data: {
-                    urls: urls,
-                    ...(text && { text }),
-                    ...(tool_declined && { tool_declined }),
-                    ...(tool_result && { tool_result })
-                },
-            };
-            this.fileManager?.clearPendingFilesState();
-        }
-        return fileUploadMessage;
-    }
-    /**
-     * send chat message through socket
-     */
-    sendSocketMessage({ message, files, audio, urls, tool_declined, tool_id, tool_result, initial_prompts }) {
-        if (!this.connection?.isConnected()) {
-            this.outgoingBuffer = {
-                ...(message !== undefined && { message }),
-                ...(files && { files }),
-                ...(audio && { audio }),
-                ...(urls && { urls }),
-                ...(tool_declined && { tool_declined }),
-                ...(tool_id && { tool_id }),
-                ...(tool_result && { tool_result }),
-                ...(initial_prompts && { initial_prompts }),
-            };
-            return;
-        }
-        const connection = this.connection;
-        let outMessage;
-        if ((files && files.length > 0) || (urls && urls.length > 0)) {
-            if (files && files.length > 3) {
-                const error = new MessageError("Maximum 3 files are allowed to be sent at a time", {
-                    context: { stage: "sendSocketChatMessage" },
-                });
-                this.emitError(error);
-                throw error;
-            }
-            outMessage = this.handleFileUploadProcess({
-                files,
-                message,
-                urls,
-                tool_declined,
-                tool_result
-            });
-        }
-        else if (message) {
-            outMessage = {
-                ev: SOCKET_EVENTS.CHAT,
-                ct: SOCKET_CONTENT_TYPES.TEXT,
-                _id: Date.now().toString(),
-                ts: Date.now(),
-                data: {
-                    text: message,
-                    ...(tool_declined && { tool_declined }),
-                    ...(tool_id && { tool_id }),
-                    ...(initial_prompts && { initial_prompts }),
-                    ...(tool_result && { tool_result })
-                },
-            };
-        }
-        else if (audio && audio?.audio && audio?.format) {
-            outMessage = {
-                ev: SOCKET_EVENTS.CHAT,
-                ct: SOCKET_CONTENT_TYPES.AUDIO,
-                _id: Date.now().toString(),
-                ts: Date.now(),
-                data: {
-                    audio: audio?.audio,
-                    format: audio?.format,
-                    ...(tool_declined && { tool_declined }),
-                    ...(tool_result && { tool_result })
-                },
-            };
-        }
-        else if (tool_result) {
-            outMessage = {
-                ev: SOCKET_EVENTS.CHAT,
-                ct: SOCKET_CONTENT_TYPES.TEXT,
-                _id: Date.now().toString(),
-                ts: Date.now(),
-                data: {
-                    text: "",
-                    tool_result,
-                }
-            };
-        }
-        if (!outMessage) {
-            const error = new MessageError("No message to send", {
-                context: { stage: "sendSocketChatMessage" },
-            });
-            this.emitError(error);
-            throw error;
-        }
-        connection.sendMessage(outMessage);
-    }
-    /**
-     * Handle incoming chat message
-     */
-    handleIncomingSocketChatMessage(message) {
-        const connection = this.assertConnection("handleIncomingSocketChatMessage");
-        switch (message.ct) {
-            case SOCKET_CONTENT_TYPES.FILE: {
-                if (message?.data?.urls && message.data.urls?.length > 0) {
-                    //stage 2. of file upload process
-                    this.fileManager
-                        ?.uploadFilesToPresignedUrl(message.data.urls)
-                        .then((validUrls) => {
-                        this.sendSocketMessage({
-                            urls: validUrls,
-                        });
-                    })
-                        .catch((error) => {
-                        const fileError = this.toFileError(error, "Failed to upload files to presigned URL", {
-                            stage: "handleIncomingSocketChatMessage",
-                            urls: message.data?.urls?.length,
-                        });
-                        this.emitError(fileError);
-                    });
-                }
-                break;
-            }
-            case SOCKET_CONTENT_TYPES.TEXT:
-                if (message.data.text &&
-                    message.data.text.trim() === "" &&
-                    message._id) {
-                    const messageData = {
-                        data: { text: message.data.text },
-                        // type: message.ct,
-                        messageId: message._id,
-                        timestamp: message.ts,
-                    };
-                    connection.emit(SYNAPSE_REALTIME_EVENTS.MESSAGE_CHUNK, messageData);
-                }
-                break;
-            case SOCKET_CONTENT_TYPES.TOOL_CALL:
-                if (message?.data?.tool_id && message._id) {
-                    const chatMessageData = {
-                        data: { ...message.data },
-                        // type: message.ct,
-                        messageId: message._id,
-                        timestamp: message.ts,
-                    };
-                    connection.emit(SYNAPSE_REALTIME_EVENTS.TOOL_CALL, chatMessageData);
-                    // this.callbacks?.onElicitationTool?.(chatMessageData, message._id);
-                }
-                break;
-            case SOCKET_CONTENT_TYPES.AUDIO_TRANSCRIPT:
-                if (message?.data?.text) {
-                    const messageData = {
-                        data: { text: message.data.text },
-                        // type: message.ct,
-                        messageId: message._id,
-                        timestamp: message.ts,
-                    };
-                    connection.emit(SYNAPSE_REALTIME_EVENTS.AUDIO_TRANSCRIPT, messageData);
-                    // this.callbacks?.onChatmessage?.(message.data.text, message.ct);
-                }
-                break;
-            default:
-            // const error = new MessageError("Unsupported content type", {
-            //   context: {
-            //     stage: "handleIncomingSocketChatMessage",
-            //     contentType: message.ct,
-            //   },
-            // });
-            // this.emitError(error);
-            // throw error;
-        }
-    }
-    /**
-     * Handle incoming stream message
-     */
-    handleIncomingSocketStreamMessage(message) {
-        const connection = this.assertConnection("handleIncomingSocketStreamMessage");
-        switch (message.ct) {
-            case SOCKET_CONTENT_TYPES.TEXT:
-                if (message?.data?.progress_msg) {
-                    const messageData = {
-                        data: { text: message.data.progress_msg },
-                        // type: message.ct,
-                        messageId: message._id,
-                        timestamp: message.ts,
-                    };
-                    connection.emit(SYNAPSE_REALTIME_EVENTS.PROGRESS_MESSAGE, messageData);
-                    return;
-                }
-                if (message?.data?.text) {
-                    const messageData = {
-                        data: { text: message.data.text },
-                        // type: message.ct,
-                        messageId: message._id,
-                        timestamp: message.ts,
-                    };
-                    //the ui layer will handle the aggregation logic for stream messages
-                    connection.emit(SYNAPSE_REALTIME_EVENTS.MESSAGE_CHUNK, messageData);
-                }
-                break;
-            case SOCKET_CONTENT_TYPES.TIPS:
-                if (message?.data?.tips) {
-                    const messageData = {
-                        data: { tips: message.data.tips },
-                        // type: message.ct,
-                        messageId: message._id,
-                        timestamp: message.ts,
-                    };
-                    connection.emit(SYNAPSE_REALTIME_EVENTS.TIPS_MESSAGE, messageData);
-                    return;
-                }
-                break;
-            case SOCKET_CONTENT_TYPES.TOOL_CALL:
-                if (message?.data?.tool_id && message._id) {
-                    const streamMessageData = {
-                        data: { ...message.data },
-                        // type: message.ct,
-                        messageId: message._id,
-                        timestamp: message.ts,
-                    };
-                    connection.emit(SYNAPSE_REALTIME_EVENTS.TOOL_CALL, streamMessageData);
-                    // this.callbacks?.onElicitationTool?.(chatMessageData, message._id);
-                    return;
-                }
-                break;
-            case SOCKET_CONTENT_TYPES.TOOL_START:
-                const toolStartMessage = {
-                    data: message?.data,
-                    messageId: message._id || Date.now().toString(),
-                };
-                connection.emit(SYNAPSE_REALTIME_EVENTS.TOOL_START, toolStartMessage);
-                break;
-            case SOCKET_CONTENT_TYPES.TOOL_END:
-                const toolEndMessage = {
-                    data: message?.data,
-                    messageId: message._id || Date.now().toString(),
-                };
-                connection.emit(SYNAPSE_REALTIME_EVENTS.TOOL_END, toolEndMessage);
-                break;
-            default:
-                const error = new MessageError(`Unsupported content type ${message?.ct}`, {
-                    context: {
-                        stage: "handleIncomingSocketStreamMessage",
-                        contentType: message.ct,
-                    },
-                });
-                this.emitError(error);
-                throw error;
-        }
-    }
-    handleDisconnect(details) {
-        this.connection?.emit?.(SYNAPSE_REALTIME_EVENTS.DISCONNECTED, details);
-    }
-    /**
-     * Handle incoming end of stream message
-     */
-    handleIncomingSocketEndOfStreamMessage(_message) {
-        const connection = this.assertConnection("handleIncomingSocketEndOfStreamMessage");
-        connection.emit(SYNAPSE_REALTIME_EVENTS.END_OF_STREAM);
-    }
-    /**
-     * Handle incoming error message
-     */
-    handleIncomingSocketErrorMessage(message) {
-        const connection = this.assertConnection("handleIncomingSocketErrorMessage");
-        switch (message?.data?.code) {
-            case SYNAPSE_REALTIME_ERROR_CODES.SESSION_EXPIRED:
-                connection.emit(SYNAPSE_REALTIME_RESERVED_EVENTS.SESSION_EXPIRED);
-                break;
-            default:
-                const error = new MessageError(message?.data?.msg || "Socket error received", {
-                    context: {
-                        stage: "handleIncomingSocketErrorMessage",
-                        errorCode: message?.data?.code,
-                    },
-                    hint: message?.data?.msg,
-                    cause: message,
-                    displayMessage: message?.data?.msg,
-                });
-                console.log("error from socket", error);
-                connection.emit(SYNAPSE_REALTIME_EVENTS.ERROR, message);
-            // this.emitError(error);
-        }
-    }
-    /**
-     * send authentication message
-     */
-    sendSocketAuthMessage(sessionToken) {
-        const connection = this.assertConnection("sendSocketAuthMessage");
-        const authMessage = {
-            ev: SOCKET_EVENTS.AUTH,
-            _id: Date.now().toString(),
-            ts: Date.now(),
-            data: { token: sessionToken },
-        };
-        connection.sendMessage(authMessage);
-    }
-    /**
-     * send ping message
-     */
-    sendSocketPingMessage() {
-        const connection = this.assertConnection("sendSocketPingMessage");
-        const pingMessage = {
-            ev: SOCKET_EVENTS.PING,
-            _id: Date.now().toString(),
-            ts: Date.now(),
-        };
-        connection.sendMessage(pingMessage);
-    }
-    /**
-     * send audio message
-     */
-    async startRecording({ onChunks, onError, }) {
-        if (!onChunks) {
-            const error = new RecordingError("onChunks is required", {
-                context: { stage: "startRecording" },
-                hint: "onChunks is required",
-            });
-            this.emitError(error);
-            throw error;
-        }
-        if (!this.audioManager) {
-            this.audioManager = new AudioManager();
-        }
-        try {
-            await this.audioManager.start(onChunks, (error) => {
-                const recordingError = this.toRecordingError(error, "Failed to start audio recording", { stage: "startRecording" });
-                onError?.(recordingError);
-                this.emitError(recordingError);
-            });
-        }
-        catch (error) {
-            const recordingError = this.toRecordingError(error, "Failed to start audio recording", { stage: "startRecording" });
-            onError?.(recordingError);
-            this.emitError(recordingError);
-            throw recordingError;
-        }
-    }
-    /**
-     * stop recording audio
-     */
-    endRecordingWithSocket() {
-        if (!this.audioManager) {
-            const error = new RecordingError("Audio manager not set. Call startRecording() first.", { context: { stage: "stopRecording" } });
-            this.emitError(error);
-            throw error;
-        }
-        try {
-            this.audioManager.stop();
-        }
-        catch (error) {
-            const recordingError = this.toRecordingError(error, "Failed to stop audio recording", { stage: "stopRecording" });
-            this.emitError(recordingError);
-            throw recordingError;
-        }
-    }
-    /**
-     * send pong message
-     */
-    sendSocketPongMessage() {
-        const connection = this.assertConnection("sendSocketPongMessage");
-        const pongMessage = {
-            ev: SOCKET_EVENTS.PONG,
-            _id: Date.now().toString(),
-            ts: Date.now(),
-        };
-        connection.sendMessage(pongMessage);
-    }
-    handleConnectionEstablished() {
-        this.connection?.handleConnected(); //this will call the onConnectionStatusChange callback with connected
-        this.connection?.emit(SYNAPSE_REALTIME_EVENTS.CONNECTED);
-        this.flushOutgoingBuffer();
-    }
-    flushOutgoingBuffer() {
-        if (!this.connection?.isConnected() || !this.outgoingBuffer)
-            return;
-        const buf = this.outgoingBuffer;
-        this.outgoingBuffer = null;
-        this.sendSocketMessage(buf);
-    }
-    /**
-     * Cleanup message service
-     */
-    cleanupMessageServerState() {
-        this.outgoingBuffer = null;
-        this.connection = null;
-        if (this.fileManager) {
-            this.fileManager.clearPendingFilesState();
-            this.fileManager = null;
-        }
-        if (this.audioManager) {
-            this.audioManager.destroy();
-            this.audioManager = null;
-        }
-    }
-    // /**
-    //  * Generate a unique message ID
-    //  */
-    // private generateId(): string {
-    //   return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
-    // }
-    emitError(error) {
-        this.callbacks?.onError?.(error);
-    }
-    toFileError(error, fallbackMessage, context, hint) {
-        return normalizeError(error, FileError, fallbackMessage, {
-            context,
-            hint,
-        });
-    }
-    toRecordingError(error, fallbackMessage, context, hint) {
-        return normalizeError(error, RecordingError, fallbackMessage, {
-            context,
-            hint,
-        });
-    }
-    assertConnection(stage) {
-        if (!this.connection) {
-            const error = new ConnectionError("Connection not set. Please ensure the connection is established before calling this method.", {
-                context: { stage },
-            });
-            this.emitError(error);
-            throw error;
-        }
-        return this.connection;
-    }
-}

package/dist/esm/messages/types.js

@@ -1,35 +0,0 @@
-/**
- * Types for message management
- */
-import { SOCKET_CONTENT_TYPES, } from "../events/Events";
-export const SYNAPSE_MESSAGE_TYPES = SOCKET_CONTENT_TYPES;
-//TOD0: reframe event names
-export const SYNAPSE_REALTIME_EVENTS = {
-    CONNECTED: "connected",
-    DISCONNECTED: "disconnected",
-    PROGRESS_MESSAGE: "progress_message",
-    MESSAGE_CHUNK: "message_chunk",
-    TIPS_MESSAGE: "tips_message",
-    END_OF_STREAM: "end_of_stream",
-    ERROR: "error",
-    TOOL_CALL: "tool_call",
-    AUDIO_TRANSCRIPT: "audio_transcript",
-    TOOL_START: "tool_start",
-    TOOL_END: "tool_end"
-};
-export const SYNAPSE_REALTIME_ERROR_CODES = {
-    SESSION_INACTIVE: "session_not_found",
-    SESSION_EXPIRED: "session_expired",
-    INVALID_EVENT: "invalid_event",
-    INVALID_CONTENT_TYPE: "invalid_content",
-    PARSING_ERROR: "parsing", // for all LLM related error
-    FILE_UPLOAD_INPROGRESS: "file_upload_inprogress",
-    TIMEOUT: "timeout",
-    SERVER_ERROR: "server_error",
-    SESSION_TOKEN_MISMATCH: "session_token_mismatch",
-    PROMPT_FETCH_ERROR: "prompt_fetch_error",
-    INVALID_FILE_REQUEST: "invalid_file_request",
-};
-export const SYNAPSE_REALTIME_RESERVED_EVENTS = {
-    SESSION_EXPIRED: "session_expired", //to be used for session expiry
-};

package/dist/esm/resources/config/Config.js

@@ -1,11 +0,0 @@
-/**
- * resource for initial setup of the agent
- * will update soon
- */
-import { BaseResource } from "../../internal/Api/BaseResource";
-export class Config extends BaseResource {
-    basePath = "/med-assist/agent-config";
-    async retrieve(agentId) {
-        return this.get(`${this.basePath}/${agentId}`);
-    }
-}

package/dist/esm/resources/feedback/Feedback.js

@@ -1,9 +0,0 @@
-"use strict";
-// import { BaseResource } from "../../internal/Api/BaseResource";
-// import { FeedbackRequest } from "./types";
-// export class Feedback extends BaseResource {
-//   private basePath = "/med-assist/session";
-//   public async update(feedback: FeedbackRequest): Promise<{success: boolean, m}> {
-//     return this.patch<Feedback>(`${this.basePath}/${feedback.sessionId}/message/${feedback.messageId}/feedback`, feedback);
-//   }
-// }