@eka-care/medassist-core 1.0.66 → 1.0.67

package/dist/esm/connection/SSE.js

@@ -0,0 +1,212 @@
+/**
+ * Server-Sent Events implementation of BaseConnection.
+ *
+ * Unlike the classic GET + EventSource pattern, this server streams events
+ * back as the response body of a POST to /chat. The request body is the
+ * same OutgoingSocketMessage envelope used over the WebSocket, so
+ * MessageManager parsing is shared.
+ *
+ * Wire shape:
+ *   POST  {serverUrl}/med-assist/session/{sessionId}/chat
+ *   Headers: Content-Type: application/json
+ *            Accept:       text/event-stream
+ *            sess-token:   <session token>
+ *            x-agent-id:   <agent id>
+ *   Body:    JSON-encoded OutgoingSocketMessage
+ *   Response: text/event-stream with `data: <json>\n\n` frames whose payloads
+ *             match the IncomingSocketMessage shape.
+ */
+import { BaseConnection } from "../internal/connection/BaseConnection";
+import { ConnectionStatus, } from "../internal/connection/types";
+import { ConnectionError, MessageError, normalizeError, } from "../internal/Error/Error";
+export class SSEConnection extends BaseConnection {
+    conversationId;
+    config;
+    connected = false;
+    activeStreamController = null;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.conversationId = config.auth.sessionId;
+        this.connect();
+    }
+    /**
+     * "Open" the SSE channel. There is no persistent socket — the connection
+     * is considered ready as soon as the session/agent identifiers are set.
+     * Each outgoing message opens its own short-lived streaming response.
+     *
+     * The open callback is deferred to a macrotask so it fires AFTER
+     * `Synapse.startSession()` resolves and the consumer (e.g. widget's
+     * `setUpEventListeners`) has had a chance to register the CONNECTED
+     * listener. With WebSocket the real socket open is naturally async; we
+     * have to simulate that here, otherwise the CONNECTED event is emitted
+     * before anyone is listening for it.
+     */
+    connect() {
+        this.updateStatus(ConnectionStatus.CONNECTING);
+        this.connected = true;
+        setTimeout(() => {
+            this.onOpenCallback?.();
+        }, 0);
+    }
+    /**
+     * Fire the open callback if the connection is already up by the time
+     * the listener registers. Mirrors the queued-disconnect pattern in
+     * BaseConnection so late-registering consumers don't miss the open
+     * event. Deferred via setTimeout for the same reason as connect().
+     */
+    onOpen(callback) {
+        this.onOpenCallback = callback;
+        if (this.connected) {
+            setTimeout(() => callback(), 0);
+        }
+    }
+    buildChatUrl() {
+        const url = new URL(this.config.serverUrl);
+        url.pathname = `${url.pathname.replace(/\/$/, "")}/med-assist/session/${this.config.auth.sessionId}/chat`;
+        return url.toString();
+    }
+    /**
+     * Send an outgoing message. POSTs the same envelope used over the
+     * WebSocket and streams the response back as SSE-encoded events.
+     */
+    sendMessage(message) {
+        if (!this.connected) {
+            const error = new ConnectionError("SSE connection is not open", {
+                context: { stage: "sendMessage" },
+            });
+            this.onErrorCallback?.(error);
+            return;
+        }
+        this.activeStreamController?.abort();
+        const controller = new AbortController();
+        this.activeStreamController = controller;
+        void this.streamChat(message, controller);
+    }
+    async streamChat(message, controller) {
+        const url = this.buildChatUrl();
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "text/event-stream",
+                    "sess-token": this.config.auth.sessionToken,
+                    "x-agent-id": this.config.agentId,
+                },
+                body: JSON.stringify(message),
+                signal: controller.signal,
+            });
+            if (!response.ok || !response.body) {
+                throw new ConnectionError(`SSE chat request failed with status ${response.status}`, { context: { stage: "streamChat", status: response.status } });
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                buffer = this.extractJsonObjects(buffer);
+            }
+            // Final flush in case the stream ends mid-object.
+            if (buffer.trim().length > 0) {
+                this.extractJsonObjects(buffer);
+            }
+        }
+        catch (error) {
+            if (controller.signal.aborted)
+                return;
+            const connectionError = normalizeError(error, ConnectionError, "SSE chat stream failed", { context: { stage: "streamChat" } });
+            this.onErrorCallback?.(connectionError);
+        }
+        finally {
+            if (this.activeStreamController === controller) {
+                this.activeStreamController = null;
+            }
+        }
+    }
+    /**
+     * Walk the buffer and dispatch every complete top-level JSON object it
+     * contains, returning any trailing partial-object bytes that still need
+     * more data. The server streams back-to-back objects (`{…}{…}{…}`) with
+     * no separator, so we track brace depth (respecting strings/escapes)
+     * to find each object boundary. Any whitespace or stray SSE prefixes
+     * between objects is skipped automatically since we anchor on `{`.
+     */
+    extractJsonObjects(buffer) {
+        let i = 0;
+        while (i < buffer.length) {
+            const start = buffer.indexOf("{", i);
+            if (start === -1)
+                return "";
+            const end = this.findObjectEnd(buffer, start);
+            if (end === -1) {
+                // Incomplete object — keep from `start` onward for the next chunk.
+                return buffer.slice(start);
+            }
+            const objStr = buffer.slice(start, end + 1);
+            try {
+                const parsed = JSON.parse(objStr);
+                this.handleMessage(parsed);
+            }
+            catch (error) {
+                const parseError = normalizeError(error, MessageError, "Failed to parse incoming SSE object", { context: { stage: "extractJsonObjects", objStr } });
+                this.onErrorCallback?.(parseError);
+            }
+            i = end + 1;
+        }
+        return "";
+    }
+    /**
+     * Return the index of the matching closing brace for the `{` at `start`,
+     * or -1 if the buffer ends before the object closes. String contents
+     * and escape sequences are skipped so braces inside strings don't
+     * affect the depth count.
+     */
+    findObjectEnd(buffer, start) {
+        let depth = 0;
+        let inString = false;
+        let escape = false;
+        for (let i = start; i < buffer.length; i++) {
+            const ch = buffer[i];
+            if (inString) {
+                if (escape) {
+                    escape = false;
+                }
+                else if (ch === "\\") {
+                    escape = true;
+                }
+                else if (ch === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+            }
+            else if (ch === "{") {
+                depth++;
+            }
+            else if (ch === "}") {
+                depth--;
+                if (depth === 0)
+                    return i;
+            }
+        }
+        return -1;
+    }
+    close() {
+        this.connected = false;
+        this.activeStreamController?.abort();
+        this.activeStreamController = null;
+        this.updateStatus(ConnectionStatus.NOT_CONNECTED);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    handleConnected() {
+        this.updateStatus(ConnectionStatus.CONNECTED);
+    }
+}

package/dist/esm/connection/Websocket.js

@@ -0,0 +1,178 @@
+/**
+ * WebSocket implementation of BaseConnection
+ */
+import { BaseConnection } from "../internal/connection/BaseConnection";
+import { ConnectionStatus, DisconnectionReason, } from "../internal/connection/types";
+import { ConnectionError, MessageError, normalizeError, } from "../internal/Error/Error";
+export class WebSocketConnection extends BaseConnection {
+    conversationId;
+    socket = null;
+    config;
+    authenticated = false;
+    constructor(config) {
+        super();
+        this.config = {
+            ...config,
+            reconnect: config.reconnect || true,
+            reconnectAttempts: config.reconnectAttempts || 3,
+            reconnectDelay: config.reconnectDelay || 1000,
+        };
+        this.conversationId = config.auth.sessionId;
+        this.connect();
+    }
+    /**
+     * Establish WebSocket connection
+     */
+    connect() {
+        try {
+            if ((this.socket && this.socket.readyState === WebSocket.OPEN) || this.authenticated)
+                return;
+            this.updateStatus(ConnectionStatus.CONNECTING);
+            // Build WebSocket URL with query parameters
+            const url = this.buildConnectionUrl();
+            this.socket = new WebSocket(url);
+            //bind creates a new function permanently set to the object we pass, no matter how or where you call the function
+            // Now when WebSocket calls the function, 'this' refers to your WebSocketConnection instance
+            this.socket.onopen = this.handleOpen.bind(this);
+            this.socket.onmessage = this.handleSocketMessage.bind(this);
+            this.socket.onerror = this.handleError.bind(this);
+            this.socket.onclose = this.handleClose.bind(this);
+        }
+        catch (error) {
+            console.log("error from connect", error);
+            const connectionError = normalizeError(error, ConnectionError, "Failed to establish WebSocket connection", { context: { stage: "connect" } });
+            this.onErrorCallback?.(connectionError);
+            this.disconnect({
+                code: 1001,
+                reason: DisconnectionReason.CONNECTION_ERROR,
+                message: connectionError.message,
+                timestamp: new Date(),
+            });
+        }
+    }
+    /**
+     * Build WebSocket connection URL with session config
+     */
+    buildConnectionUrl() {
+        const url = new URL(this.config.serverUrl);
+        url.pathname = `/reloaded/ws/med-assist/session/${this.config.auth.sessionId}/`;
+        return url.toString();
+    }
+    /**
+     * Handle WebSocket open event
+     */
+    handleOpen() {
+        if (this.authenticated || this.socket?.readyState !== WebSocket.OPEN)
+            return;
+        this.onOpenCallback?.();
+    }
+    /**
+     * Handle incoming WebSocket messages
+     */
+    handleSocketMessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            this.handleMessage(data);
+        }
+        catch (error) {
+            const parseError = normalizeError(error, MessageError, "Failed to parse incoming WebSocket message", { context: { stage: "handleSocketMessage" } });
+            this.onErrorCallback?.(parseError);
+        }
+    }
+    /**
+     * Handle WebSocket errors
+     */
+    handleError(event) {
+        console.log("handleError", event);
+    }
+    /**
+     * Handle WebSocket close event
+     */
+    handleClose(event) {
+        const wasClean = event.wasClean;
+        const code = event.code;
+        const reason = event.reason;
+        let disconnectReason;
+        let message;
+        this.authenticated = false;
+        if (this.isConnected()) {
+            console.log("WebSocket is already connected, skipping reconnection");
+            return;
+        }
+        if (code === 1000) {
+            disconnectReason = DisconnectionReason.CLIENT_CLOSED;
+            message = "Connection closed normally";
+        }
+        else if (code === 1001 || code === 1006) {
+            disconnectReason = DisconnectionReason.NETWORK_ERROR;
+            message = event.reason || "Network connection lost";
+        }
+        else if (code === 4001 || code === 1008) {
+            if (event.reason === "timeout" || event.reason === "Authentication timeout") {
+                disconnectReason = DisconnectionReason.TIMEOUT;
+                message = "Connection timed out";
+            }
+            else {
+                disconnectReason = DisconnectionReason.AUTHENTICATION_ERROR;
+                message = event.reason || "Authentication failed";
+            }
+        }
+        else if (wasClean) {
+            disconnectReason = DisconnectionReason.SERVER_CLOSED;
+            message = reason || "Server closed connection";
+        }
+        else {
+            disconnectReason = DisconnectionReason.CONNECTION_ERROR;
+            message = reason || "Connection closed unexpectedly";
+        }
+        this.disconnect({
+            reason: disconnectReason,
+            message,
+            code,
+            timestamp: new Date(),
+        });
+    }
+    /**
+     * Send a message through the WebSocket
+     */
+    sendMessage(message) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new ConnectionError("Cannot send message: connection not open", {
+                context: {
+                    stage: "sendMessage",
+                    readyState: this.socket?.readyState,
+                },
+                hint: "Ensure the WebSocket is open before sending messages.",
+            });
+        }
+        try {
+            this.socket.send(JSON.stringify(message));
+        }
+        catch (error) {
+            const connectionError = normalizeError(error, ConnectionError, "Failed to send WebSocket message", { context: { stage: "sendMessage" } });
+            this.onErrorCallback?.(connectionError);
+            throw connectionError;
+        }
+    }
+    /**
+     * Close the WebSocket connection
+     */
+    close() {
+        this.authenticated = false;
+        if (this.socket) {
+            this.updateStatus(ConnectionStatus.NOT_CONNECTED);
+            this.socket.close(1000, "Client closed connection");
+            this.socket = null;
+        }
+    }
+    /**
+     * Check if the WebSocket is connected
+     */
+    isConnected() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    handleConnected() {
+        this.updateStatus(ConnectionStatus.CONNECTED);
+        this.authenticated = true;
+    }
+}

package/dist/esm/constants/index.js

@@ -0,0 +1,25 @@
+const PRODUCTION_CONFIG = {
+    WEBSOCKET_URL: "wss://matrix-ws.eka.care/reloaded",
+    BASE_API_URL: "https://matrix.eka.care/reloaded",
+};
+const DEVELOPMENT_CONFIG = {
+    // can be used for local development
+    WEBSOCKET_URL: "wss://matrix-ws.dev.eka.care/reloaded",
+    BASE_API_URL: "https://matrix.dev.eka.care/reloaded",
+};
+const STAGING_CONFIG = {
+    WEBSOCKET_URL: "wss://matrix-ws.dev.eka.care",
+    BASE_API_URL: "https://matrix.dev.eka.care",
+};
+export const getConfig = (environment = "production") => {
+    if (environment === "development") {
+        return DEVELOPMENT_CONFIG;
+    }
+    else if (environment === "production") {
+        return PRODUCTION_CONFIG;
+    }
+    else if (environment === "staging") {
+        return STAGING_CONFIG;
+    }
+    return PRODUCTION_CONFIG;
+};

package/dist/esm/constants/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/conversation.js

@@ -0,0 +1,7 @@
+export var SYNAPSE_CONVERSATION;
+(function (SYNAPSE_CONVERSATION) {
+    SYNAPSE_CONVERSATION["TEXT"] = "text";
+    SYNAPSE_CONVERSATION["FILE"] = "file";
+    SYNAPSE_CONVERSATION["AUDIO"] = "audio";
+    SYNAPSE_CONVERSATION["VOICE"] = "voice";
+})(SYNAPSE_CONVERSATION || (SYNAPSE_CONVERSATION = {}));

package/dist/esm/events/Events.js

@@ -0,0 +1,41 @@
+// Content types
+export const SOCKET_CONTENT_TYPES = {
+    TEXT: "text",
+    AUDIO: "audio",
+    FILE: "file",
+    TOOL_CALL: "tool",
+    TIPS: "tips",
+    AUDIO_TRANSCRIPT: "audio_transcript",
+    TOOL_START: "tool_start",
+    TOOL_END: "tool_end",
+};
+export const SOCKET_EVENTS = {
+    // Client to Server events
+    PING: "ping",
+    PONG: "pong",
+    CHAT: "chat",
+    STREAM: "stream",
+    AUTH: "auth",
+    END_OF_STREAM: "eos",
+    SYNC: "sync",
+    ERROR: "err",
+    // Server to Client events
+    CONNECTION_ESTABLISHED: "conn",
+};
+export const MULTI_SELECT_ADDITIONAL_OPTION = {
+    NOTA: "none_of_the_above",
+    AOTA: "all_of_the_above",
+};
+export function IsValidSocketMesssage(message) {
+    const validEvents = [
+        SOCKET_EVENTS.PING,
+        SOCKET_EVENTS.PONG,
+        SOCKET_EVENTS.ERROR,
+        SOCKET_EVENTS.SYNC,
+        SOCKET_EVENTS.CONNECTION_ESTABLISHED,
+        SOCKET_EVENTS.CHAT,
+        SOCKET_EVENTS.STREAM,
+        SOCKET_EVENTS.END_OF_STREAM,
+    ];
+    return validEvents.includes(message.ev);
+}

package/dist/esm/events/Incoming.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/events/Outgoing.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/events/index.js

@@ -0,0 +1,2 @@
+export * as Outgoing from "../events/Outgoing";
+export * as Incoming from "../events/Incoming";

package/dist/esm/events/types.js

@@ -0,0 +1,5 @@
+/**
+ * Event types for message layer
+ * These are specific to the messaging layer and don't affect the base connection layer
+ */
+export {};

package/dist/esm/index.js

@@ -0,0 +1,34 @@
+/**
+ * Synapse SDK - Main exports
+ * Medical Chatbot TypeScript SDK
+ */
+// High-level API (Primary interface for most users)
+export { SynapseSDK } from "./Synapse";
+// Connection layer (for advanced usage)
+export { BaseConnection } from "./internal/connection/BaseConnection";
+export { WebSocketConnection } from "./connection/Websocket";
+export { SSEConnection } from "./connection/SSE";
+export { ConnectionFactory, ConnectionType, } from "./connection/ConnectionFactory";
+export * from "./internal/connection/types";
+// Resources layer (for advanced usage)
+export { ResourceManager } from "./resources";
+export * from "./resources/types";
+export { Session } from "./resources/session/Session";
+export * from "./resources/session/types";
+export { ToolCall } from "./resources/toolCall/ToolCall";
+export * from "./resources/toolCall/types";
+// Message layer (for advanced usage)
+export { MessageManager } from "./messages/MessageManager";
+export * from "./messages/types";
+export * from "./events/types";
+// Core HTTP client (for advanced usage)
+export { HttpClient } from "./internal/Api/HttpClient";
+// Error handling
+export { SynapseError, APIError, APIUserAbortError, APIConnectionTimeoutError, BadRequestError, UnauthorizedError, PermissionDeniedError, NotFoundError, MethodNotAllowedError, RateLimitError, InternalServerError, SynapseErrorCode, } from "./internal/Error/Error";
+export { ErrorType } from "./internal/Error/types";
+// Utilities
+export { ErrorUtils } from "./utils/Error";
+export * from "./media/audio/types";
+export { SYNAPSE_MESSAGE_TYPES } from "./messages/types";
+export * from "./conversation";
+export * from "./voice";

package/dist/esm/internal/Api/BaseResource.js

@@ -0,0 +1,50 @@
+/**
+ * Base class for all resources
+ */
+export class BaseResource {
+    client;
+    constructor(httpClient) {
+        this.client = httpClient;
+    }
+    /**
+     * Helper method for making GET requests
+     */
+    async get(path, params, options) {
+        return this.client.get(path, params, options);
+    }
+    /**
+     * Helper method for making POST requests
+     */
+    async post(path, body, options) {
+        return this.client.post(path, body, options);
+    }
+    /**
+     * Helper method for making PUT requests
+     */
+    async put(path, body, options) {
+        return this.client.put(path, body, options);
+    }
+    /**
+     * Helper method for making DELETE requests
+     */
+    async delete(path, options) {
+        return this.client.delete(path, options);
+    }
+    /**
+     * Helper method for making PATCH requests
+     */
+    async patch(path, body, options) {
+        return this.client.patch(path, body, options);
+    }
+    /**
+     * Build a path with parameters
+     * Example: buildPath('/sessions/:id', { id: '123' }) => '/sessions/123'
+     */
+    buildPath(template, params) {
+        let path = template;
+        for (const [key, value] of Object.entries(params)) {
+            path = path.replace(`:${key}`, encodeURIComponent(value));
+        }
+        return path;
+    }
+}