@eka-care/medassist-core 1.0.70 → 1.0.71

package/dist/esm/Synapse.js

@@ -1,612 +0,0 @@
-/**
- * High-level SynapseSDK API
- * Provides a simple interface for managing chat sessions
- */
-import { ConnectionFactory, ConnectionType, } from "./connection/ConnectionFactory";
-import { DisconnectionReason, } from "./internal/connection/types";
-import { getConfig } from "./constants";
-import { ResourceManager } from "./resources";
-// import { type AgentConfig } from "./resources/types";
-import { MessageManager } from "./messages/MessageManager";
-import { SYNAPSE_REALTIME_EVENTS, SYNAPSE_REALTIME_RESERVED_EVENTS, } from "./messages/types";
-import { EventEmitter } from "./internal/events/EventEmitter";
-import { ErrorUtils } from "./utils/Error";
-import { APIError, 
-// AuthenticationError,
-ConnectionError, MessageError, NotFoundError, 
-// RecordingError,
-SessionError, SynapseError, normalizeError, } from "./internal/Error/Error";
-import { SOCKET_EVENTS, } from "./events/Events";
-import { VoiceAgent } from "./voice/VoiceAgent";
-//TODO: Fix issue with handling error content type ,which is comming as a connection error to the user
-export class SynapseSDK {
-    connection = null;
-    messageManager;
-    resourceManager;
-    // private agentConfig: AgentConfig | null = null;
-    sessionConfig = null;
-    config;
-    connectionType;
-    isRefreshingSession = false;
-    connectionAttempts = 0;
-    sdkEventEmitter = new EventEmitter();
-    _voice = null;
-    constructor(config) {
-        this.config = {
-            ...config,
-            environment: config.environment || "production",
-        };
-        this.connectionType = config.connectionType || ConnectionType.SSE; //by default use SSE, can be overridden by config
-        const API_ORIGIN = getConfig(this.config?.environment).BASE_API_URL;
-        this.resourceManager = new ResourceManager({
-            agentId: this.config.agentId,
-            serverUrl: this.config.serverUrl || API_ORIGIN, //based on environment
-            ...(this.config.auth && { authorization: this.config.auth }),
-            ...(this.config.authToken && { authToken: this.config.authToken }),
-        });
-        this.messageManager = new MessageManager(this.config?.callbacks);
-    }
-    /**
-     * Start the session
-     * if existing session is provided, it will be validated and refreshed
-     * if no existing session is provided, a new session will be created
-     * then the connection will be initialized and event handlers will be setup
-     * return the session response
-     */
-    async startSession(existingSession) {
-        try {
-            const sessionResponse = await this.manageSession(existingSession);
-            await this.initializeConnection(sessionResponse);
-            this.setupEventHandlers();
-            return sessionResponse;
-        }
-        catch (error) {
-            const userFriendlyMessage = ErrorUtils.getUserFriendlyMessage(error);
-            const errorDetails = ErrorUtils.getErrorDetails(error);
-            if (error instanceof APIError) {
-                if (error.status === 404 || error.status === 403) {
-                    throw error;
-                }
-            }
-            const sessionError = this.toSessionError(error, userFriendlyMessage || "Failed to start session", {
-                stage: "startSession",
-                details: errorDetails,
-            }, "Check network connectivity or recheck credentials before retrying.");
-            this.emitError(sessionError);
-            throw sessionError;
-        }
-    }
-    /**
-     * Send a message conetnt will be text always
-     */
-    async sendMessage({ message, files, audio, tool_declined, tool_id, initial_prompts, tool_result }) {
-        switch (this.connectionType) {
-            case ConnectionType.SOCKET:
-            case ConnectionType.SSE:
-                this.messageManager.sendSocketMessage({
-                    message: message,
-                    files: files,
-                    audio: audio,
-                    ...(tool_declined && { tool_declined }),
-                    ...(tool_id && { tool_id }),
-                    ...(initial_prompts?.length && { initial_prompts }),
-                    ...(tool_result && Object.keys(tool_result)?.length && { tool_result })
-                });
-                break;
-            default:
-                const error = new ConnectionError("Unsupported connection type", {
-                    context: {
-                        stage: "sendChatMessage",
-                        connectionType: this.connectionType,
-                    },
-                });
-                this.emitError(error);
-                throw error;
-        }
-    }
-    /**
-     * Send feedback on a message
-     */
-    async sendFeedback(messageId, feedback, reason) {
-        if (!this.connection) {
-            const error = new ConnectionError("Connection not established. Session may not be initialized.", {
-                context: { stage: "sendFeedback" },
-                hint: "Call startSession() before attempting to send feedback.",
-            });
-            this.emitError(error);
-            throw error;
-        }
-        if (!this.sessionConfig?.session_id) {
-            const error = new SessionError("Session ID not found", {
-                context: { stage: "sendFeedback" },
-                hint: "Call startSession() before attempting to send feedback.",
-            });
-            this.emitError(error);
-            throw error;
-        }
-        switch (this.connectionType) {
-            case ConnectionType.SOCKET:
-            case ConnectionType.SSE:
-                await this.resourceManager.sendFeedback(this.sessionConfig.session_id, messageId, feedback, reason);
-                break;
-        }
-    }
-    /**
-     * Register a listener for a specific event
-     */
-    on(event, listener) {
-        this.sdkEventEmitter.on(event, listener);
-    }
-    /**
-     * Remove a listener for a specific event
-     */
-    off(event, listener) {
-        this.sdkEventEmitter.off(event, listener);
-    }
-    /**
-     * Get the session ID
-     */
-    getSessionConfig() {
-        if (!this.sessionConfig?.session_id || !this.sessionConfig?.session_token) {
-            throw new SessionError("Session ID or token not found", {
-                context: { stage: "getSessionConfig" },
-                hint: "Ensure the session API returns both identifiers.",
-            });
-        }
-        return this.sessionConfig;
-    }
-    /**
-     * Call tool
-     */
-    async callTool(tool_id, message_id, params) {
-        if (!this.connection) {
-            const error = new ConnectionError("Connection not established. Session may not be initialized.", {
-                context: { stage: "callTool" },
-                hint: "Call startSession() before attempting to call tool.",
-            });
-            this.emitError(error);
-            throw error;
-        }
-        if (!this.sessionConfig?.session_id || !this.sessionConfig?.session_token) {
-            const error = new SessionError("Session ID not found", {
-                context: { stage: "callTool" },
-                hint: "Call startSession() before attempting to call tool.",
-            });
-            this.emitError(error);
-            throw error;
-        }
-        switch (this.connectionType) {
-            case ConnectionType.SOCKET:
-            case ConnectionType.SSE:
-                try {
-                    const response = await this.resourceManager.callTool(this.sessionConfig.session_id, tool_id, message_id, this.sessionConfig.session_token, params);
-                    if (response.error) {
-                        throw new APIError(response.error.msg, 500, response.error);
-                    }
-                    let cleanedResponse = {
-                        data: { ...response.data },
-                        messageId: response._id,
-                        timestamp: response.ts,
-                    };
-                    this.connection.emit(SYNAPSE_REALTIME_EVENTS.TOOL_CALL, cleanedResponse);
-                }
-                catch (error) {
-                    if (error instanceof APIError && error?.status === 401) {
-                        await this.handleSessionExpiry();
-                        return await this.callTool(tool_id, message_id, params);
-                    }
-                    throw error;
-                }
-                break;
-            default:
-                const error = new ConnectionError("Unsupported connection type", {
-                    context: { stage: "callTool", connectionType: this.connectionType },
-                });
-                this.emitError(error);
-                throw error;
-        }
-    }
-    /**
-     * Send audio
-     * */
-    async startRecording({ onChunks, onError, }) {
-        switch (this.connectionType) {
-            case ConnectionType.SOCKET:
-            case ConnectionType.SSE:
-                try {
-                    await this.messageManager.startRecording({
-                        onChunks,
-                        onError,
-                    });
-                }
-                catch (error) {
-                    throw error;
-                }
-                break;
-            default:
-                const error = new ConnectionError("Unsupported connection type", {
-                    context: { stage: "sendAudio", connectionType: this.connectionType },
-                });
-                this.emitError(error);
-                throw error;
-        }
-    }
-    /**
-     * Stop recording audio
-     */
-    endRecording() {
-        switch (this.connectionType) {
-            case ConnectionType.SOCKET:
-            case ConnectionType.SSE:
-                this.messageManager.endRecordingWithSocket();
-                break;
-            default:
-                const error = new ConnectionError("Unsupported connection type", {
-                    context: {
-                        stage: "endRecording",
-                        connectionType: this.connectionType,
-                    },
-                });
-                this.emitError(error);
-                throw error;
-        }
-    }
-    // /**
-    //  * Get the agent configuration
-    //  */
-    async getAgentConfig() {
-        return this.resourceManager.getAgentConfig();
-    }
-    isConnected() {
-        return this.connection?.isConnected() ?? false;
-    }
-    get voice() {
-        if (!this._voice) {
-            this._voice = new VoiceAgent(this.buildVoiceConfig(), this.resourceManager, async () => {
-                const session = await this.resourceManager.createSession();
-                return {
-                    sessionId: session.session_id,
-                    sessionToken: session.session_token,
-                };
-            });
-        }
-        return this._voice;
-    }
-    /**
-     * End the session
-     */
-    endSession() {
-        this._voice?.destroy();
-        this._voice = null;
-        this.closeConnection();
-        this.cleanup();
-    }
-    buildVoiceConfig() {
-        const base = this.config.serverUrl ||
-            getConfig(this.config.environment).BASE_API_URL;
-        return {
-            offerUrl: `${base}/med-assist/voice/offer`,
-            handleRefresh: async () => {
-                await this.handleSessionExpiry();
-            },
-        };
-    }
-    toClientError(error) {
-        if (error instanceof APIError) {
-            return {
-                message: (error.error?.msg) || error.message,
-                error: error.error,
-                code: error.code,
-                status: error.status,
-                context: error.context,
-            };
-        }
-        if (error instanceof SynapseError) {
-            return {
-                message: error.displayMessage || error.message,
-                code: error.code,
-                context: error.context,
-            };
-        }
-        if (error instanceof Error) {
-            return { message: error.message };
-        }
-        return { message: "An unexpected error occurred" };
-    }
-    emitError(error) {
-        this.config.callbacks?.onError?.(this.toClientError(error));
-    }
-    toSessionError(error, fallbackMessage, context, hint) {
-        return normalizeError(error, SessionError, fallbackMessage, {
-            context,
-            hint,
-        });
-    }
-    /**
-     * Initialize the connection
-     * eg: socket connection or polling connection
-     */
-    async initializeConnection(sessionResponse) {
-        this.closeConnection();
-        if (!sessionResponse.session_id || !sessionResponse.session_token) {
-            throw new SessionError("Session ID or token not found", {
-                context: { stage: "initializeConnection" },
-                hint: "Ensure the session API returns both identifiers.",
-            });
-        }
-        this.sessionConfig = sessionResponse;
-        const envConfig = getConfig(this.config?.environment);
-        const isSocket = this.connectionType === ConnectionType.SOCKET;
-        const defaultUrl = isSocket ? envConfig.WEBSOCKET_URL : envConfig.BASE_API_URL;
-        const customUrl = this.config.serverUrl
-            ? isSocket
-                ? `wss://${this.config.serverUrl.split("://")[1]}`
-                : this.config.serverUrl
-            : null;
-        this.connection = await ConnectionFactory.createConnection(this.connectionType, {
-            serverUrl: customUrl || defaultUrl,
-            auth: {
-                sessionId: sessionResponse.session_id,
-                sessionToken: sessionResponse.session_token,
-            },
-            agentId: this.config.agentId,
-            userId: this.config.userId,
-            // authorization: this.config?.authorization,
-            overrides: this.config.overrides,
-        });
-        this.connectionAttempts++;
-        this.messageManager.setConnection(this.connection);
-        // Bridge all connection events to the persistent SDK-level emitter so that
-        // widget listeners registered via .on() survive internal reconnections.
-        const originalEmit = this.connection.emit.bind(this.connection);
-        this.connection.emit = (event, ...args) => {
-            originalEmit(event, ...args);
-            this.sdkEventEmitter.emit(event, ...args);
-        };
-    }
-    /**
-     * Resolve the session
-     * function to decide whether to create a new session or refresh the existing session
-     */
-    async manageSession(existingSession) {
-        try {
-            if (!existingSession?.session_id) {
-                return this.createNewSession();
-            }
-            const result = await this.resourceManager.validateSession(existingSession.session_id);
-            if (result.active) {
-                return existingSession;
-            }
-            if (result.expired) {
-                return this.refreshSession(existingSession.session_id, existingSession.session_token);
-            }
-            throw new APIError("Failed to create session", 500, undefined, undefined);
-        }
-        catch (error) {
-            console.log("error", error, error instanceof APIError);
-            if (error instanceof APIError) {
-                if (error.status === 404 || error.status === 403) {
-                    throw error;
-                }
-            }
-            else if (error instanceof NotFoundError && error.status === 404) {
-                throw error;
-            }
-            throw this.toSessionError(error, "Failed to resolve session", {
-                stage: "resolveSession",
-            });
-        }
-    }
-    /**
-     * Refresh the session
-     */
-    async refreshSession(sessionId, sessionToken) {
-        try {
-            return await this.resourceManager.refreshSession(sessionId, sessionToken);
-        }
-        catch (error) {
-            if (error instanceof APIError) {
-                // Emit API error via onError callback before handling
-                this.emitError(error);
-                // if (status === 404 || status === 500) {
-                //   return this.createNewSession();
-                // }
-            }
-            throw this.toSessionError(error, "Failed to refresh session", {
-                stage: "refreshSession",
-                sessionId,
-            });
-        }
-    }
-    /**
-     * Create a new session
-     */
-    async createNewSession() {
-        return await this.resourceManager.createSession(this.config.userId, this.config.context);
-    }
-    /**
-     * Set up event handlers for connection and messages
-     */
-    setupEventHandlers() {
-        if (!this.connection)
-            return;
-        switch (this.connectionType) {
-            case ConnectionType.SOCKET:
-                this.connection.onOpen(() => {
-                    this.onSocketConnectionOpen();
-                });
-                this.connection.onMessage((message) => {
-                    this.onIncomingSocketMessage(message);
-                });
-                this.connection.onError((error) => {
-                    this.onSocketConnectionError(error);
-                });
-                this.connection.on(SYNAPSE_REALTIME_RESERVED_EVENTS.SESSION_EXPIRED, () => {
-                    this.handleSessionExpiry();
-                });
-                break;
-            case ConnectionType.SSE:
-                // SSE auth is handled at the URL/header layer, no auth message needed.
-                // Connection is considered "established" as soon as the stream opens.
-                this.connection.onOpen(() => {
-                    this.messageManager.handleConnectionEstablished();
-                });
-                this.connection.onMessage((message) => {
-                    this.onIncomingSocketMessage(message);
-                });
-                this.connection.onError((error) => {
-                    this.onSocketConnectionError(error);
-                });
-                this.connection.on(SYNAPSE_REALTIME_RESERVED_EVENTS.SESSION_EXPIRED, () => {
-                    this.handleSessionExpiry();
-                });
-                break;
-            default:
-                throw new ConnectionError("Unsupported connection type", {
-                    context: {
-                        stage: "setupEventHandlers",
-                        connectionType: this.connectionType,
-                    },
-                    hint: "Use ConnectionType.SOCKET or provide a custom handler.",
-                });
-        }
-        //common handler for all connection types
-        this.connection.onDisconnect(async (details) => {
-            if (details.reason === DisconnectionReason.CLIENT_CLOSED)
-                return;
-            if (this.connectionAttempts < 3 && this.sessionConfig?.session_id && this.sessionConfig.session_token) {
-                try {
-                    await this.startSession({ session_id: this.sessionConfig.session_id, session_token: this.sessionConfig.session_token });
-                }
-                catch (error) {
-                    this.messageManager.handleDisconnect(details);
-                }
-            }
-            else {
-                this.messageManager.handleDisconnect(details);
-            }
-        });
-    }
-    /**
-     * Handle socket error
-     */
-    onSocketConnectionError(error) {
-        this.connection?.emit(SYNAPSE_REALTIME_EVENTS.ERROR, error);
-        const connectionError = this.toConnectionError(error, "WebSocket connection error", { stage: "onSocketConnectionError" }, "Verify network connectivity or attempt to reconnect.");
-        this.emitError(connectionError);
-    }
-    /**
-     * Handle socket connection open
-     */
-    onSocketConnectionOpen() {
-        if (!this.sessionConfig?.session_token) {
-            const error = new SessionError("Session token not set. Call startSession() first.", {
-                context: { stage: "onSocketConnectionOpen" },
-                hint: "Ensure startSession() completes successfully before socket opens.",
-            });
-            this.emitError(error);
-            throw error;
-        }
-        this.messageManager.sendSocketAuthMessage(this.sessionConfig.session_token);
-    }
-    /**
-     * Handle incoming socket messages
-     */
-    onIncomingSocketMessage(message) {
-        // this.config.callbacks?.onMessage?.(message.content, message.messageId);
-        switch (message.ev) {
-            case SOCKET_EVENTS.CHAT:
-                this.messageManager.handleIncomingSocketChatMessage(message);
-                // this.config.callbacks?.onMessage?.(message.data.content, message.data.messageId);
-                break;
-            case SOCKET_EVENTS.CONNECTION_ESTABLISHED: //emit after internal handlings
-                this.messageManager.handleConnectionEstablished();
-                break;
-            case SOCKET_EVENTS.STREAM:
-                this.messageManager.handleIncomingSocketStreamMessage(message);
-                break;
-            case SOCKET_EVENTS.END_OF_STREAM: //emit
-                this.messageManager.handleIncomingSocketEndOfStreamMessage(message);
-                break;
-            case SOCKET_EVENTS.PING:
-                this.messageManager.sendSocketPongMessage();
-                break;
-            case SOCKET_EVENTS.PONG:
-                this.messageManager.sendSocketPingMessage();
-                break;
-            case SOCKET_EVENTS.SYNC:
-                break;
-            case SOCKET_EVENTS.ERROR:
-                this.messageManager.handleIncomingSocketErrorMessage(message);
-                break;
-            default:
-                const error = new MessageError("Unsupported message type", {
-                    context: {
-                        stage: "onIncomingSocketMessage",
-                        event: message.ev ?? "unknown",
-                    },
-                    hint: "Ensure the server is sending supported socket events.",
-                });
-                this.emitError(error);
-                return;
-        }
-    }
-    /**
-     * Handle session expired
-     */
-    async handleSessionExpiry() {
-        if (this.isRefreshingSession) {
-            console.warn("Session is already being refreshed");
-            return;
-        }
-        try {
-            this.closeConnection();
-            if (!this.sessionConfig?.session_id ||
-                !this.sessionConfig?.session_token) {
-                const error = new SessionError("Session ID or token not found", {
-                    context: { stage: "handleSessionExpiry" },
-                });
-                this.emitError(error);
-                throw error;
-            }
-            this.isRefreshingSession = true;
-            const refreshed = await this.refreshSession(this.sessionConfig.session_id, this.sessionConfig.session_token);
-            if (!refreshed.session_id || !refreshed.session_token) {
-                throw new SessionError("Session refresh failed", {
-                    context: { stage: "handleSessionExpiry" },
-                });
-            }
-            this.sessionConfig.session_id = refreshed.session_id;
-            this.sessionConfig.session_token = refreshed.session_token;
-            await this.initializeConnection(refreshed);
-            this.setupEventHandlers();
-            this.config.callbacks?.onSessionRefreshed?.(refreshed);
-        }
-        catch (error) {
-            const sessionError = this.toSessionError(error, "Session expired", {
-                stage: "handleSessionExpiry",
-            });
-            this.emitError(sessionError);
-        }
-        finally {
-            this.isRefreshingSession = false;
-        }
-    }
-    toConnectionError(error, fallbackMessage, context, hint) {
-        return normalizeError(error, ConnectionError, fallbackMessage, {
-            context,
-            hint,
-        });
-    }
-    closeConnection() {
-        if (this.connection) {
-            this.connection.close();
-            this.connection = null;
-        }
-    }
-    cleanup() {
-        this.connectionAttempts = 0;
-        this.sdkEventEmitter?.removeAllListeners?.();
-        this.messageManager?.cleanupMessageServerState?.();
-    }
-}

package/dist/esm/connection/ConnectionFactory.js

@@ -1,27 +0,0 @@
-/**
- * Factory class to create the appropriate connection type
- */
-import { WebSocketConnection, } from "./Websocket";
-import { SSEConnection } from "./SSE";
-import { ConnectionError } from "../internal/Error/Error";
-export const ConnectionType = {
-    SOCKET: "socket",
-    SSE: "sse",
-};
-export class ConnectionFactory {
-    /**
-     * Create a connection based on the specified type
-     */
-    static async createConnection(type, config) {
-        switch (type) {
-            case ConnectionType.SOCKET:
-                return new WebSocketConnection(config);
-            case ConnectionType.SSE:
-                return new SSEConnection(config);
-            default:
-                throw new ConnectionError(`Unsupported connection type: ${type}`, {
-                    context: { type },
-                });
-        }
-    }
-}