@ctchealth/plato-sdk 0.0.8 → 0.0.9

package/src/lib/plato-intefaces.ts

@@ -0,0 +1,232 @@
+/**
+ * Copyright (c) 2025 ctcHealth. All rights reserved.
+ *
+ * This file is part of the ctcHealth Plato Platform, a proprietary software system developed by ctcHealth.
+ *
+ * This source code and all related materials are confidential and proprietary to ctcHealth.
+ * Unauthorized access, use, copying, modification, distribution, or disclosure is strictly prohibited
+ * and may result in disciplinary action and civil and/or criminal penalties.
+ *
+ * This software is intended solely for authorized use within ctcHealth and its designated partners.
+ *
+ * For internal use only.
+ */
+export enum YearOfExperience {
+  '1-5' = '1-5 years',
+  '6-10' = '6-10 years',
+  '11-20' = '16-20 years',
+  '20+' = '20+ years',
+}
+
+export enum PracticeType {
+  Private = 'Private Practice',
+  Hospital = 'Hospital',
+  AcademicMedicalCenter = 'Academic Medical Center',
+  Clinic = 'Clinic',
+}
+export enum SegmentType {
+  Traditionalist = 'The Traditionalist',
+  Innovator = 'The Innovator',
+  PatientOrientedPhysician = 'The Patient-Oriented Physician',
+  FinanciallyDrivenPrescriber = 'The Financially-Driven Prescriber',
+  EvidencePurist = 'The Evidence-Purist',
+  CostConsciousPrescriber = 'The Cost-Conscious Prescriber',
+}
+
+export enum AssistantVoiceGender {
+  Male = 'Male',
+  Female = 'Female',
+}
+
+export class PersonalityAndBehaviourDto {
+  riskTolerance!: number;
+  researchOrientation!: number;
+  recognitionNeed!: number;
+  brandLoyalty!: number;
+  patientEmpathy!: number;
+}
+
+export class ProfessionalProfileDto {
+  practiceSettings!: string;
+  yearOfExperience!: number;
+  specialityAndDepartment!: string;
+  location!: string;
+}
+
+export class ContextDto {
+  subSpecialityOrTherapyFocus!: string;
+  typicalPatientMix!: string;
+  keyClinicalDrivers!: string;
+}
+
+export class CharacterCreateDto {
+  name!: string;
+  professionalProfile!: ProfessionalProfileDto;
+  segment!: SegmentType;
+  personalityAndBehaviour!: PersonalityAndBehaviourDto;
+  context!: ContextDto;
+  assistantGender?: AssistantVoiceGender;
+}
+
+export class ProductConfig {
+  name!: string;
+  description!: string;
+}
+
+export class CreateSimulationDto {
+  persona!: CharacterCreateDto;
+  product!: ProductConfig;
+  presentation?: string;
+  scenario!: string;
+  objectives?: string[];
+  anticipatedObjections?: string[];
+}
+
+export type RecordingsLimit = 5 | 10 | 25;
+
+export class SimulationRecordingsQueryDto {
+  limit?: RecordingsLimit;
+  page?: number;
+  sort?: SortOrder;
+}
+
+export enum SortOrder {
+  ASC = 'asc',
+  DESC = 'desc',
+}
+
+export enum RecordingStatus {
+  STARTED = 'STARTED',
+  PROCESSING = 'PROCESSING',
+  FINISHED = 'FINISHED',
+  FAILED = 'FAILED',
+}
+
+export class SimulationRecordingsDto {
+  _id!: string;
+  createdAt!: Date;
+  recordingStatus?: RecordingStatus;
+}
+
+//
+export interface CallCreateDto {
+  /**
+   * Call ID obtained
+   */
+  callId: string;
+  /**
+   * Call Assistant ID
+   */
+  assistantId: string;
+}
+
+export interface CallDTO {
+  /**
+   * call ID
+   */
+  _id: string;
+  /**
+   *  call ID obtained
+   */
+  callId: string;
+  /**
+   *  call User ID
+   */
+  platoUserId: string;
+  /**
+   *  call Assistant ID
+   */
+  assistantId: string;
+  /**
+   *  call summary of the conversation
+   */
+  summary: string;
+  /**
+   *  call transcript of the conversation
+   */
+  transcript: string;
+  /**
+   *  call feedback provided by the user
+   */
+  feedback: string;
+  /**
+   * Success Evaluation returned by model
+   */
+  successEvaluation: boolean;
+  /**
+   *  call Recording URL
+   */
+  recordingUrl: string;
+  /**
+   * Status of recording processing (e.g., 'STARTED', 'PROCESSING', 'FINISHED', 'FAILED')
+   */
+  recordingStatus?: RecordingStatus;
+  /**
+   * Date and Time of the creation of the message
+   */
+  createdAt: Date;
+  /**
+   * Date and Time of the creation of the message
+   */
+  endedAt: Date;
+  /**
+   * Rating of the call given by the user
+   */
+  rating: number;
+  /**
+   * Main strenghts of the user conversation based on the analysis of the AI
+   */
+  strengths: Array<string>;
+  /**
+   * Main weak points of the user conversation based on the analysis of the AI
+   */
+  weaknesses: Array<string>;
+  /**
+   * Name of Metric for the AI feedback report
+   */
+  metric1: string;
+  /**
+   * Name of Metric for the AI feedback report
+   */
+  metric2: string;
+  /**
+   * Name of Metric for the AI feedback report
+   */
+  metric3: string;
+  /**
+   * AI feedback value for Metric 1
+   */
+  metric1Value: number;
+  /**
+   * AI feedback value for Metric 2
+   */
+  metric2Value: number;
+  /**
+   * AI feedback value for Metric 3
+   */
+  metric3Value: number;
+  /**
+   * AI feedback value for the call score
+   */
+  score?: number;
+  /**
+   * Defines if the calls will be consider for the memory feature
+   */
+  inMemory: boolean;
+}
+
+export enum CreationStatus {
+  CREATING = 'CREATING',
+  READY = 'READY',
+  ERROR = 'ERROR',
+}
+export enum CreationPhase {
+  STARTING = 'STARTING',
+  CORE = 'CORE',
+  BOUNDARIES = 'BOUNDARIES',
+  SPEECH_AND_THOUGHT = 'SPEECH_AND_THOUGHT',
+  CONVERSATION_EVOLUTION = 'CONVERSATION_EVOLUTION',
+  MEMORY = 'MEMORY',
+  FINISHED = 'FINISHED',
+  ERROR = 'ERROR',
+}

package/src/lib/plato-sdk.ts

@@ -0,0 +1,265 @@
+import axios, { AxiosInstance } from 'axios';
+import {
+  CallCreateDto,
+  CallDTO,
+  CreateSimulationDto,
+  CreationPhase,
+  SimulationRecordingsDto,
+  SimulationRecordingsQueryDto,
+} from './plato-intefaces';
+import Vapi from '@vapi-ai/web';
+import { Call } from '@vapi-ai/web/dist/api';
+
+export interface ApiClientConfig {
+  baseUrl: string;
+  token?: string;
+  user?: string;
+}
+
+/**
+ * Event map for call events, providing strict typing for each event's payload.
+ */
+export interface CallEventMap {
+  'call-start': void;
+  'call-end': void;
+  'speech-start': void;
+  'speech-end': void;
+  error: Error;
+  message: {
+    type: string;
+    role: string;
+    transcript?: string;
+    transcriptType: 'final' | 'partial';
+    toolCallList?: any[];
+    toolCalls?: any[];
+    [key: string]: any;
+  };
+  'volume-level': number;
+}
+
+export type CallEventNames = keyof CallEventMap;
+
+export type CallEventListener<K extends CallEventNames> = (payload: CallEventMap[K]) => void;
+
+export class PlatoApiClient {
+  private http: AxiosInstance;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  private eventListeners: Partial<Record<CallEventNames, Function[]>> = {};
+  private callControllerInstance?: Vapi;
+  private eventsAttached = false;
+  eventNames: CallEventNames[] = [
+    'call-start',
+    'call-end',
+    'speech-start',
+    'speech-end',
+    'error',
+    'message',
+    'volume-level',
+  ];
+
+  constructor(private config: ApiClientConfig) {
+    if (!config.baseUrl) {
+      throw new Error('baseUrl is required');
+    }
+    if (!config.token) {
+      throw new Error('token is required');
+    }
+    if (!config.user) {
+      throw new Error('user is required');
+    }
+
+    if (config.baseUrl.endsWith('/')) {
+      config.baseUrl = config.baseUrl.slice(0, -1);
+    }
+
+    this.http = axios.create({
+      baseURL: config.baseUrl,
+      headers: {
+        'x-api-key': config.token,
+        'x-api-key-user': config.user,
+      },
+    });
+  }
+
+  /**
+   * Register a listener for a call event with strict typing.
+   * @param event Event name
+   * @param listener Listener function
+   */
+  private on<K extends CallEventNames>(event: K, listener: CallEventListener<K>): void {
+    if (!this.eventListeners[event]) {
+      this.eventListeners[event] = [];
+    }
+    this.eventListeners[event]!.push(listener);
+    if (this.callControllerInstance && !this.eventsAttached) {
+      this.attachEvents();
+    }
+  }
+
+  /**
+   * Remove a listener for a call event with strict typing.
+   * @param event Event name
+   * @param listener Listener function
+   */
+  private off<K extends CallEventNames>(event: K, listener: CallEventListener<K>): void {
+    if (!this.eventListeners[event]) return;
+    this.eventListeners[event] = this.eventListeners[event]!.filter(l => l !== listener);
+  }
+
+  /**
+   * Internal: Attach event listeners and propagate to registered listeners.
+   */
+  private attachEvents(): void {
+    if (this.eventsAttached || !this.callControllerInstance) return;
+    this.eventsAttached = true;
+    const vapi = this.callControllerInstance;
+
+    this.eventNames.forEach(event => {
+      vapi.on(event, (payload: any) => {
+        (this.eventListeners[event] || []).forEach(listener => listener(payload));
+      });
+    });
+  }
+
+  async createSimulation(createSimulationParams: CreateSimulationDto): Promise<{
+    simulationId: string;
+    phase: CreationPhase;
+  }> {
+    try {
+      const res = await this.http.post('/api/v1/simulation', {
+        ...createSimulationParams,
+      });
+      return {
+        simulationId: res.data.simulationId,
+        phase: res.data.phase,
+      };
+    } catch (e) {
+      if (axios.isAxiosError(e)) {
+        console.error('Error creating simulation:', e.response?.data.message);
+      }
+      throw e;
+    }
+  }
+
+  async checkSimulationStatus(simulationId: string): Promise<{
+    phase: CreationPhase;
+  }> {
+    const res = await this.http.get(`/api/v1/simulation/status/${simulationId}`);
+
+    return res.data;
+  }
+
+  async getCallDetails(callId: string): Promise<CallDTO> {
+    try {
+      const res = await this.http.get(`/api/v1/simulation/call/${callId}`);
+      return res.data as CallDTO;
+    } catch (e) {
+      if (axios.isAxiosError(e)) {
+        console.error('Error getting call details:', e.response?.data.message);
+      }
+      throw e;
+    }
+  }
+
+  async getCallRecordings(
+    queryParams: SimulationRecordingsQueryDto
+  ): Promise<SimulationRecordingsDto[]> {
+    try {
+      const res = await this.http.get(`/api/v1/simulation/call/recordings`, {
+        params: queryParams,
+      });
+      return res.data as SimulationRecordingsDto[];
+    } catch (e) {
+      if (axios.isAxiosError(e)) {
+        console.error('Error getting call recordings:', e.response?.data.message);
+      }
+      throw e;
+    }
+  }
+
+  async getCallRecording(callId: string): Promise<string> {
+    try {
+      const res = await this.http.get(`/api/v1/simulation/call/recordings/${callId}`);
+      return res.data as string;
+    } catch (e) {
+      if (axios.isAxiosError(e)) {
+        console.error('Error getting call recording:', e.response?.data.message);
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Remove all listeners for all call events.
+   */
+  private removeAllEventListeners(): void {
+    if (!this.callControllerInstance) return;
+    this.eventNames.forEach(event => {
+      (this.eventListeners[event] || []).forEach(listener => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        this.callControllerInstance?.off(event, listener);
+      });
+      this.eventListeners[event] = [];
+    });
+    this.eventsAttached = false;
+  }
+
+  async startCall(simulationId: string) {
+    this.callControllerInstance = new Vapi(
+      'f07d17ec-d4e6-487d-a0b9-0539c01aecbb',
+      'https://db41aykk1gw9e.cloudfront.net' // base url
+    );
+    if (!this.eventsAttached) {
+      this.attachEvents();
+    }
+    const { data } = await this.http.get(`/api/v1/simulation/${simulationId}`);
+    const assistantId = data as string;
+    const call: Call | null = await this.callControllerInstance.start(assistantId);
+
+    if (!call || !call.assistantId) {
+      throw new Error('Cannot start a call, please try again later');
+    }
+    try {
+      const apiCall = await this.createCall({
+        callId: call.id,
+        assistantId: call.assistantId,
+      });
+
+      // Return stopCall, callId, and event subscription methods with strict typing
+      return {
+        stopCall: () => {
+          this.callControllerInstance?.stop();
+          this.removeAllEventListeners();
+        },
+        callId: apiCall._id,
+        /**
+         * Subscribe to call events for this call with strict typing.
+         * @param event Event name
+         * @param listener Listener function
+         */
+        on: <K extends CallEventNames>(event: K, listener: CallEventListener<K>) =>
+          this.on(event, listener),
+        /**
+         * Unsubscribe from call events for this call with strict typing.
+         * @param event Event name
+         * @param listener Listener function
+         */
+        off: <K extends CallEventNames>(event: K, listener: CallEventListener<K>) =>
+          this.off(event, listener),
+      };
+    } catch (e) {
+      this.callControllerInstance?.stop();
+      this.removeAllEventListeners();
+      throw e;
+    }
+  }
+
+  private async createCall(payload: CallCreateDto) {
+    const response = await this.http.post('/api/v1/simulation/call', {
+      ...payload,
+    });
+
+    return response.data as CallDTO;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"],
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/src/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/plato-sdk"), exports);
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/plato-sdk/src/index.ts"],"names":[],"mappings":";;;AAAA,0DAAgC"}