@eka-care/medassist-core 1.0.0

package/README.md

@@ -0,0 +1,32 @@
+# @synapse/core
+
+TypeScript SDK for real-time medical chatbot experiences with session management, WebSocket connectivity, and media handling.
+
+## Installation
+
+```bash
+npm install @synapse/core
+```
+
+## Quick Start
+
+```typescript
+import { SynapseSDK } from "@synapse/core";
+
+const sdk = new SynapseSDK({
+  agentId: "agent-123",
+  environment: "production",
+  userId: "user-456",
+  callbacks: {
+    onSessionRefreshed: (session) => console.log("session refreshed", session),
+    onConnectionStatusChange: (status) => console.log("status", status),
+    onRecordingStatusChange: (status) => console.log("recording", status),
+    onError: (error) => console.error("synapse error", error),
+  },
+});
+
+const session = await sdk.startSession();
+sdk.sendMessage({ message: "Hello, doctor!" });
+```
+
+For more details, see the [main README](../../README.md).

package/dist/Synapse.d.ts

@@ -0,0 +1,131 @@
+/**
+ * High-level SynapseSDK API
+ * Provides a simple interface for managing chat sessions
+ */
+import { ConnectionType } from "./connection/ConnectionFactory";
+import { ConnectionStatus } from "./internal/connection/types";
+import { type Environment } from "./constants";
+import { SYNAPSE_REALTIME_EVENTS } from "./messages/types";
+import { SynapseError } from "./internal/Error/Error";
+import { type SessionResponse } from "./resources/session/types";
+import { AudioRecordingStatus } from "./media/audio/types";
+export interface SendMessageOptions {
+    message?: string;
+    messageId?: string;
+    files?: File[];
+    tool_use_id?: string;
+    tool_use_params?: Record<string, unknown>;
+    hidden?: boolean;
+}
+export interface SynapseSDKOverrides {
+    prompt?: string;
+    firstMessage?: string;
+    language?: string;
+}
+export type SynapseSDKError = SynapseError | Error;
+export interface SynapseSDKCallbacks {
+    onSessionRefreshed?: (sessionResponse: SessionResponse) => void;
+    onConnectionStatusChange?: (status: ConnectionStatus) => void;
+    onRecordingStatusChange?: (status: AudioRecordingStatus) => void;
+    onError?: (error: SynapseSDKError) => void;
+}
+export interface SynapseSDKConfig {
+    agentId: string;
+    environment?: Environment;
+    userId?: string;
+    connectionType?: ConnectionType;
+    overrides?: SynapseSDKOverrides;
+    callbacks?: SynapseSDKCallbacks;
+}
+export interface ExistingSessionOptions {
+    session_id: string;
+    session_token: string;
+}
+export declare class SynapseSDK {
+    private connection;
+    private messageManager;
+    private resourceManager;
+    private sessionToken;
+    private sessionId;
+    private config;
+    private connectionType;
+    constructor(config: SynapseSDKConfig);
+    /**
+     * 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
+     */
+    startSession(existingSession?: ExistingSessionOptions): Promise<SessionResponse>;
+    /**
+     * Send a message conetnt will be text always
+     */
+    sendMessage({ message, messageId, files, tool_use_id, tool_use_params, hidden, }: SendMessageOptions): Promise<void>;
+    /**
+     * Register a listener for a specific event
+     */
+    on(event: SYNAPSE_REALTIME_EVENTS, listener: (...args: unknown[]) => void): void;
+    /**
+     * Remove a listener for a specific event
+     */
+    off(event: SYNAPSE_REALTIME_EVENTS, listener: (...args: unknown[]) => void): void;
+    /**
+     * Get the session ID
+     */
+    getSessionConfig(): SessionResponse;
+    /**
+     * Send audio
+     * */
+    startRecording(): void;
+    /**
+     * Stop recording audio
+     */
+    endRecording(): void;
+    /**
+     * End the session
+     */
+    endSession(): void;
+    private emitError;
+    private toSessionError;
+    /**
+     * Initialize the connection
+     * eg: socket connection or polling connection
+     */
+    private initializeConnection;
+    /**
+     * Resolve the session
+     * function to decide whether to create a new session or refresh the existing session
+     */
+    private manageSession;
+    /**
+     * Refresh the session
+     */
+    private refreshSession;
+    /**
+     * Create a new session
+     */
+    private createNewSession;
+    /**
+     * Set up event handlers for connection and messages
+     */
+    private setupEventHandlers;
+    /**
+     * Handle socket error
+     */
+    private onSocketConnectionError;
+    /**
+     * Handle socket connection open
+     */
+    private onSocketConnectionOpen;
+    /**
+     * Handle incoming socket messages
+     */
+    private onIncomingSocketMessage;
+    /**
+     * Handle session expired
+     */
+    private handleSessionExpiry;
+    private toConnectionError;
+}
+//# sourceMappingURL=Synapse.d.ts.map

package/dist/Synapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Synapse.d.ts","sourceRoot":"","sources":["../src/Synapse.ts"],"names":[],"mappings":"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"}

package/dist/Synapse.js

@@ -0,0 +1,479 @@
+"use strict";
+/**
+ * High-level SynapseSDK API
+ * Provides a simple interface for managing chat sessions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynapseSDK = void 0;
+const ConnectionFactory_1 = require("./connection/ConnectionFactory");
+const types_1 = require("./internal/connection/types");
+const constants_1 = require("./constants");
+const resources_1 = require("./resources");
+// import { type AgentConfig } from "./resources/types";
+const MessageManager_1 = require("./messages/MessageManager");
+const types_2 = require("./messages/types");
+const Error_1 = require("./utils/Error");
+const Error_2 = require("./internal/Error/Error");
+const Events_1 = require("./events/Events");
+class SynapseSDK {
+    connection = null;
+    messageManager;
+    resourceManager;
+    // private agentConfig: AgentConfig | null = null;
+    sessionToken = null;
+    sessionId = null;
+    config;
+    connectionType;
+    constructor(config) {
+        this.config = {
+            ...config,
+            environment: config.environment || "production",
+        };
+        this.connectionType = config.connectionType || ConnectionFactory_1.ConnectionType.SOCKET;
+        const API_ORIGIN = (0, constants_1.getConfig)(this.config?.environment).BASE_API_URL;
+        this.resourceManager = new resources_1.ResourceManager({
+            agentId: this.config.agentId,
+            serverUrl: API_ORIGIN, //based on environment
+        });
+    }
+    /**
+     * 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 = Error_1.ErrorUtils.getUserFriendlyMessage(error);
+            const errorDetails = Error_1.ErrorUtils.getErrorDetails(error);
+            const sessionError = this.toSessionError(error, userFriendlyMessage || "Failed to start session", {
+                stage: "startSession",
+                details: errorDetails,
+            }, "Check network connectivity or refresh credentials before retrying.");
+            this.emitError(sessionError);
+            throw sessionError;
+        }
+    }
+    /**
+     * Send a message conetnt will be text always
+     */
+    async sendMessage({ message, messageId, files, tool_use_id, tool_use_params, hidden, }) {
+        if (!this.connection) {
+            const error = new Error_2.ConnectionError("Connection not established. Session may not be initialized.", {
+                context: { stage: "sendChatMessage" },
+                hint: "Call startSession() and wait for connection before sending messages.",
+            });
+            this.emitError(error);
+            throw error;
+        }
+        switch (this.connectionType) {
+            case ConnectionFactory_1.ConnectionType.SOCKET:
+                this.messageManager.sendSocketChatMessage({
+                    message: message,
+                    files: files,
+                    messageId: messageId,
+                    type: Events_1.SOCKET_CONTENT_TYPES.TEXT,
+                    tool_use_id: tool_use_id,
+                    tool_use_params: tool_use_params,
+                    hidden: hidden,
+                });
+                break;
+            default:
+                const error = new Error_2.ConnectionError("Unsupported connection type", {
+                    context: {
+                        stage: "sendChatMessage",
+                        connectionType: this.connectionType,
+                    },
+                });
+                this.emitError(error);
+                throw error;
+        }
+    }
+    // /**
+    //  * upload files
+    //  */
+    // public uploadFiles(
+    //   files: File[],
+    //   message?: string,
+    //   messageId?: string
+    // ): void {
+    //   if (!this.connection) {
+    //     //TODO: use onError instead of throw error
+    //     const error = new ConnectionError(
+    //       "Connection not established. Session may not be initialized.",
+    //       {
+    //         context: { stage: "uploadFiles" },
+    //         hint: "Call startSession() before attempting uploads.",
+    //       }
+    //     );
+    //     this.emitError(error);
+    //     throw error;
+    //   }
+    //   switch (this.connectionType) {
+    //     case ConnectionType.SOCKET:
+    //       this.messageManager.sendSocketChatMessage({
+    //         files,
+    //         message,
+    //         messageId: messageId,
+    //         type: SOCKET_CONTENT_TYPES.FILE,
+    //       });
+    //       break;
+    //     default:
+    //       const error = new ConnectionError("Unsupported connection type", {
+    //         context: {
+    //           stage: "uploadFiles",
+    //           connectionType: this.connectionType,
+    //         },
+    //       });
+    //       this.emitError(error);
+    //       throw error;
+    //   }
+    // }
+    /**
+     * Register a listener for a specific event
+     */
+    on(event, listener) {
+        this.connection?.on(event, listener);
+    }
+    /**
+     * Remove a listener for a specific event
+     */
+    off(event, listener) {
+        this.connection?.off(event, listener);
+    }
+    /**
+     * Get the session ID
+     */
+    getSessionConfig() {
+        if (!this.sessionId || !this.sessionToken) {
+            throw new Error_2.SessionError("Session ID or token not found", {
+                context: { stage: "getSessionConfig" },
+                hint: "Ensure the session API returns both identifiers.",
+            });
+        }
+        return {
+            session_id: this.sessionId,
+            session_token: this.sessionToken,
+        };
+    }
+    /**
+     * Send audio
+     * */
+    startRecording() {
+        if (!this.connection) {
+            const error = new Error_2.ConnectionError("Connection not established. Session may not be initialized.", {
+                context: { stage: "sendAudio" },
+                hint: "Call startSession() before attempting to send audio.",
+            });
+            this.emitError(error);
+            throw error;
+        }
+        switch (this.connectionType) {
+            case ConnectionFactory_1.ConnectionType.SOCKET:
+                this.messageManager.startRecordingWithSocket();
+                break;
+            default:
+                const error = new Error_2.ConnectionError("Unsupported connection type", {
+                    context: { stage: "sendAudio", connectionType: this.connectionType },
+                });
+                this.emitError(error);
+                throw error;
+        }
+    }
+    /**
+     * Stop recording audio
+     */
+    endRecording() {
+        if (!this.connection) {
+            const error = new Error_2.ConnectionError("Connection not established. Session may not be initialized.", {
+                context: { stage: "endRecording" },
+                hint: "Call startRecording() before attempting to stop recording.",
+            });
+            this.emitError(error);
+            throw error;
+        }
+        switch (this.connectionType) {
+            case ConnectionFactory_1.ConnectionType.SOCKET:
+                this.messageManager.endRecordingWithSocket();
+                break;
+            default:
+                const error = new Error_2.ConnectionError("Unsupported connection type", {
+                    context: {
+                        stage: "endRecording",
+                        connectionType: this.connectionType,
+                    },
+                });
+                this.emitError(error);
+                throw error;
+        }
+    }
+    // /**
+    //  * Get the agent configuration
+    //  */
+    // public getAgentConfig(): AgentConfig | null {
+    //   return this.agentConfig;
+    // }
+    /**
+     * End the session
+     */
+    endSession() {
+        if (this.connection) {
+            this.connection.close();
+            this.connection = null;
+        }
+        if (this.messageManager) {
+            this.messageManager.cleanupMessageServerState();
+        }
+    }
+    emitError(error) {
+        this.config.callbacks?.onError?.(error);
+    }
+    toSessionError(error, fallbackMessage, context, hint) {
+        return (0, Error_2.normalizeError)(error, Error_2.SessionError, fallbackMessage, {
+            context,
+            hint,
+        });
+    }
+    /**
+     * Initialize the connection
+     * eg: socket connection or polling connection
+     */
+    async initializeConnection(sessionResponse) {
+        if (this.connection) {
+            this.connection.close();
+            this.connection = null;
+        }
+        if (!sessionResponse.session_id || !sessionResponse.session_token) {
+            throw new Error_2.SessionError("Session ID or token not found", {
+                context: { stage: "initializeConnection" },
+                hint: "Ensure the session API returns both identifiers.",
+            });
+        }
+        this.sessionId = sessionResponse.session_id;
+        this.sessionToken = sessionResponse.session_token;
+        const serverUrl = (0, constants_1.getConfig)(this.config?.environment).WEBSOCKET_URL;
+        const connectionType = this.config.connectionType === "socket"
+            ? ConnectionFactory_1.ConnectionType.SOCKET
+            : ConnectionFactory_1.ConnectionType.SOCKET;
+        this.connection = await ConnectionFactory_1.ConnectionFactory.createConnection(connectionType, {
+            serverUrl,
+            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.messageManager = new MessageManager_1.MessageManager(this.connection, this.config?.callbacks);
+    }
+    /**
+     * Resolve the session
+     * function to decide whether to create a new session or refresh the existing session
+     */
+    async manageSession(existingSession) {
+        if (!existingSession?.session_id) {
+            return this.createNewSession();
+        }
+        this.config.callbacks?.onConnectionStatusChange?.(types_1.ConnectionStatus.CONNECTING);
+        try {
+            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);
+            }
+            return this.createNewSession();
+        }
+        catch (error) {
+            this.config.callbacks?.onConnectionStatusChange?.(types_1.ConnectionStatus.NOT_CONNECTED);
+            if (error instanceof Error_2.APIError) {
+                const status = error.status;
+                if (status === 404 || status === 500) {
+                    return this.createNewSession();
+                }
+            }
+            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 Error_2.APIError) {
+                const status = error.status;
+                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 || Date.now().toString());
+    }
+    /**
+     * Set up event handlers for connection and messages
+     */
+    setupEventHandlers() {
+        if (!this.connection)
+            return;
+        switch (this.connectionType) {
+            case ConnectionFactory_1.ConnectionType.SOCKET:
+                this.connection.onOpen(() => {
+                    this.onSocketConnectionOpen();
+                });
+                this.connection.onMessage((message) => {
+                    this.onIncomingSocketMessage(message);
+                });
+                this.connection.onError((error) => {
+                    this.onSocketConnectionError(error);
+                });
+                this.connection.onStatusChange((status) => {
+                    this.config.callbacks?.onConnectionStatusChange?.(status);
+                });
+                this.connection.on(types_2.SYNAPSE_REALTIME_RESERVED_EVENTS.SESSION_EXPIRED, () => {
+                    this.handleSessionExpiry();
+                });
+                break;
+            default:
+                throw new Error_2.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((details) => {
+            this.messageManager.handleDisconnect(details);
+            // this.endSession();
+        });
+    }
+    /**
+     * Handle socket error
+     */
+    onSocketConnectionError(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.sessionToken) {
+            const error = new Error_2.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.sessionToken);
+    }
+    /**
+     * Handle incoming socket messages
+     */
+    onIncomingSocketMessage(message) {
+        // this.config.callbacks?.onMessage?.(message.content, message.messageId);
+        switch (message.ev) {
+            case Events_1.SOCKET_EVENTS.CHAT:
+                this.messageManager.handleIncomingSocketChatMessage(message);
+                // this.config.callbacks?.onMessage?.(message.data.content, message.data.messageId);
+                break;
+            case Events_1.SOCKET_EVENTS.CONNECTION_ESTABLISHED: //emit after internal handlings
+                this.messageManager.handleConnectionEstablished();
+                break;
+            case Events_1.SOCKET_EVENTS.STREAM:
+                this.messageManager.handleIncomingSocketStreamMessage(message);
+                break;
+            case Events_1.SOCKET_EVENTS.END_OF_STREAM: //emit
+                this.messageManager.handleIncomingSocketEndOfStreamMessage(message);
+                break;
+            case Events_1.SOCKET_EVENTS.PING:
+                this.messageManager.sendSocketPongMessage();
+                break;
+            case Events_1.SOCKET_EVENTS.PONG:
+                this.messageManager.sendSocketPingMessage();
+                break;
+            case Events_1.SOCKET_EVENTS.SYNC:
+                break;
+            case Events_1.SOCKET_EVENTS.ERROR:
+                this.messageManager.handleIncomingSocketErrorMessage(message);
+                break;
+            default:
+                const error = new Error_2.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() {
+        try {
+            this.endSession();
+            this.config.callbacks?.onConnectionStatusChange?.(types_1.ConnectionStatus.CONNECTING);
+            if (!this.sessionId || !this.sessionToken) {
+                const error = new Error_2.SessionError("Session ID or token not found", {
+                    context: { stage: "handleSessionExpiry" },
+                });
+                this.emitError(error);
+                throw error;
+            }
+            const refreshed = await this.refreshSession(this.sessionId, this.sessionToken);
+            if (!refreshed.session_id || !refreshed.session_token) {
+                throw new Error_2.SessionError("Session refresh failed", {
+                    context: { stage: "handleSessionExpiry" },
+                });
+            }
+            this.sessionId = refreshed.session_id;
+            this.sessionToken = refreshed.session_token;
+            await this.initializeConnection(refreshed);
+            this.setupEventHandlers();
+            this.config.callbacks?.onSessionRefreshed?.(refreshed);
+        }
+        catch (error) {
+            this.config.callbacks?.onConnectionStatusChange?.(types_1.ConnectionStatus.NOT_CONNECTED);
+            const sessionError = this.toSessionError(error, "Session expired", {
+                stage: "handleSessionExpiry",
+            });
+            this.emitError(sessionError);
+        }
+    }
+    toConnectionError(error, fallbackMessage, context, hint) {
+        return (0, Error_2.normalizeError)(error, Error_2.ConnectionError, fallbackMessage, {
+            context,
+            hint,
+        });
+    }
+}
+exports.SynapseSDK = SynapseSDK;

package/dist/connection/ConnectionFactory.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Factory class to create the appropriate connection type
+ */
+import { BaseConnection } from "../internal/connection/BaseConnection";
+import { type WebSocketConnectionConfig } from "./Websocket";
+export declare const ConnectionType: {
+    readonly SOCKET: "socket";
+};
+export type ConnectionType = (typeof ConnectionType)[keyof typeof ConnectionType];
+export type ConnectionConfig = WebSocketConnectionConfig;
+export declare class ConnectionFactory {
+    /**
+     * Create a connection based on the specified type
+     */
+    static createConnection(type: ConnectionType, config: ConnectionConfig): Promise<BaseConnection>;
+}
+//# sourceMappingURL=ConnectionFactory.d.ts.map

package/dist/connection/ConnectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionFactory.d.ts","sourceRoot":"","sources":["../../src/connection/ConnectionFactory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AACvE,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,aAAa,CAAC;AAGrB,eAAO,MAAM,cAAc;;CAGjB,CAAC;AAEX,MAAM,MAAM,cAAc,GACxB,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAEvD,MAAM,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AAEzD,qBAAa,iBAAiB;IAC5B;;OAEG;WACiB,gBAAgB,CAClC,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,cAAc,CAAC;CAU3B"}