@eka-care/medassist-core 1.0.0

package/dist/media/audio/Audio.d.ts

@@ -0,0 +1,37 @@
+import { type AudioConfig, type AudioDataCallback, type AudioErrorCallback, type AudioRecordingStatusCallback } from "./types";
+export declare class AudioManager {
+    private mediaRecorder;
+    private mediaStream;
+    private recordingStartTime;
+    private autoPauseTimer;
+    private config;
+    private onAudioData;
+    private onAudioError;
+    private onRecordingStatusChange;
+    private suppressCallbacks;
+    constructor(config?: Partial<AudioConfig>);
+    private checkCurrentPermissionState;
+    start(onAudioData: AudioDataCallback, onRecordingStatusChange?: AudioRecordingStatusCallback, onAudioError?: AudioErrorCallback): Promise<void>;
+    private processAudioChunk;
+    private toRecordingError;
+    private handleError;
+    /**
+     * Set up auto-pause timer for 15-minute limit
+     */
+    private setupAutoPauseTimer;
+    private setupMediaRecorderEvents;
+    /**
+     * Convert blob to base64 string
+     */
+    private blobToBase64;
+    /**
+     * Stop recording manually
+     */
+    stop(): void;
+    /**
+     * Cancel recording (discard data and suppress callbacks)
+     */
+    cancel(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=Audio.d.ts.map

package/dist/media/audio/Audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Audio.d.ts","sourceRoot":"","sources":["../../../src/media/audio/Audio.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EAEvB,KAAK,4BAA4B,EAElC,MAAM,SAAS,CAAC;AAGjB,qBAAa,YAAY;IACvB,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,cAAc,CAA8C;IAEpE,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,YAAY,CAAmC;IACvD,OAAO,CAAC,uBAAuB,CAA6C;IAC5E,OAAO,CAAC,iBAAiB,CAAS;gBAEtB,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM;YAU/B,2BAA2B;IAa5B,KAAK,CAChB,WAAW,EAAE,iBAAiB,EAC9B,uBAAuB,CAAC,EAAE,4BAA4B,EACtD,YAAY,CAAC,EAAE,kBAAkB,GAChC,OAAO,CAAC,IAAI,CAAC;YAkGF,iBAAiB;IAyB/B,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,WAAW;IAoBnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B,OAAO,CAAC,wBAAwB;IAsChC;;OAEG;IACH,OAAO,CAAC,YAAY;IA8BpB;;OAEG;IACH,IAAI,IAAI,IAAI;IA8BZ;;OAEG;IACH,MAAM,IAAI,IAAI;IAiCd,OAAO,IAAI,IAAI;CAiChB"}

package/dist/media/audio/Audio.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioManager = void 0;
+const types_1 = require("./types");
+const Error_1 = require("../../internal/Error/Error");
+class AudioManager {
+    mediaRecorder = null;
+    mediaStream = null;
+    recordingStartTime = 0;
+    autoPauseTimer = null;
+    config;
+    onAudioData = null;
+    onAudioError = null;
+    onRecordingStatusChange = null;
+    suppressCallbacks = false; //gurad against late recorder events like ondatavaailable after cancel () or cleanup() is called
+    constructor(config = {}) {
+        this.config = {
+            mimeType: "audio/webm;codecs=opus",
+            audioBitsPerSecond: 128000,
+            maxRecordingDuration: 900000, // 15 minutes
+            autoPauseEnabled: true,
+            ...config,
+        };
+    }
+    async checkCurrentPermissionState() {
+        const permission = await navigator.permissions.query({
+            name: "microphone",
+        });
+        if (permission.state === "denied") {
+            throw new Error_1.RecordingError("Microphone permission denied", {
+                context: { permissionState: permission.state },
+                hint: "Ensure the browser has microphone access enabled for this site.",
+            });
+        }
+        return permission.state;
+    }
+    async start(onAudioData, onRecordingStatusChange, onAudioError //Clearly handles the error inside the callback without unhandled rejections
+    ) {
+        try {
+            // Check if mediaDevices is available
+            if (!navigator.mediaDevices) {
+                throw new Error_1.RecordingError("Media devices API is not available. This usually means the page is not served over HTTPS or there are browser restrictions.", {
+                    context: { feature: "mediaDevices" },
+                    hint: "Serve the app over HTTPS and verify browser/device microphone support.",
+                });
+            }
+            // Check if MediaRecorder is supported
+            if (!window.MediaRecorder) {
+                throw new Error_1.RecordingError("MediaRecorder is not supported in this browser", {
+                    context: { feature: "MediaRecorder" },
+                    hint: "Use a browser that supports the MediaRecorder API.",
+                });
+            }
+            // Check for supported audio formats in order of preference
+            const supportedTypes = [
+                "audio/mp3",
+                "audio/ogg;codecs=opus",
+                "audio/mp4",
+                "audio/ogg",
+                "audio/wav",
+            ].filter((type) => MediaRecorder.isTypeSupported(type));
+            if (supportedTypes.length === 0) {
+                throw new Error_1.RecordingError("No supported audio formats found in this browser", {
+                    context: { requestedTypes: supportedTypes },
+                    hint: "Verify codec support or adjust the requested MIME types.",
+                });
+            }
+            // Update config with best supported mime type
+            this.config.mimeType = supportedTypes[0];
+            await this.checkCurrentPermissionState();
+            this.onAudioData = onAudioData;
+            this.onAudioError = onAudioError ?? null;
+            this.onRecordingStatusChange = onRecordingStatusChange ?? null;
+            this.suppressCallbacks = false; //reset the guard against late recorder events
+            // Get user media
+            this.mediaStream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    echoCancellation: false,
+                    noiseSuppression: false,
+                    autoGainControl: false,
+                    sampleRate: 44100,
+                    channelCount: 1,
+                },
+            });
+            // Create MediaRecorder with fallback if the selected format fails
+            this.mediaRecorder = new MediaRecorder(this.mediaStream, {
+                mimeType: this.config.mimeType,
+                audioBitsPerSecond: this.config.audioBitsPerSecond,
+            });
+            // Verify MediaRecorder is in a valid state
+            if (this.mediaRecorder.state !== "inactive") {
+                throw new Error_1.RecordingError("MediaRecorder is in an invalid state for start()", {
+                    context: { recorderState: this.mediaRecorder.state },
+                });
+            }
+            // Set up event handlers
+            this.setupMediaRecorderEvents();
+            // Start recording
+            this.mediaRecorder.start();
+            this.recordingStartTime = Date.now();
+            this.onRecordingStatusChange?.(types_1.AudioRecordingStatus.LISTENING);
+            // Set up auto-pause timer if enabled
+            if (this.config.autoPauseEnabled) {
+                this.setupAutoPauseTimer();
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to start audio recording", {
+                stage: "start",
+            });
+        }
+    }
+    async processAudioChunk(blob) {
+        try {
+            this.onRecordingStatusChange?.(types_1.AudioRecordingStatus.PROCESSING);
+            const base64Audio = await this.blobToBase64(blob);
+            const now = Date.now();
+            if (!this.onAudioData) {
+                return;
+            }
+            const audioData = {
+                audio: base64Audio,
+                format: this.config.mimeType,
+                duration: this.recordingStartTime > 0 ? now - this.recordingStartTime : 0,
+                timestamp: this.recordingStartTime > 0 ? this.recordingStartTime : now,
+            };
+            this.onAudioData(audioData);
+            this.onRecordingStatusChange?.(types_1.AudioRecordingStatus.TRANSCRIBING);
+        }
+        catch (error) {
+            this.handleError(error, { stage: "process_audio_chunk" });
+        }
+    }
+    toRecordingError(error, fallbackMessage, context) {
+        if (error instanceof Error_1.RecordingError) {
+            return error;
+        }
+        if (error instanceof Error_1.SynapseError) {
+            return new Error_1.RecordingError(error.message, {
+                cause: error,
+                context: { ...error.context, ...context },
+                hint: error.hint,
+            });
+        }
+        const message = error instanceof Error && error.message ? error.message : fallbackMessage;
+        return new Error_1.RecordingError(message, {
+            cause: error,
+            context,
+        });
+    }
+    handleError(error, context) {
+        const recordingError = this.toRecordingError(error, "Unexpected recording error", context);
+        this.onRecordingStatusChange?.(types_1.AudioRecordingStatus.ERROR);
+        if (this.onAudioError) {
+            try {
+                this.onAudioError(recordingError);
+            }
+            catch (callbackError) {
+                console.error("Audio error callback failed:", callbackError);
+            }
+        }
+        else {
+            console.error("AudioManager error:", recordingError);
+        }
+    }
+    /**
+     * Set up auto-pause timer for 15-minute limit
+     */
+    setupAutoPauseTimer() {
+        if (this.autoPauseTimer) {
+            clearTimeout(this.autoPauseTimer);
+        }
+        this.autoPauseTimer = setTimeout(() => {
+            console.log("Auto-pause timer triggered after 15 minutes");
+            this.stop();
+        }, this.config.maxRecordingDuration);
+    }
+    setupMediaRecorderEvents() {
+        if (!this.mediaRecorder)
+            return;
+        this.mediaRecorder.ondataavailable = (event) => {
+            if (this.suppressCallbacks || event.data.size <= 0) {
+                return;
+            }
+            this.processAudioChunk(event.data).catch((error) => this.handleError(error, {
+                stage: "media_recorder_ondataavailable",
+                hasData: event.data.size > 0,
+            }));
+        };
+        this.mediaRecorder.onstop = async () => {
+            this.recordingStartTime = 0;
+        };
+        this.mediaRecorder.onerror = (event) => {
+            this.handleError(event.error instanceof Error
+                ? event.error
+                : new Error("MediaRecorder encountered an unknown error"), { stage: "media_recorder_onerror" });
+        };
+        this.mediaRecorder.onstart = () => {
+            console.log("MediaRecorder started recording");
+            if (this.mediaRecorder) {
+                console.log("MediaRecorder state:", this.mediaRecorder.state);
+                console.log("MediaRecorder MIME type:", this.mediaRecorder.mimeType);
+            }
+        };
+    }
+    /**
+     * Convert blob to base64 string
+     */
+    blobToBase64(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                if (typeof reader.result === "string") {
+                    // Remove data URL prefix (e.g., "data:audio/mp3;base64,")
+                    const base64 = reader.result.split(",")[1];
+                    resolve(base64);
+                }
+                else {
+                    reject(new Error_1.RecordingError("Failed to convert blob to base64", {
+                        context: { stage: "blob_to_base64" },
+                    }));
+                }
+            };
+            reader.onerror = () => reject(new Error_1.RecordingError("FileReader error while converting audio chunk to base64", {
+                cause: reader.error ?? undefined,
+                context: { stage: "blob_to_base64" },
+            }));
+            reader.readAsDataURL(blob);
+        });
+    }
+    /**
+     * Stop recording manually
+     */
+    stop() {
+        if (!this.mediaRecorder)
+            return;
+        try {
+            // Clear auto-pause timer
+            if (this.autoPauseTimer) {
+                clearTimeout(this.autoPauseTimer);
+                this.autoPauseTimer = null;
+            }
+            // Stop MediaRecorder
+            if (this.mediaRecorder.state === "recording") {
+                this.mediaRecorder.stop();
+            }
+            // Stop media stream
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+            this.onRecordingStatusChange?.(types_1.AudioRecordingStatus.IDLE);
+            console.log("Audio recording stopped manually");
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to stop audio recording", {
+                stage: "stop",
+            });
+        }
+    }
+    /**
+     * Cancel recording (discard data and suppress callbacks)
+     */
+    cancel() {
+        if (!this.mediaRecorder)
+            return;
+        try {
+            this.suppressCallbacks = true;
+            if (this.autoPauseTimer) {
+                clearTimeout(this.autoPauseTimer);
+                this.autoPauseTimer = null;
+            }
+            // Prevent ondataavailable from pushing chunks
+            this.mediaRecorder.ondataavailable = null;
+            // Stop MediaRecorder
+            if (this.mediaRecorder.state === "recording") {
+                this.mediaRecorder.stop();
+            }
+            // Stop media stream
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+            this.onRecordingStatusChange?.(types_1.AudioRecordingStatus.IDLE);
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to cancel audio recording", {
+                stage: "cancel",
+            });
+        }
+    }
+    destroy() {
+        try {
+            this.cancel();
+            if (this.mediaRecorder) {
+                this.mediaRecorder = null;
+            }
+            if (this.mediaStream) {
+                this.mediaStream.getTracks().forEach((track) => track.stop());
+                this.mediaStream = null;
+            }
+        }
+        catch (error) {
+            throw this.toRecordingError(error, "Failed to destroy audio resources", {
+                stage: "destroy",
+            });
+        }
+    }
+}
+exports.AudioManager = AudioManager;

package/dist/media/audio/types.d.ts

@@ -0,0 +1,25 @@
+import { RecordingError } from "../../internal/Error/Error";
+export interface AudioMetaData {
+    audio: string;
+    format: string;
+    duration: number;
+    timestamp: number;
+}
+export interface AudioConfig {
+    mimeType: string;
+    audioBitsPerSecond: number;
+    maxRecordingDuration: number;
+    autoPauseEnabled: boolean;
+}
+export type AudioDataCallback = (data: AudioMetaData) => void;
+export type AudioErrorCallback = (error: RecordingError) => void;
+export declare const AudioRecordingStatus: {
+    readonly IDLE: "idle";
+    readonly LISTENING: "listening";
+    readonly ERROR: "error";
+    readonly PROCESSING: "processing";
+    readonly TRANSCRIBING: "transcribing";
+};
+export type AudioRecordingStatus = (typeof AudioRecordingStatus)[keyof typeof AudioRecordingStatus];
+export type AudioRecordingStatusCallback = (status: AudioRecordingStatus) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/media/audio/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/media/audio/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AACjE,eAAO,MAAM,oBAAoB;;;;;;CAMvB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAC9B,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AACnE,MAAM,MAAM,4BAA4B,GAAG,CACzC,MAAM,EAAE,oBAAoB,KACzB,IAAI,CAAC"}

package/dist/media/audio/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioRecordingStatus = void 0;
+exports.AudioRecordingStatus = {
+    IDLE: "idle",
+    LISTENING: "listening",
+    ERROR: "error",
+    PROCESSING: "processing",
+    TRANSCRIBING: "transcribing",
+};

package/dist/media/file/File.d.ts

@@ -0,0 +1,54 @@
+export declare class Filemanager {
+    private pendingFiles;
+    private pendingMessage?;
+    private pendingFormat;
+    private messageId?;
+    /**
+     * Set the files for upload
+     */
+    setFilesForUpload(files: File[], messageId?: string, message?: string): void;
+    /**
+     * Get the pending file state
+     */
+    getPendingFileState(): {
+        files: File[];
+        messageId: string;
+        message: string;
+        format: string;
+    };
+    /**
+     * Upload files to presigned URLs
+     */
+    uploadFilesToPresignedUrl(presignedUrls: string[]): Promise<string>;
+    /**
+     * 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
+     */
+    zipFiles(): Promise<Blob>;
+    /**
+     * 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: Blob, fileName: string): File;
+    /**
+     * Checks if multiple files should be zipped
+     * @param files Array of files
+     * @returns boolean - true if files should be zipped
+     */
+    shouldZipFiles(): boolean;
+    /**
+     * 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
+     */
+    getUploadFileName(): string;
+    /**
+     * Clears the pending files
+     */
+    clearPendingFilesState(): void;
+}
+//# sourceMappingURL=File.d.ts.map

package/dist/media/file/File.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"File.d.ts","sourceRoot":"","sources":["../../../src/media/file/File.ts"],"names":[],"mappings":"AAMA,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,cAAc,CAAC,CAAc;IACrC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,SAAS,CAAC,CAAc;IAEhC;;OAEG;IACI,iBAAiB,CACtB,KAAK,EAAE,IAAI,EAAE,EACb,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,IAAI;IAaP;;OAEG;IAEI,mBAAmB,IAAI;QAC5B,KAAK,EAAE,IAAI,EAAE,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;KAChB;IASD;;OAEG;IACU,yBAAyB,CACpC,aAAa,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,MAAM,CAAC;IA4ElB;;;;;OAKG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IActC;;;;;OAKG;IACI,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIrD;;;;OAIG;IACI,cAAc,IAAI,OAAO;IAIhC;;;;OAIG;IACI,iBAAiB,IAAI,MAAM;IAOlC;;OAEG;IACI,sBAAsB,IAAI,IAAI;CAMtC"}

package/dist/media/file/File.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filemanager = void 0;
+/**
+ * Class to store file states
+ * Helpers: Zipping, uploading to presigned url, etc.
+ */
+const jszip_1 = __importDefault(require("jszip"));
+const Error_1 = require("../../internal/Error/Error");
+class Filemanager {
+    pendingFiles = [];
+    pendingMessage = "";
+    pendingFormat = "";
+    messageId = "";
+    /**
+     * Set the files for upload
+     */
+    setFilesForUpload(files, messageId, message) {
+        if (this.pendingFiles.length > 0) {
+            this.clearPendingFilesState();
+        }
+        this.pendingFiles = files;
+        this.messageId = messageId || Date.now().toString();
+        if (message && message.trim()) {
+            this.pendingMessage = message;
+        }
+        this.pendingFormat =
+            files.length > 1 ? "zip" : files?.[0]?.type?.split("/")?.[1] || "unknown";
+    }
+    /**
+     * Get the pending file state
+     */
+    getPendingFileState() {
+        return {
+            files: this.pendingFiles,
+            messageId: this.messageId || "",
+            message: this.pendingMessage || "",
+            format: this.pendingFormat || "",
+        };
+    }
+    /**
+     * Upload files to presigned URLs
+     */
+    async uploadFilesToPresignedUrl(presignedUrls) {
+        let successCount = 0;
+        // Filter out invalid URLs
+        const validUrls = presignedUrls.filter((url) => url && url.trim());
+        try {
+            if (validUrls.length === 0) {
+                throw new Error_1.FileError("No valid presigned URLs provided", {
+                    context: { stage: "uploadFilesToPresignedUrl" },
+                });
+            }
+            let fileToUpload;
+            let contentType;
+            if (this.shouldZipFiles()) {
+                // Zip multiple files into a single file
+                const zipBlob = await this.zipFiles();
+                const zipFileName = this.getUploadFileName();
+                fileToUpload = this.blobToFile(zipBlob, zipFileName);
+                contentType = "application/zip";
+            }
+            else {
+                // Single file, upload as is
+                fileToUpload = this.pendingFiles?.[0];
+                contentType = fileToUpload.type;
+            }
+            // Upload to all presigned URLs
+            for (let i = 0; i < validUrls.length; i++) {
+                const url = validUrls[i];
+                const response = await fetch(url, {
+                    method: "PUT",
+                    body: fileToUpload,
+                    headers: {
+                        "Content-Type": contentType,
+                        "x-ms-blob-type": "BlockBlob",
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error_1.FileError(`Failed to upload ${fileToUpload.name} to URL ${i + 1}: ${response.status} ${response.statusText}`, {
+                        context: {
+                            stage: "uploadFilesToPresignedUrl",
+                            status: response.status,
+                            url,
+                        },
+                    });
+                }
+                successCount++;
+            }
+            // Call sendFileUploadComplete only once with the first presigned URL
+            // this.sendFileUploadComplete(validUrls[0]);
+            return validUrls[0];
+        }
+        catch (error) {
+            if (successCount > 0) {
+                // this.sendFileUploadComplete(validUrls[0]);
+                return validUrls[0];
+            }
+            throw (0, Error_1.normalizeError)(error, Error_1.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
+     */
+    async zipFiles() {
+        const zip = new jszip_1.default();
+        // 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
+     */
+    shouldZipFiles() {
+        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
+     */
+    getUploadFileName() {
+        if (this.shouldZipFiles()) {
+            return `uploaded_files_${Date.now()}.zip`;
+        }
+        return this.pendingFiles[0]?.name || "file";
+    }
+    /**
+     * Clears the pending files
+     */
+    clearPendingFilesState() {
+        this.pendingFiles = [];
+        this.pendingMessage = "";
+        this.pendingFormat = "";
+        this.messageId = "";
+    }
+}
+exports.Filemanager = Filemanager;

package/dist/messages/MessageManager.d.ts

@@ -0,0 +1,79 @@
+/**
+ * MessageManager class to handle sending and receiving messages
+ * Works with BaseConnection and Store
+ */
+import { type SynapseSDKCallbacks } from "../Synapse";
+import { type IncomingSocketChatMessage, type IncomingSocketStreamMessage, type IncomingSocketErrorMessage, type IncomingSocketEndOfStreamMessage } from "../events/Events";
+import { BaseConnection } from "../internal/connection/BaseConnection";
+import { type SocketChatRequestData } from "./types";
+import { type DisconnectionDetails } from "../internal/connection/types";
+export declare class MessageManager {
+    private connection;
+    private callbacks;
+    private fileManager;
+    private audioManager;
+    constructor(connection: BaseConnection, callbacks?: SynapseSDKCallbacks);
+    /**
+     * Handle file upload process
+     */
+    private handleFileUploadProcess;
+    /**
+     * send chat message through socket
+     */
+    sendSocketChatMessage({ message, messageId, type, files, url, tool_use_id, tool_use_params, hidden, }: SocketChatRequestData): void;
+    /**
+     * Handle incoming chat message
+     */
+    handleIncomingSocketChatMessage(message: IncomingSocketChatMessage): void;
+    /**
+     * Handle incoming stream message
+     */
+    handleIncomingSocketStreamMessage(message: IncomingSocketStreamMessage): void;
+    handleDisconnect(details: DisconnectionDetails): void;
+    /**
+     * Handle incoming end of stream message
+     */
+    handleIncomingSocketEndOfStreamMessage(_message: IncomingSocketEndOfStreamMessage): void;
+    /**
+     * Handle incoming error message
+     */
+    handleIncomingSocketErrorMessage(message: IncomingSocketErrorMessage): void;
+    /**
+     * send authentication message
+     */
+    sendSocketAuthMessage(sessionToken: string): void;
+    /**
+     * send ping message
+     */
+    sendSocketPingMessage(): void;
+    /**
+     * start recording audio
+     */
+    private sendSocketStreamMessage;
+    /**
+     * send audio message
+     */
+    startRecordingWithSocket(): void;
+    /**
+     * stop recording audio
+     */
+    endRecordingWithSocket(): void;
+    /**
+     * send pong message
+     */
+    sendSocketPongMessage(): void;
+    handleConnectionEstablished(): void;
+    /**
+     * Cleanup message service
+     */
+    cleanupMessageServerState(): void;
+    /**
+     * Generate a unique message ID
+     */
+    private generateId;
+    private emitError;
+    private toFileError;
+    private toRecordingError;
+    private assertConnection;
+}
+//# sourceMappingURL=MessageManager.d.ts.map