@eka-care/medassist-core 1.0.0

package/dist/messages/MessageManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageManager.d.ts","sourceRoot":"","sources":["../../src/messages/MessageManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EAIL,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACtC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAEvE,OAAO,EAGL,KAAK,qBAAqB,EAI3B,MAAM,SAAS,CAAC;AAWjB,OAAO,EACL,KAAK,oBAAoB,EAC1B,MAAM,8BAA8B,CAAC;AACtC,qBAAa,cAAc;IACzB,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,YAAY,CAA6B;gBAErC,UAAU,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,mBAAmB;IAIvE;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAiD/B;;OAEG;IACI,qBAAqB,CAAC,EAC3B,OAAO,EACP,SAAS,EACT,IAAI,EACJ,KAAK,EACL,GAAG,EACH,WAAW,EACX,eAAe,EACf,MAAM,GACP,EAAE,qBAAqB,GAAG,IAAI;IA4C/B;;OAEG;IACI,+BAA+B,CACpC,OAAO,EAAE,yBAAyB,GACjC,IAAI;IAqFP;;OAEG;IACI,iCAAiC,CACtC,OAAO,EAAE,2BAA2B,GACnC,IAAI;IAsDA,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAI5D;;OAEG;IACI,sCAAsC,CAC3C,QAAQ,EAAE,gCAAgC,GACzC,IAAI;IAOP;;OAEG;IACI,gCAAgC,CACrC,OAAO,EAAE,0BAA0B,GAClC,IAAI;IAoBP;;OAEG;IACI,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAWxD;;OAEG;IACI,qBAAqB,IAAI,IAAI;IAUpC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAkC/B;;OAEG;IACI,wBAAwB,IAAI,IAAI;IAiCvC;;OAEG;IACI,sBAAsB,IAAI,IAAI;IAsBrC;;OAEG;IACI,qBAAqB,IAAI,IAAI;IAU7B,2BAA2B,IAAI,IAAI;IAM1C;;OAEG;IACI,yBAAyB,IAAI,IAAI;IAWxC;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,gBAAgB;CAsCzB"}

package/dist/messages/MessageManager.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageManager = void 0;
+const Events_1 = require("../events/Events");
+const File_1 = require("../media/file/File");
+const types_1 = require("./types");
+const Audio_1 = require("../media/audio/Audio");
+const types_2 = require("../media/audio/types");
+const Error_1 = require("../internal/Error/Error");
+class MessageManager {
+    connection = null;
+    callbacks = null;
+    fileManager = null;
+    audioManager = null;
+    constructor(connection, callbacks) {
+        this.connection = connection || null;
+        this.callbacks = callbacks || null;
+    }
+    /**
+     * Handle file upload process
+     */
+    handleFileUploadProcess({ files, messageId, message, url, }) {
+        if (!this.fileManager) {
+            this.fileManager = new File_1.Filemanager();
+        }
+        let fileUploadMessage;
+        if (files && files.length > 0) {
+            //stage 1. of file upload process
+            //--store files temproary in memory
+            this.fileManager.setFilesForUpload(files, messageId, message);
+            fileUploadMessage = {
+                ev: Events_1.SOCKET_EVENTS.CHAT,
+                ct: Events_1.SOCKET_CONTENT_TYPES.FILE,
+                _id: messageId || Date.now().toString(),
+                ts: Date.now(),
+                data: {
+                    extension: this.fileManager.getPendingFileState().format,
+                },
+            };
+        }
+        else if (url) {
+            //--stage 3. of file upload process
+            //--only requirement is url
+            //--send file upload acknowledgement to client
+            const text = this.fileManager.getPendingFileState().message;
+            fileUploadMessage = {
+                ev: Events_1.SOCKET_EVENTS.CHAT,
+                ct: Events_1.SOCKET_CONTENT_TYPES.FILE,
+                _id: this.fileManager.getPendingFileState().messageId,
+                ts: Date.now(),
+                data: {
+                    url: url,
+                    ...(text && { text }),
+                },
+            };
+            this.fileManager?.clearPendingFilesState();
+        }
+        return fileUploadMessage;
+    }
+    /**
+     * send chat message through socket
+     */
+    sendSocketChatMessage({ message, messageId, type, files, url, tool_use_id, tool_use_params, hidden, }) {
+        const connection = this.assertConnection("sendSocketChatMessage");
+        let outMessage;
+        switch (type) {
+            case Events_1.SOCKET_CONTENT_TYPES.FILE:
+                outMessage = this.handleFileUploadProcess({
+                    files,
+                    messageId,
+                    message,
+                    url,
+                });
+                break;
+            case Events_1.SOCKET_CONTENT_TYPES.TEXT:
+                outMessage = {
+                    ev: Events_1.SOCKET_EVENTS.CHAT,
+                    ct: type,
+                    _id: messageId || Date.now().toString(),
+                    ts: Date.now(),
+                    data: {
+                        text: message,
+                        ...(tool_use_id && { tool_use_id }),
+                        ...(tool_use_params && { tool_use_params }),
+                        ...(hidden && { hidden }),
+                    },
+                };
+                break;
+            default:
+                const error = new Error_1.MessageError("Unsupported content type", {
+                    context: { stage: "sendSocketChatMessage", type },
+                    hint: "Use SOCKET_CONTENT_TYPES.FILE or SOCKET_CONTENT_TYPES.TEXT.",
+                });
+                this.emitError(error);
+                throw error;
+        }
+        if (!outMessage) {
+            const error = new Error_1.MessageError("No message to send", {
+                context: { stage: "sendSocketChatMessage", type },
+            });
+            this.emitError(error);
+            throw error;
+        }
+        connection.sendMessage(outMessage);
+    }
+    /**
+     * Handle incoming chat message
+     */
+    handleIncomingSocketChatMessage(message) {
+        const connection = this.assertConnection("handleIncomingSocketChatMessage");
+        switch (message.ct) {
+            case Events_1.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(() => {
+                        this.sendSocketChatMessage({
+                            type: Events_1.SOCKET_CONTENT_TYPES.FILE,
+                            url: message.data.urls?.[0],
+                        });
+                    })
+                        .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 Events_1.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(types_1.SYNAPSE_REALTIME_EVENTS.MESSAGE_CHUNK, messageData);
+                }
+                break;
+            case Events_1.SOCKET_CONTENT_TYPES.PILL:
+            case Events_1.SOCKET_CONTENT_TYPES.MULTI:
+                // case SOCKET_CONTENT_TYPES.DOCTOR_CARD:
+                if (message?.data?.tool_use_id && message._id) {
+                    const chatMessageData = {
+                        data: { ...message.data, type: message.ct },
+                        // type: message.ct,
+                        messageId: message._id,
+                        timestamp: message.ts,
+                    };
+                    connection.emit(types_1.SYNAPSE_REALTIME_EVENTS.TOOL_ESCALATION, chatMessageData);
+                    // this.callbacks?.onElicitationTool?.(chatMessageData, message._id);
+                }
+                break;
+            case Events_1.SOCKET_CONTENT_TYPES.INLINE_TEXT:
+                if (message?.data?.text) {
+                    const messageData = {
+                        data: { text: message.data.text },
+                        // type: message.ct,
+                        messageId: message._id,
+                        timestamp: message.ts,
+                    };
+                    connection.emit(types_1.SYNAPSE_REALTIME_EVENTS.INLINE_TEXT, messageData);
+                    this.callbacks?.onRecordingStatusChange?.(types_2.AudioRecordingStatus.IDLE);
+                    // this.callbacks?.onChatmessage?.(message.data.text, message.ct);
+                }
+                break;
+            default:
+                const error = new Error_1.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 Events_1.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(types_1.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(types_1.SYNAPSE_REALTIME_EVENTS.MESSAGE_CHUNK, messageData);
+                }
+                break;
+            case Events_1.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(types_1.SYNAPSE_REALTIME_EVENTS.TIPS_MESSAGE, messageData);
+                    return;
+                }
+                break;
+            default:
+                const error = new Error_1.MessageError("Unsupported content type", {
+                    context: {
+                        stage: "handleIncomingSocketStreamMessage",
+                        contentType: message.ct,
+                    },
+                });
+                this.emitError(error);
+                throw error;
+        }
+    }
+    handleDisconnect(details) {
+        this.connection?.emit?.(types_1.SYNAPSE_REALTIME_EVENTS.DISCONNECTED, details);
+    }
+    /**
+     * Handle incoming end of stream message
+     */
+    handleIncomingSocketEndOfStreamMessage(_message) {
+        const connection = this.assertConnection("handleIncomingSocketEndOfStreamMessage");
+        connection.emit(types_1.SYNAPSE_REALTIME_EVENTS.END_OF_STREAM);
+    }
+    /**
+     * Handle incoming error message
+     */
+    handleIncomingSocketErrorMessage(message) {
+        const connection = this.assertConnection("handleIncomingSocketErrorMessage");
+        switch (message.code) {
+            case types_1.SYNAPSE_REALTIME_ERROR_CODES.SESSION_EXPIRED:
+                connection.emit(types_1.SYNAPSE_REALTIME_RESERVED_EVENTS.SESSION_EXPIRED);
+                break;
+            default:
+                const error = new Error_1.MessageError(message.msg || "Socket error received", {
+                    context: {
+                        stage: "handleIncomingSocketErrorMessage",
+                        errorCode: message.code,
+                    },
+                });
+                connection.emit(types_1.SYNAPSE_REALTIME_EVENTS.ERROR, error);
+                this.emitError(error);
+        }
+    }
+    /**
+     * send authentication message
+     */
+    sendSocketAuthMessage(sessionToken) {
+        const connection = this.assertConnection("sendSocketAuthMessage");
+        const authMessage = {
+            ev: Events_1.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: Events_1.SOCKET_EVENTS.PING,
+            _id: Date.now().toString(),
+            ts: Date.now(),
+        };
+        connection.sendMessage(pingMessage);
+    }
+    /**
+     * start recording audio
+     */
+    sendSocketStreamMessage({ data, type, messageId, timestamp, }) {
+        const connection = this.assertConnection("sendSocketStreamMessage");
+        switch (type) {
+            case Events_1.SOCKET_CONTENT_TYPES.AUDIO:
+                const message = {
+                    ev: Events_1.SOCKET_EVENTS.STREAM,
+                    ct: type,
+                    _id: messageId || this.generateId(),
+                    ts: timestamp || Date.now(),
+                    data: {
+                        audio: data.audio,
+                        format: data.format,
+                    },
+                };
+                connection.sendMessage(message);
+                break;
+            default:
+                const error = new Error_1.MessageError("Unsupported content type", {
+                    context: { stage: "sendSocketStreamMessage", contentType: type },
+                });
+                this.emitError(error);
+                throw error;
+        }
+    }
+    /**
+     * send audio message
+     */
+    startRecordingWithSocket() {
+        this.assertConnection("startRecording");
+        if (!this.audioManager) {
+            this.audioManager = new Audio_1.AudioManager();
+        }
+        this.audioManager
+            .start((audioData) => {
+            this.sendSocketStreamMessage({
+                data: audioData,
+                type: Events_1.SOCKET_CONTENT_TYPES.AUDIO,
+            });
+        }, this.callbacks?.onRecordingStatusChange ?? undefined, (error) => {
+            const recordingError = this.toRecordingError(error, "Audio recording error", { stage: "startRecording" });
+            this.emitError(recordingError);
+        })
+            .catch((error) => {
+            const recordingError = this.toRecordingError(error, "Failed to start audio recording", { stage: "startRecording" });
+            this.emitError(recordingError);
+        });
+    }
+    /**
+     * stop recording audio
+     */
+    endRecordingWithSocket() {
+        if (!this.audioManager) {
+            const error = new Error_1.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: Events_1.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(types_1.SYNAPSE_REALTIME_EVENTS.CONNECTED);
+        // this.connection?.handleConnected();
+    }
+    /**
+     * Cleanup message service
+     */
+    cleanupMessageServerState() {
+        if (this.fileManager) {
+            this.fileManager.clearPendingFilesState();
+            this.fileManager = null;
+        }
+        if (this.audioManager) {
+            this.audioManager.destroy();
+            this.audioManager = null;
+        }
+    }
+    /**
+     * Generate a unique message ID
+     */
+    generateId() {
+        return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+    }
+    emitError(error) {
+        this.callbacks?.onError?.(error);
+    }
+    toFileError(error, fallbackMessage, context, hint) {
+        return (0, Error_1.normalizeError)(error, Error_1.FileError, fallbackMessage, {
+            context,
+            hint,
+        });
+    }
+    toRecordingError(error, fallbackMessage, context, hint) {
+        return (0, Error_1.normalizeError)(error, Error_1.RecordingError, fallbackMessage, {
+            context,
+            hint,
+        });
+    }
+    assertConnection(stage) {
+        if (!this.connection) {
+            const error = new Error_1.ConnectionError("Connection not set. Please ensure the connection is established before calling this method.", {
+                context: { stage },
+            });
+            this.emitError(error);
+            throw error;
+        }
+        return this.connection;
+    }
+}
+exports.MessageManager = MessageManager;

package/dist/messages/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Types for message management
+ */
+import { SOCKET_CONTENT_TYPES, type IncomingSocketMessage, type OutgoingSocketMessage, MULTI_SELECT_ADDITIONAL_OPTION } from "../events/Events";
+import { type AudioMetaData } from "../media/audio/types";
+export declare const SYNAPSE_MESSAGE_TYPES: {
+    readonly TEXT: "text";
+    readonly AUDIO: "audio";
+    readonly FILE: "file";
+    readonly PILL: "pill";
+    readonly MULTI: "multi";
+    readonly DOCTOR_CARD: "doctor_card";
+    readonly TIPS: "tips";
+    readonly INLINE_TEXT: "inline_text";
+    readonly MOBILE_VERIFICATION: "mobile_verification";
+};
+export type ContentType = SOCKET_CONTENT_TYPES;
+export type IncomingMessage = IncomingSocketMessage;
+export type OutgoingMessage = OutgoingSocketMessage;
+export interface SocketChatRequestData {
+    message?: string;
+    messageId?: string;
+    type: SOCKET_CONTENT_TYPES;
+    files?: File[];
+    url?: string;
+    tool_use_id?: string;
+    tool_use_params?: Record<string, unknown>;
+    hidden?: boolean;
+}
+export declare const SYNAPSE_REALTIME_EVENTS: {
+    readonly CONNECTED: "connected";
+    readonly DISCONNECTED: "disconnected";
+    readonly PROGRESS_MESSAGE: "progress_message";
+    readonly MESSAGE_CHUNK: "message_chunk";
+    readonly TIPS_MESSAGE: "tips_message";
+    readonly END_OF_STREAM: "end_of_stream";
+    readonly ERROR: "error";
+    readonly TOOL_ESCALATION: "tool_escalation";
+    readonly INLINE_TEXT: "inline_text";
+};
+export type SYNAPSE_REALTIME_EVENTS = (typeof SYNAPSE_REALTIME_EVENTS)[keyof typeof SYNAPSE_REALTIME_EVENTS];
+export declare const SYNAPSE_REALTIME_ERROR_CODES: {
+    readonly SESSION_INACTIVE: "session_not_found";
+    readonly SESSION_EXPIRED: "session_expired";
+    readonly INVALID_EVENT: "invalid_event";
+    readonly INVALID_CONTENT_TYPE: "invalid_content";
+    readonly PARSING_ERROR: "parsing";
+    readonly FILE_UPLOAD_INPROGRESS: "file_upload_inprogress";
+    readonly TIMEOUT: "timeout";
+    readonly SERVER_ERROR: "server_error";
+    readonly SESSION_TOKEN_MISMATCH: "session_token_mismatch";
+};
+export type SYNAPSE_REALTIME_ERROR_CODES = (typeof SYNAPSE_REALTIME_ERROR_CODES)[keyof typeof SYNAPSE_REALTIME_ERROR_CODES];
+export declare const SYNAPSE_REALTIME_RESERVED_EVENTS: {
+    readonly SESSION_EXPIRED: "session_expired";
+};
+export type SYNAPSE_REALTIME_RESERVED_EVENTS = (typeof SYNAPSE_REALTIME_RESERVED_EVENTS)[keyof typeof SYNAPSE_REALTIME_RESERVED_EVENTS];
+export type SOCKET_STREAM_DATA = AudioMetaData;
+export type SynapseRealTimeEventData = {
+    data: ToolEscalationData;
+    messageId?: string;
+    timestamp?: number;
+};
+export type SynapseContentTypes = SOCKET_CONTENT_TYPES;
+export type ToolEscalationData = {
+    type?: ContentType;
+    choices?: string[];
+    callbacks?: Record<string, boolean>;
+    additional_option?: typeof MULTI_SELECT_ADDITIONAL_OPTION;
+    text?: string;
+    tips?: string[];
+    [key: string]: unknown;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/messages/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/messages/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,oBAAoB,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,8BAA8B,EAC/B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,eAAO,MAAM,qBAAqB;;;;;;;;;;CAAuB,CAAC;AAE1D,MAAM,MAAM,WAAW,GAAG,oBAAoB,CAAC;AAE/C,MAAM,MAAM,eAAe,GAAG,qBAAqB,CAAC;AACpD,MAAM,MAAM,eAAe,GAAG,qBAAqB,CAAC;AAEpD,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAGD,eAAO,MAAM,uBAAuB;;;;;;;;;;CAU1B,CAAC;AAEX,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAEzE,eAAO,MAAM,4BAA4B;;;;;;;;;;CAU/B,CAAC;AAEX,MAAM,MAAM,4BAA4B,GACtC,CAAC,OAAO,4BAA4B,CAAC,CAAC,MAAM,OAAO,4BAA4B,CAAC,CAAC;AAEnF,eAAO,MAAM,gCAAgC;;CAEnC,CAAC;AAEX,MAAM,MAAM,gCAAgC,GAC1C,CAAC,OAAO,gCAAgC,CAAC,CAAC,MAAM,OAAO,gCAAgC,CAAC,CAAC;AAG3F,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC;AAE/C,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,CAAC;AACvD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,iBAAiB,CAAC,EAAE,OAAO,8BAA8B,CAAC;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC"}

package/dist/messages/types.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Types for message management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNAPSE_REALTIME_RESERVED_EVENTS = exports.SYNAPSE_REALTIME_ERROR_CODES = exports.SYNAPSE_REALTIME_EVENTS = exports.SYNAPSE_MESSAGE_TYPES = void 0;
+const Events_1 = require("../events/Events");
+exports.SYNAPSE_MESSAGE_TYPES = Events_1.SOCKET_CONTENT_TYPES;
+//TOD0: reframe event names
+exports.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_ESCALATION: "tool_escalation",
+    INLINE_TEXT: "inline_text",
+};
+exports.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",
+};
+exports.SYNAPSE_REALTIME_RESERVED_EVENTS = {
+    SESSION_EXPIRED: "session_expired", //to be used for session expiry
+};

package/dist/resources/config/Config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * resource for initial setup of the agent
+ * will update soon
+ */ 
+//# sourceMappingURL=Config.d.ts.map

package/dist/resources/config/Config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/resources/config/Config.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/resources/config/Config.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * resource for initial setup of the agent
+ * will update soon
+ */ 

package/dist/resources/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Init class to fetch agent configuration from the platform
+ */
+import { type ResourceConfig } from "./types";
+import { type SessionResponse, type USER_FEEDBACK } from "./session/types";
+export declare class ResourceManager {
+    private resourceConfig;
+    private httpClient;
+    private session;
+    constructor(config: ResourceConfig);
+    /**
+     * Fetch agent configuration and create session
+     */
+    createSession(userId: string): Promise<SessionResponse>;
+    /**
+     * Validate a session if it's still active or not
+     * GET /med-assist/session/:sessionId
+     */
+    validateSession(sessionId: string): Promise<{
+        expired: boolean;
+        active: boolean;
+    }>;
+    /**
+     * Refresh a session
+     * POST /med-assist/session/:sessionId/refresh
+     */
+    refreshSession(sessionId: string, sessionToken: string): Promise<SessionResponse>;
+    /**
+     * Feedback on a message
+     * PATCH /med-assist/session/:sessionId/:messageId
+     */
+    sendFeedback(sessionId: string, messageId: string, feedback: USER_FEEDBACK, feedbackReason?: string): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAG3E,qBAAa,eAAe;IAC1B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAU;gBAEb,MAAM,EAAE,cAAc;IAgBlC;;OAEG;IACU,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAwBpE;;;OAGG;IACU,eAAe,CAC1B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;IAgDjD;;;OAGG;IACU,cAAc,CACzB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,eAAe,CAAC;IAI3B;;;OAGG;IACU,YAAY,CACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC;CAGjB"}