@eka-care/medassist-core 1.0.66 → 1.0.68

package/dist/esm/resources/feedback/types.js

@@ -0,0 +1,7 @@
+"use strict";
+// export type FeedbackRequest = {
+//   messageId: string;
+//   sessionId: string;
+//   feedback: USER_FEEDBACK;
+//   feedbackReason?: string;
+// }

package/dist/esm/resources/index.js

@@ -0,0 +1,152 @@
+/**
+ * Init class to fetch agent configuration from the platform
+ */
+import { HttpClient } from "../internal/Api/HttpClient";
+import { Session } from "./session/Session";
+import { APIError } from "../internal/Error/Error";
+import { Config } from "./config/Config";
+import { VoiceResource } from "./voice/VoiceResource";
+export class ResourceManager {
+    resourceConfig;
+    httpClient;
+    session;
+    config;
+    voiceResource;
+    constructor(config) {
+        this.resourceConfig = config;
+        // Set up HTTP client with agentId header for all requests
+        this.httpClient = new HttpClient({
+            baseUrl: this.resourceConfig.serverUrl,
+            headers: {
+                "X-agent-id": this.resourceConfig.agentId, // This will be included in ALL requests
+                "ngrok-skip-browser-warning": "69420",
+                ...(this.resourceConfig.authorization && { Authorization: this.resourceConfig.authorization }),
+            },
+            // authorization: config.authorization,
+        });
+        this.config = new Config(this.httpClient);
+        this.session = new Session(this.httpClient);
+        this.voiceResource = new VoiceResource(this.httpClient);
+    }
+    /**
+     * Fetch agent configuration and create session
+     */
+    async createSession(userId, context) {
+        try {
+            // Use SessionsResource to start a session
+            // The X-agent-id header is automatically included from httpClient config
+            const { profile, intent, user_location, referer, ...extraContext } = context || {};
+            const sessionRequest = {
+                ...(userId && { user_id: userId }),
+                ...(profile && { user_context: profile }),
+                ...((intent || Object.keys(extraContext).length > 0) && {
+                    session_context: {
+                        ...(intent && { intent }),
+                        ...(user_location && { user_location }),
+                        ...extraContext, // Include any extra properties from context
+                    }
+                }),
+                ...(referer && { referer }),
+            };
+            const sessionData = await this.session.create(sessionRequest, this.resourceConfig.authToken);
+            if (!sessionData?.session_id || !sessionData?.session_token) {
+                throw new APIError("Failed to start session.", 500, undefined, undefined);
+            }
+            return sessionData;
+        }
+        catch (error) {
+            if (error instanceof APIError) {
+                throw error;
+            }
+            throw new APIError("Failed to start session.", 500, undefined, undefined);
+        }
+    }
+    async getAgentConfig() {
+        if (!this.config) {
+            this.config = new Config(this.httpClient);
+        }
+        try {
+            return await this.config.retrieve(this.resourceConfig.agentId);
+        }
+        catch (error) {
+            throw new APIError("Failed to get agent config.", 500, undefined, undefined);
+        }
+    }
+    /**
+     * Validate a session if it's still active or not
+     * GET /med-assist/session/:sessionId
+     */
+    async validateSession(sessionId) {
+        try {
+            const sessionData = await this.session.retrieve(sessionId);
+            if (sessionData.msg && sessionData.msg === "Session Active") {
+                return {
+                    expired: false,
+                    active: true,
+                };
+            }
+            return {
+                expired: true,
+                active: false,
+            };
+        }
+        catch (error) {
+            if (error instanceof APIError) {
+                switch (error.status) {
+                    // case 404:
+                    //   return {
+                    //     expired: false,
+                    //     active: false,
+                    //   };
+                    // case 500:
+                    //   return {
+                    //     expired: false,
+                    //     active: false,
+                    //   };
+                    case 401:
+                        // if (!!error.error?.msg) {
+                        //   return {
+                        //     expired: true,
+                        //     active: false,
+                        //   };
+                        // }
+                        // throw new APIError(error.error?.msg || "Failed to authenticate user", 401, undefined, undefined);
+                        return {
+                            expired: true,
+                            active: false,
+                        };
+                    default:
+                        throw error;
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Refresh a session
+     * POST /med-assist/session/:sessionId/refresh
+     */
+    async refreshSession(sessionId, sessionToken) {
+        return await this.session.refresh(sessionId, sessionToken);
+    }
+    /**
+     * Feedback on a message
+     * PATCH /med-assist/session/:sessionId/:messageId
+     */
+    async sendFeedback(sessionId, messageId, feedback, feedbackReason) {
+        return await this.session.feedback(sessionId, messageId, feedback, feedbackReason);
+    }
+    /**
+     * Call a tool
+     * POST /med-assist/api-call-tool
+     */
+    async callTool(sessionId, toolId, message_id, session_token, toolParams) {
+        return await this.session.callTool(sessionId, toolId, message_id, session_token, toolParams);
+    }
+    async getVoiceIceServers(sessionId, sessionToken) {
+        return await this.voiceResource.getIceServers(sessionId, sessionToken);
+    }
+    async sendVoiceOffer(body) {
+        return await this.voiceResource.sendOffer(body);
+    }
+}

package/dist/esm/resources/session/Session.js

@@ -0,0 +1,44 @@
+import { BaseResource } from "../../internal/Api/BaseResource";
+/**
+ * SessionsResource class for managing sessions-related api calls
+ */
+export class Session extends BaseResource {
+    //Ts implicitly calls super() here
+    /**
+     * create a new session
+     * POST /med-assist/session
+     */
+    basePath = "/med-assist/session";
+    async create(sessionRequest, authToken) {
+        return this.post(this.basePath, sessionRequest, authToken
+            ? { headers: { "x-auth-token": authToken } }
+            : undefined);
+    }
+    async retrieve(sessionId) {
+        return this.get(`${this.basePath}/${sessionId}`);
+    }
+    /**
+     * refresh a session
+     * POST /med-assist/session/refresh
+     */
+    async refresh(sessionId, sessionToken) {
+        return this.get(`${this.basePath}/${sessionId}/refresh`, undefined, {
+            headers: {
+                "x-sess-token": sessionToken,
+            },
+        });
+    }
+    async feedback(sessionId, messageId, feedback, feedback_reason) {
+        return this.put(`${this.basePath}/${sessionId}/messages/${messageId}/feedback`, {
+            feedback,
+            feedback_reason,
+        });
+    }
+    async callTool(sessionId, toolId, messageId, sessionToken, toolParams) {
+        return this.post(`${this.basePath}/${sessionId}/messages/${messageId}/tools/${toolId}`, { tool_params: toolParams }, {
+            headers: {
+                "x-sess-token": sessionToken,
+            },
+        });
+    }
+}

package/dist/esm/resources/session/types.js

@@ -0,0 +1,5 @@
+export const USER_FEEDBACK = {
+    LIKE: "LIKE",
+    DISLIKE: "DISLIKE",
+    NONE: "NONE",
+};

package/dist/esm/resources/toolCall/ToolCall.js

@@ -0,0 +1,12 @@
+import { BaseResource } from "../../internal/Api/BaseResource";
+export class ToolCall extends BaseResource {
+    basePath = "/med-assist/api-call-tool";
+    async callTool(sessionId, toolName, toolParams) {
+        // if (toolName === SYNAPSE_TOOL_NAME.GET_LOCATION) {
+        //   return this.requestLocation() as Promise<R>;
+        // }
+        return this.post(`${this.basePath}?session_id=${sessionId}&tool_name=${toolName}`, {
+            tool_params: toolParams,
+        });
+    }
+}

package/dist/esm/resources/toolCall/types.js

@@ -0,0 +1,34 @@
+export var SYNAPSE_TOOL_NAME;
+(function (SYNAPSE_TOOL_NAME) {
+    SYNAPSE_TOOL_NAME["MOBILE_VERIFICATION"] = "mobile_verification";
+    SYNAPSE_TOOL_NAME["AVAILABILITY_DATES"] = "availability_dates";
+    SYNAPSE_TOOL_NAME["AVAILABILITY_SLOTS"] = "availability_slots";
+    SYNAPSE_TOOL_NAME["DOCTOR_AVAILABILITY"] = "doctor_availability";
+    SYNAPSE_TOOL_NAME["DOCTOR_DETAILS"] = "doctor_details";
+    SYNAPSE_TOOL_NAME["GET_LOCATION"] = "get_location";
+})(SYNAPSE_TOOL_NAME || (SYNAPSE_TOOL_NAME = {}));
+export var SYNAPSE_COMPONENTS;
+(function (SYNAPSE_COMPONENTS) {
+    SYNAPSE_COMPONENTS["MOBILE"] = "mobile_number";
+    SYNAPSE_COMPONENTS["OTP"] = "otp";
+    SYNAPSE_COMPONENTS["EMAIL"] = "email_address";
+    SYNAPSE_COMPONENTS["PILL"] = "pills";
+    SYNAPSE_COMPONENTS["MULTI"] = "multi";
+    SYNAPSE_COMPONENTS["DOCTOR_CARD"] = "doctor_card";
+    SYNAPSE_COMPONENTS["CARD"] = "card";
+    SYNAPSE_COMPONENTS["MEDIA_CARD"] = "media_card";
+})(SYNAPSE_COMPONENTS || (SYNAPSE_COMPONENTS = {}));
+export var SYNAPSE_TOOL_CALLBACK_NAME;
+(function (SYNAPSE_TOOL_CALLBACK_NAME) {
+    SYNAPSE_TOOL_CALLBACK_NAME["DOCTOR_AVAILABILITY"] = "get_doctor_availability";
+    SYNAPSE_TOOL_CALLBACK_NAME["AVAILABILITY_DATES"] = "get_available_dates";
+    SYNAPSE_TOOL_CALLBACK_NAME["AVAILABILITY_SLOTS"] = "get_available_slots";
+    SYNAPSE_TOOL_CALLBACK_NAME["MOBILE_VERIFICATION"] = "verify_mobile_number";
+    SYNAPSE_TOOL_CALLBACK_NAME["DOCTOR_DETAILS"] = "get_doctor_details";
+})(SYNAPSE_TOOL_CALLBACK_NAME || (SYNAPSE_TOOL_CALLBACK_NAME = {}));
+export var SYNAPSE_EICITATION_STATUS;
+(function (SYNAPSE_EICITATION_STATUS) {
+    SYNAPSE_EICITATION_STATUS["PROGRESS"] = "progress";
+    SYNAPSE_EICITATION_STATUS["SUCCESS"] = "success";
+    SYNAPSE_EICITATION_STATUS["FAILURE"] = "failure";
+})(SYNAPSE_EICITATION_STATUS || (SYNAPSE_EICITATION_STATUS = {}));

package/dist/esm/resources/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for agent configuration initialization
+ */
+export {};

package/dist/esm/resources/voice/VoiceResource.js

@@ -0,0 +1,14 @@
+import { BaseResource } from "../../internal/Api/BaseResource";
+export class VoiceResource extends BaseResource {
+    static ICE_SERVERS_PATH = "/med-assist/voice/ice-servers";
+    static OFFER_PATH = "/med-assist/voice/offer";
+    async getIceServers(sessionId, sessionToken) {
+        return this.get(VoiceResource.ICE_SERVERS_PATH, {
+            session_id: sessionId,
+            token: sessionToken,
+        });
+    }
+    async sendOffer(body) {
+        return this.post(VoiceResource.OFFER_PATH, body);
+    }
+}

package/dist/esm/resources/voice/types.js

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

package/dist/esm/types/index.js

@@ -0,0 +1,8 @@
+/**
+ * Shared types across the SDK
+ */
+// Re-export common types from other modules
+export * from '../internal/connection/types';
+export * from '../internal/Error/types';
+export * from '../messages/types';
+export * from '../resources/session/types';

package/dist/esm/utils/Error.js

@@ -0,0 +1,110 @@
+import { APIConnectionTimeoutError, APIError, PermissionDeniedError, SynapseError, UnauthorizedError, } from "../internal/Error/Error";
+// Utility functions for error handling
+export class ErrorUtils {
+    /**
+     * Check if an error is a specific API error type
+     */
+    static isAPIError(error) {
+        return error instanceof APIError;
+    }
+    /**
+     * Check if an error is a network-related error
+     */
+    static isNetworkError(error) {
+        return (error instanceof APIError &&
+            (error.status === 0 || error.status === undefined));
+    }
+    /**
+     * Check if an error is a timeout error
+     */
+    static isTimeoutError(error) {
+        return error instanceof APIConnectionTimeoutError;
+    }
+    /**
+     * Check if an error is an authentication error
+     */
+    static isAuthError(error) {
+        return (error instanceof UnauthorizedError ||
+            error instanceof PermissionDeniedError);
+    }
+    /**
+     * Check if an error is a client error (4xx)
+     */
+    static isClientError(error) {
+        return (error instanceof APIError &&
+            error.status !== undefined &&
+            error.status >= 400 &&
+            error.status < 500);
+    }
+    /**
+     * Check if an error is a server error (5xx)
+     */
+    static isServerError(error) {
+        return (error instanceof APIError &&
+            error.status !== undefined &&
+            error.status >= 500);
+    }
+    /**
+     * Get user-friendly error message
+     */
+    static getUserFriendlyMessage(error) {
+        if (ErrorUtils.isNetworkError(error)) {
+            return "Unable to connect to the server. Please check your internet connection.";
+        }
+        if (ErrorUtils.isTimeoutError(error)) {
+            return "Request timed out. Please try again.";
+        }
+        if (ErrorUtils.isAuthError(error)) {
+            return "Authentication failed. Please log in again.";
+        }
+        if (ErrorUtils.isServerError(error)) {
+            return "Server error occurred. Please try again later.";
+        }
+        if (ErrorUtils.isAPIError(error)) {
+            return error.message;
+        }
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return "An unexpected error occurred.";
+    }
+    /**
+     * Extract error details for logging
+     */
+    static getErrorDetails(error) {
+        if (ErrorUtils.isAPIError(error)) {
+            return {
+                type: error.name,
+                message: error.message,
+                code: error.code,
+                status: error.status,
+                timestamp: error.timestamp,
+                stack: error.stack,
+                context: error.context,
+                hint: error.hint,
+            };
+        }
+        if (error instanceof SynapseError) {
+            return {
+                type: error.name,
+                message: error.message,
+                code: error.code,
+                timestamp: error.timestamp,
+                stack: error.stack,
+                context: error.context,
+                hint: error.hint,
+            };
+        }
+        if (error instanceof Error) {
+            return {
+                type: error.name,
+                message: error.message,
+                stack: error.stack,
+            };
+        }
+        return {
+            type: "Unknown",
+            message: String(error),
+        };
+    }
+}