From b70f7bdc9bbf586dde3c61b1e683d5dc8e7afbfa Mon Sep 17 00:00:00 2001
From: rsarika <95286093+rsarika@users.noreply.github.com>
Date: Wed, 13 Nov 2024 08:03:05 +0530
Subject: [PATCH] feat(cc): copy Agent req from agentx Desktop (#3955)

Co-authored-by: Priya <pkesari@cisco.com>
Co-authored-by: parv_gour <parv_gour@PAGOUR-M-D8B2>
Co-authored-by: pagour98 <pagour@cisco.com>
Co-authored-by: arungane <arungane@cisco.com>
Co-authored-by: Bharath Balan <62698609+bhabalan@users.noreply.github.com>
Co-authored-by: Adhwaith Menon <111346225+adhmenon@users.noreply.github.com>
Co-authored-by: adhmenon <adhmenon@cisco.com>
---
 docs/samples/contact-center/app.js            | 137 ++-
 docs/samples/contact-center/index.html        |  59 +-
 docs/samples/contact-center/style.css         | 894 +++++++++---------
 .../@webex/plugin-cc/__mocks__/workerMock.js  |  15 +
 packages/@webex/plugin-cc/package.json        |   4 +-
 .../@webex/plugin-cc/src/AgentConfig/types.ts |  87 --
 .../plugin-cc/src/AgentConfigService/types.ts | 140 ---
 packages/@webex/plugin-cc/src/HttpRequest.ts  |  50 -
 .../plugin-cc/src/WebSocket/WebSocket.ts      | 139 ---
 packages/@webex/plugin-cc/src/cc.ts           | 275 ++++--
 packages/@webex/plugin-cc/src/config.ts       |  12 +
 packages/@webex/plugin-cc/src/constants.ts    |   6 +-
 .../Agentconfig.ts}                           |  23 +-
 .../{AgentConfig => features}/constants.ts    |   0
 .../@webex/plugin-cc/src/features/types.ts    |  35 +
 packages/@webex/plugin-cc/src/logger-proxy.ts |   9 +
 .../src/services/WebCallingService.ts         |  63 ++
 .../src/{ => services}/WebSocket/config.ts    |   0
 .../plugin-cc/src/services/WebSocket/index.ts |  70 ++
 .../src/{ => services}/WebSocket/types.ts     |  17 +-
 .../plugin-cc/src/services/agent/index.ts     | 125 +++
 .../plugin-cc/src/services/agent/types.ts     | 147 +++
 .../config/index.ts}                          |  49 +-
 .../plugin-cc/src/services/config/types.ts    | 127 +++
 .../plugin-cc/src/services/constants.ts       |   9 +
 .../@webex/plugin-cc/src/services/core/Err.ts |  97 ++
 .../src/services/core/GlobalTypes.ts          |  14 +
 .../src/services/core/HttpRequest.ts          |  37 +
 .../plugin-cc/src/services/core/Utils.ts      |  24 +
 .../core/WebSocket/WebSocketManager.ts        | 170 ++++
 .../core/WebSocket/connection-service.ts      | 144 +++
 .../core/WebSocket/keepalive.worker.js        |  88 ++
 .../plugin-cc/src/services/core/aqm-reqs.ts   | 248 +++++
 .../plugin-cc/src/services/core/constants.ts  |  11 +
 .../plugin-cc/src/services/core/types.ts      |  48 +
 .../@webex/plugin-cc/src/services/index.ts    |  21 +
 packages/@webex/plugin-cc/src/types.ts        | 233 ++++-
 .../test/unit/spec/AgentConfig/AgentConfig.ts | 344 -------
 .../AgentConfigService/AgentConfigService.ts  | 211 -----
 .../plugin-cc/test/unit/spec/HttpRequest.ts   |  63 --
 .../plugin-cc/test/unit/spec/WebSocket.ts     | 195 ----
 .../@webex/plugin-cc/test/unit/spec/cc.ts     | 649 +++++++------
 .../test/unit/spec/features/AgentConfig.ts    | 463 +++++++++
 .../unit/spec/services/WebCallingService.ts   | 147 +++
 .../test/unit/spec/services/agent/index.ts    |  60 ++
 .../test/unit/spec/services/config/index.ts   | 252 +++++
 .../unit/spec/services/core/HttpRequest.ts    |  67 ++
 .../core/WebSocket/WebSocketManager.ts        | 372 ++++++++
 .../core/WebSocket/connection-service.ts      | 164 ++++
 .../test/unit/spec/services/core/aqm-reqs.ts  | 569 +++++++++++
 packages/calling/src/index.ts                 |   1 +
 packages/webex/test/unit/spec/webex.js        |  12 +
 52 files changed, 5024 insertions(+), 2172 deletions(-)
 create mode 100644 packages/@webex/plugin-cc/__mocks__/workerMock.js
 delete mode 100644 packages/@webex/plugin-cc/src/AgentConfig/types.ts
 delete mode 100644 packages/@webex/plugin-cc/src/AgentConfigService/types.ts
 delete mode 100644 packages/@webex/plugin-cc/src/HttpRequest.ts
 delete mode 100644 packages/@webex/plugin-cc/src/WebSocket/WebSocket.ts
 rename packages/@webex/plugin-cc/src/{AgentConfig/AgentConfig.ts => features/Agentconfig.ts} (86%)
 rename packages/@webex/plugin-cc/src/{AgentConfig => features}/constants.ts (100%)
 create mode 100644 packages/@webex/plugin-cc/src/features/types.ts
 create mode 100644 packages/@webex/plugin-cc/src/logger-proxy.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/WebCallingService.ts
 rename packages/@webex/plugin-cc/src/{ => services}/WebSocket/config.ts (100%)
 create mode 100644 packages/@webex/plugin-cc/src/services/WebSocket/index.ts
 rename packages/@webex/plugin-cc/src/{ => services}/WebSocket/types.ts (65%)
 create mode 100644 packages/@webex/plugin-cc/src/services/agent/index.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/agent/types.ts
 rename packages/@webex/plugin-cc/src/{AgentConfigService/AgentConfigService.ts => services/config/index.ts} (73%)
 create mode 100644 packages/@webex/plugin-cc/src/services/config/types.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/constants.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/Err.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/GlobalTypes.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/HttpRequest.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/Utils.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/WebSocket/WebSocketManager.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/WebSocket/connection-service.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/WebSocket/keepalive.worker.js
 create mode 100644 packages/@webex/plugin-cc/src/services/core/aqm-reqs.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/constants.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/core/types.ts
 create mode 100644 packages/@webex/plugin-cc/src/services/index.ts
 delete mode 100644 packages/@webex/plugin-cc/test/unit/spec/AgentConfig/AgentConfig.ts
 delete mode 100644 packages/@webex/plugin-cc/test/unit/spec/AgentConfigService/AgentConfigService.ts
 delete mode 100644 packages/@webex/plugin-cc/test/unit/spec/HttpRequest.ts
 delete mode 100644 packages/@webex/plugin-cc/test/unit/spec/WebSocket.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/features/AgentConfig.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/services/WebCallingService.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/services/agent/index.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/services/config/index.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/services/core/HttpRequest.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/WebSocketManager.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/connection-service.ts
 create mode 100644 packages/@webex/plugin-cc/test/unit/spec/services/core/aqm-reqs.ts

diff --git a/docs/samples/contact-center/app.js b/docs/samples/contact-center/app.js
index ce36776bd36..4144f3ac6f2 100644
--- a/docs/samples/contact-center/app.js
+++ b/docs/samples/contact-center/app.js
@@ -22,19 +22,25 @@ const tokenElm = document.querySelector('#access-token');
 const saveElm = document.querySelector('#access-token-save');
 const authStatusElm = document.querySelector('#access-token-status');
 const registerBtn = document.querySelector('#webexcc-register');
-
-
-// Store and Grab `access-token` from localstorage
-if (localStorage.getItem('date') > new Date().getTime()) {
-  tokenElm.value = localStorage.getItem('access-token');
+const teamsDropdown = document.querySelector('#teamsDropdown');
+const agentLogin = document.querySelector('#AgentLogin');
+const agentLoginButton = document.querySelector('#loginAgent');
+const dialNumber = document.querySelector('#dialNumber');
+const registerStatus = document.querySelector('#ws-connection-status');
+const logoutAgentElm = document.querySelector('#logoutAgent');
+const buddyAgentsDropdownElm = document.getElementById('buddyAgentsDropdown');
+
+// Store and Grab `access-token` from sessionStorage
+if (sessionStorage.getItem('date') > new Date().getTime()) {
+  tokenElm.value = sessionStorage.getItem('access-token');
 }
 else {
-  localStorage.removeItem('access-token');
+  sessionStorage.removeItem('access-token');
 }
 
 tokenElm.addEventListener('change', (event) => {
-  localStorage.setItem('access-token', event.target.value);
-  localStorage.setItem('date', new Date().getTime() + (12 * 60 * 60 * 1000));
+  sessionStorage.setItem('access-token', event.target.value);
+  sessionStorage.setItem('date', new Date().getTime() + (12 * 60 * 60 * 1000));
 });
 
 function changeAuthType() {
@@ -94,7 +100,7 @@ function initWebex(e) {
     console.log('Authentication#initWebex() :: Webex Ready');
 
     authStatusElm.innerText = 'Saved access token!';
-
+    registerStatus.innerHTML = 'Not Subscribed';
     registerBtn.disabled = false;
   });
 
@@ -103,14 +109,115 @@ function initWebex(e) {
 
 credentialsFormElm.addEventListener('submit', initWebex);
 
+
 function register() {
-    webex.cc.register().then((data) => {
-        console.log('Event subscription successful: ', data);
-    }).catch(() => {
-        console.log('Event subscription failed');
+    webex.cc.register(true).then((agentProfile) => {
+        registerStatus.innerHTML = 'Subscribed';
+        console.log('Event subscription successful: ', agentProfile);
+        teamsDropdown.innerHTML = ''; // Clear previously selected option on teamsDropdown
+        const listTeams = agentProfile.teams;
+        listTeams.forEach((team) => {
+            const option = document.createElement('option');
+            option.value = team.id;
+            option.text = team.name;
+            teamsDropdown.add(option);
+        });
+        const loginVoiceOptions = agentProfile.loginVoiceOptions;
+        agentLogin.innerHTML = '<option value="" selected>Choose Agent Login ...</option>'; // Clear previously selected option on agentLogin.
+        dialNumber.value = '';
+        dialNumber.disabled = true;
+        if(loginVoiceOptions.length > 0) agentLoginButton.disabled = false;
+        loginVoiceOptions.forEach((voiceOptions)=> {
+          const option = document.createElement('option');
+          option.text = voiceOptions;
+          option.value = voiceOptions;
+          agentLogin.add(option);
+        });
+    }).catch((error) => {
+        console.log('Event subscription failed', error);
     })
 }
 
+async function handleAgentLogin(e) {
+  const value = e.target.value;
+  agentDeviceType = value
+  if (value === 'AGENT_DN') {
+    dialNumber.disabled = false;
+  } else if (value === 'EXTENSION') {
+    dialNumber.disabled = false;
+  } else {
+    dialNumber.disabled = true;
+  }
+}
+
+function doAgentLogin() {
+  webex.cc.stationLogin({teamId: teamsDropdown.value, loginOption: agentDeviceType, dialNumber: dialNumber.value}).then((response) => {
+    console.log('Agent Logged in successfully', response);
+    logoutAgentElm.classList.remove('hidden');
+    // Re-Login Agent after 15 seconds for testing purpose
+    setTimeout(async () => {
+      try {
+        const response = await webex.cc.stationReLogin();
+
+        console.log('Agent Re-Login successful', response);
+      } catch (error) {
+        console.log('Agent Re-Login failed', error);
+      }
+    }, 15000);
+  }
+  ).catch((error) => {
+    if (error.message === 'AGENT_SESSION_ALREADY_EXISTS') {
+      logoutAgentElm.classList.remove('hidden');
+    }
+    console.log('Agent Login failed', error);
+  });
+}
+
+
+function logoutAgent() {
+  webex.cc.stationLogout({logoutReason: 'logout'}).then((response) => {
+    console.log('Agent logged out successfully', response);
+
+    setTimeout(() => {
+      logoutAgentElm.classList.add('hidden');
+    }, 1000);
+  }
+  ).catch((error) => {
+    console.log('Agent logout failed', error);
+  });
+}
+
+async function fetchBuddyAgents() {
+  try {
+    buddyAgentsDropdownElm.innerHTML = ''; // Clear previous options
+    const buddyAgentsResponse = await webex.cc.getBuddyAgents({mediaType: 'telephony'});
+
+    if (!buddyAgentsResponse || !buddyAgentsResponse.data) {
+      console.error('Failed to fetch buddy agents');
+      buddyAgentsDropdownElm.innerHTML = `<option disabled="true">Failed to fetch buddy agents<option>`;
+      return;
+    }
+
+    if (buddyAgentsResponse.data.agentList.length === 0) {
+      console.log('The fetched buddy agents list was empty');
+      buddyAgentsDropdownElm.innerHTML = `<option disabled="true">No buddy agents available<option>`;
+      return;
+    }
+
+    buddyAgentsResponse.data.agentList.forEach((agent) => {
+      const option = document.createElement('option');
+      option.text = `${agent.agentName} - ${agent.state}`;
+      option.value = agent.agentId;
+      buddyAgentsDropdownElm.add(option);
+    });
+
+  } catch (error) {
+    console.error('Failed to fetch buddy agents', error);
+    buddyAgentsDropdownElm.innerHTML = ''; // Clear previous options
+    buddyAgentsDropdownElm.innerHTML = `<option disabled="true">Failed to fetch buddy agents, ${error}<option>`;
+  }
+}
+
 const allCollapsibleElements = document.querySelectorAll('.collapsible');
 allCollapsibleElements.forEach((el) => {
   el.addEventListener('click', (event) => {
@@ -139,8 +246,8 @@ if (window.location.hash) {
   const expiresIn = urlParams.get('expires_in');
 
   if (accessToken) {
-    localStorage.setItem('access-token', accessToken);
-    localStorage.setItem('date', new Date().getTime() + parseInt(expiresIn, 10));
+    sessionStorage.setItem('access-token', accessToken);
+    sessionStorage.setItem('date', new Date().getTime() + parseInt(expiresIn, 10));
     tokenElm.value = accessToken;
   }
 }
diff --git a/docs/samples/contact-center/index.html b/docs/samples/contact-center/index.html
index 77b0b594a18..97be88b448d 100644
--- a/docs/samples/contact-center/index.html
+++ b/docs/samples/contact-center/index.html
@@ -80,24 +80,57 @@ <h2 class="collapsible">
             </div>
           </fieldset>
         </form>
-      </div>   
+      </div>
   </div>
   </section>
   </div>
 
-  <div class="box">
-    <section class="section-box">
-      <h2 class="collapsible">
-        Agent Desktop Using Webex CC SDK
-        <i class="arrow fa fa-angle-down" aria-hidden="true"></i>
-      </h2>
+    <div class="box">
+      <section class="section-box">
+        <h2 class="collapsible">
+          Agent Station Login/Logout
+          <i class="arrow fa fa-angle-down" aria-hidden="true"></i>
+        </h2>
 
-      <div class="section-content">
+        <div class="section-content">
+          <fieldset>
+            <legend>Agent</legend>
+            <p class="note">
+              NOTE: Teams are fetched automatically for the Agent Login.
+            </p>
+            <div class="screenshare-section">
+              <div style="display: flex; gap: 1rem;">
+                <fieldset style="flex: 0.69;">
+                  <legend>Select Team</legend>
+                  <select id="teamsDropdown" class="form-control w-auto my-3">Teams</select>
+                </fieldset>
+                <fieldset>
+                  <legend>Agent Login</legend>
+                  <select name="AgentLogin" id="AgentLogin" class="AgentLogin" onchange="handleAgentLogin(event)">
+                    <option value="" selected hidden>Choose Agent Login ...</option>
+                  </select>
+                  <input id="dialNumber" name="dialNumber" placeholder="Dial Number" value="" type="text">
+                  <button id="loginAgent" disabled class="btn btn-primary my-3" onclick="doAgentLogin()">Login With
+                    Selected Team</button>
+                  <button id="logoutAgent" class="btn btn-primary my-3 ml-2 hidden" onclick="logoutAgent()">Logout Agent</button>
+                </fieldset>
+                <fieldset>
+                  <legend>Agent status</legend>
+                  <select id="statusDropdown" class="form-control w-auto my-3"></select>
+                  <button id="setAgentStatus" class="btn btn-primary my-3 ml-2" onclick="setAgentStatus()">set
+                    sate</button>
+                </fieldset>
+              </div>
+              <fieldset id="buddyAgentsBox">
+                <legend>Buddy Agents</legend>
+                <button id="fetchBuddyAgents" class="btn btn-primary my-3" onclick="fetchBuddyAgents()">Get Buddy Agents</button>
+                <select id="buddyAgentsDropdown" class="form-control w-auto my-3"></select>
+              </fieldset>
             </div>
-          </div>
-        </fieldset>
-      </div>
-    </section>
+          </fieldset>
+        </div>
+      </section>
+    </div>
   </div>
 
   <script src="../webex.min.js"></script>
@@ -105,4 +138,4 @@ <h2 class="collapsible">
   <script src="app.js"></script>
 </body>
 
-</html>
\ No newline at end of file
+</html>
diff --git a/docs/samples/contact-center/style.css b/docs/samples/contact-center/style.css
index 26bd7730a40..adb172f8cb3 100644
--- a/docs/samples/contact-center/style.css
+++ b/docs/samples/contact-center/style.css
@@ -1,448 +1,448 @@
 :root {
-    --video-grid-max-width: 100%;
-  }
-  
-  body {
-    max-width: 100%;
-    margin: 1rem;
-    padding: 0;
-    background: #eeeeee;
-  }
-  
-  button.btn--green {
-    color: #fff;
-    color: var(--md-button-join-text-color, #fff);
-    background-color: #00ab50;
-    background-color: var(--md-button-join-bg-color, #00ab50);
-    border-color: transparent;
-  }
-  
-  button.btn--green:disabled {
-    opacity: 0.5;
-  }
-  
-  button.btn--red {
-    color: #fff;
-    color: var(--md-button-cancel-text-color, #fff);
-    background-color: #f7644a;
-    background-color: var(--md-button-cancel-bg-color, #f7644a);
-    border-color: transparent;
-  }
-  
-  .btn--red:disabled,
-  .btn--green:disabled {
-    opacity: 0.5;
-  }
-  
-  button.btn-code {
-    font-family: Consolas, Liberation Mono, Courier, monospace;
-  }
-  
-  .container {
-    display: flex;
-    width: 100%;
-    flex-direction: row;
-    justify-content: space-between;
-    margin-bottom: 1rem;
-  }
-  
-  .column {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-    width: 100%;
-  }
-  
-  .box {
-    max-width: 70rem; 
-    margin-inline: auto;
-    margin-bottom: 1rem;
-  }
-  
-  .section-box {
-    background: #ffffff;
-    border-radius: 1rem;
-    padding: 0rem 1rem;
-    overflow: hidden;
-    box-shadow: 1px 1px 5px 1px #dddddd;
-  }
-  
-  .section-box h2 {
-    margin: 0.5rem 0rem;
-    font-size: 1.25rem;
-    font-weight: 400;
-  }
-  
-  .section-wide {
-    width: 100%;
-  }
-  
-  .collapsible {
-    cursor: pointer;
-  }
-  
-  .section-content {
-    height: auto;
-  }
-  
-  .collapsed {
-    height: 0;
-  }
-  
-  .join-meeting-btn-grid {
-    display: grid;
-    grid-template-columns: 1fr 1fr 1fr;
-    /* border: 10px solid black */
-  } 
-  
-  .video-section {
-    display: flex;
-    flex-direction: column;
-    flex-grow: 1;
-  }
-  
-  .screenshare-section {
-    display: flex;
-    flex-direction: column;
-    flex-grow: 1;
-  }
-  
-  .status-par {
-    padding: 0.5rem;
-    background-color: #eeeeee;
-    margin: 0.2rem;
-    border-radius: 6px;
-  }
-  
-  #participant-table {
-    max-height: 400px;
-    overflow: auto;
-  }
-  
-  #events-list {
-    max-height: 200px;
-    overflow: auto;
-  }
-  
-  .multistream-videos-container {
-    display: flex;
-    flex-direction: column;
-  }
-  
-  .multistream-videos-container video {
-    border-radius: 0.5rem;
-  }
-  
-  .video-grid-row {
-    display: flex;
-    flex-direction: row;
-    justify-content: center;
-    flex-wrap: wrap;
-    align-items: center;
-    align-content: center;
-  }
-  
-  .video-container,
-  .audio-container,
-  .screenshare-container {
-    position: relative;
-    display: flex;
-    justify-content: center;
-    margin: 0.4rem;
-  }
-  
-  .multistream-remote-video {
-    z-index: 0;
-  }
-  .video-label {
-    z-index: 2;
-    position: absolute;
-    bottom: 0px;
-    left: 0px;
-    width: 100%;
-    text-align: center;
-    color: black;
-    background-color: rgba(255,255,255,0.5);
-  }
-  
-  .video-overlay {
-    z-index: 1;
-    position: absolute;
-    top: 0px;
-    left: 0px;
-    width: 100%;
-    height: 100%;
-    display: flex;
-    align-items: center;
-    align-content: center;
-    border-radius: 0.5rem;
-    background-color: lightgray;
-  }
-  
-  .video-overlay-text {
-    color: black;
-    width: 100%;
-    text-align: center;
-  }
-  
-  .speaking {
-    background-color: rgba(94, 217, 248, 0.5);
-  }
-  
-  .clickable {
-    cursor: pointer;
-  }
-  
-  .grid-video {
-    max-width: var(--video-grid-max-width);
-  }
-  
-  .big-video {
-    max-width: 100%;
-  }
-  
-  .small-video {
-    max-width: 18%;
-  }
-  
-  .multistream-buttons {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-  }
-  
-  .multistream-buttons select {
-    /* margin: 0 0.5rem; */
-  }
-  
-  .stage {
-    min-height: 30rem;
-  }
-  
-  .stageThumbnails {
-    min-height: 7rem;
-  }
-  
-  .stage-control-wrapper {
-    display: flex;
-    align-items: center;
-  }
-  
-  .stage-control-wrapper span {
-    margin-right: 0.5rem;
-  }
-  
-  .prefer-live-video {
-    display: flex;
-  }
-  
-  .prefer-live-video span {
-    margin-top: 1rem;
-    margin-right: 0.5rem;
-  }
-  
-  /* Utilities */
-  
-  .flex {
-    display: flex;
-  }
-  .flex--wrap {
-    flex-wrap: wrap;
-  }
-  .flex--center {
-    justify-content: center;
-  }
-  
-  .flex--align-center {
-    align-items: center;
-  }
-  
-  /* Margin utils */
-  .u-m {
-    margin: 1rem !important;
-  }
-  
-  .u-mv {
-    margin-top: 1rem !important;
-    margin-bottom: 1rem !important;
-  }
-  
-  .u-mb {
-    margin-bottom: 1rem !important;
-  }
-  
-  .u-mt {
-    margin-top: 1rem !important;
-  }
-  
-  .u-ml {
-    margin-left: 1rem;
-  }
-  
-  /* Padding Utils */
-  .u-p {
-    padding: 1rem !important;
-  }
-  
-  .u-pv {
-    padding-top: 1rem !important;
-    padding-bottom: 1rem !important;
-  }
-  
-  .u-pb {
-    padding-bottom: 1rem !important;
-  }
-  
-  .u-pt {
-    padding-top: 1rem !important;
-  }
-  
-  /* Misc Styles */
-  .note {
-    padding: 1rem 0;
-    margin: 0.8rem 0;
-    background: rgba(232, 232, 232, 0.4);
-    padding: 1rem;
-    border-radius: 6px;
-    color: #555;
-  }
-  
-  .transcription {
-    display: flex;
-    flex-direction: column;
-  }
-  .transcription textarea {
-    width: 100%;
-    min-height: 10rem;
-  }
-  
-  .device-type-label {
-    width: 125px;
-    display: inline-block;
-  }
-  
-  .context-info {
-    width: 200px;
-    display: inline-block;
-  }
-  
-  .meeting-list {
-    list-style-type: none;
-  }
-  
-  /* Container - Docs / Streams Fixed */
-  .container {
-    display: flex;
-    width: 100%;
-    gap: 1rem;
-    flex-direction: row;
-  }
-  
-  .docs {
-    overflow: auto;
-  }
-  
-  .hidden {
-    display: none;
-  }
-  
-  .media-button-label {
-    flex: 0.25;
-    font-weight: 500;
-    color: #b70303;
-  }
-  
-  .media-select {
-    flex: 0.15;
-    margin-right: 1rem;
-  }
-  
-  .media-button {
-    flex: 0.5;
-    width: 23rem;
-  }
-  
-  h2 {
-    color: #0052bf;
-  }
-  
-  legend {
-    font-size: 1.05rem;
-    color: #1a73e8;
-  }
-  
-  .video-container {
-    position: relative;
-  }
-  
-  .video-resolution {
-    position: absolute;
-    left: 0.5rem;
-    top: 0.5rem;
-    opacity: 0.75;
-    user-select: none;
-    color: #083f88;
-    background-color: rgb(255 255 255);
-    padding: 0.3rem;
-  }
-  
-  .webex-warning {
-    color: #7d4705;
-  }
-  
-  .webex-error {
-    color: #de3434;
-  }
-  
-  .arrow {
-    font-weight: 500;
-    font-size: 1.75rem;
-    float: right;
-    margin-top: -2px;
-  }
-  
-  
-  .global-toggle-btn-wrapper {
-    display: flex;
-    justify-content: end;
-    margin: -0.5rem auto;
-    position: sticky;
-    top: 0;
-    z-index: 1;
-  }
-  
-  .global-toggle-btn {
-    width: 10rem;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    padding: 0.25rem;
-    background-color: white;
-    color: #0052bf;
-    border: #0052bf 1px solid;
-    box-shadow: 3px 3px 4px 1px rgb(0 0 0 / 40%);
-  }
-  
-  .global-toggle-btn:hover {
-    border: #1a73e8 1px solid;
-    background-color: whitesmoke
-  }
-  
-  .global-toggle-btn:focus {
-    box-shadow: 3px 3px 4px 1px rgb(0 0 0 / 40%);
-  }
-  
-  #voicea-transcription-formatted-display{
-    max-height: 200px;
-    overflow: auto;
-    padding: 0.5rem;
-    background-color: #eeeeee;
-    margin: 0.2rem;
-    border-radius: 5px;
-  }
-  
-  .inline-code{
-    background-color:lightgrey;
-    border-radius:5px;
-    padding: 0 2px;
-  }
\ No newline at end of file
+  --video-grid-max-width: 100%;
+}
+
+body {
+  max-width: 100%;
+  margin: 1rem;
+  padding: 0;
+  background: #eeeeee;
+}
+
+button.btn--green {
+  color: #fff;
+  color: var(--md-button-join-text-color, #fff);
+  background-color: #00ab50;
+  background-color: var(--md-button-join-bg-color, #00ab50);
+  border-color: transparent;
+}
+
+button.btn--green:disabled {
+  opacity: 0.5;
+}
+
+button.btn--red {
+  color: #fff;
+  color: var(--md-button-cancel-text-color, #fff);
+  background-color: #f7644a;
+  background-color: var(--md-button-cancel-bg-color, #f7644a);
+  border-color: transparent;
+}
+
+.btn--red:disabled,
+.btn--green:disabled {
+  opacity: 0.5;
+}
+
+button.btn-code {
+  font-family: Consolas, Liberation Mono, Courier, monospace;
+}
+
+.container {
+  display: flex;
+  width: 100%;
+  flex-direction: row;
+  justify-content: space-between;
+  margin-bottom: 1rem;
+}
+
+.column {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  width: 100%;
+}
+
+.box {
+  max-width: 70rem; 
+  margin-inline: auto;
+  margin-bottom: 1rem;
+}
+
+.section-box {
+  background: #ffffff;
+  border-radius: 1rem;
+  padding: 0rem 1rem;
+  overflow: hidden;
+  box-shadow: 1px 1px 5px 1px #dddddd;
+}
+
+.section-box h2 {
+  margin: 0.5rem 0rem;
+  font-size: 1.25rem;
+  font-weight: 400;
+}
+
+.section-wide {
+  width: 100%;
+}
+
+.collapsible {
+  cursor: pointer;
+}
+
+.section-content {
+  height: auto;
+}
+
+.collapsed {
+  height: 0;
+}
+
+.join-meeting-btn-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr 1fr;
+  /* border: 10px solid black */
+} 
+
+.video-section {
+  display: flex;
+  flex-direction: column;
+  flex-grow: 1;
+}
+
+.screenshare-section {
+  display: flex;
+  flex-direction: column;
+  flex-grow: 1;
+}
+
+.status-par {
+  padding: 0.5rem;
+  background-color: #eeeeee;
+  margin: 0.2rem;
+  border-radius: 6px;
+}
+
+#participant-table {
+  max-height: 400px;
+  overflow: auto;
+}
+
+#events-list {
+  max-height: 200px;
+  overflow: auto;
+}
+
+.multistream-videos-container {
+  display: flex;
+  flex-direction: column;
+}
+
+.multistream-videos-container video {
+  border-radius: 0.5rem;
+}
+
+.video-grid-row {
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  flex-wrap: wrap;
+  align-items: center;
+  align-content: center;
+}
+
+.video-container,
+.audio-container,
+.screenshare-container {
+  position: relative;
+  display: flex;
+  justify-content: center;
+  margin: 0.4rem;
+}
+
+.multistream-remote-video {
+  z-index: 0;
+}
+.video-label {
+  z-index: 2;
+  position: absolute;
+  bottom: 0px;
+  left: 0px;
+  width: 100%;
+  text-align: center;
+  color: black;
+  background-color: rgba(255,255,255,0.5);
+}
+
+.video-overlay {
+  z-index: 1;
+  position: absolute;
+  top: 0px;
+  left: 0px;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  align-content: center;
+  border-radius: 0.5rem;
+  background-color: lightgray;
+}
+
+.video-overlay-text {
+  color: black;
+  width: 100%;
+  text-align: center;
+}
+
+.speaking {
+  background-color: rgba(94, 217, 248, 0.5);
+}
+
+.clickable {
+  cursor: pointer;
+}
+
+.grid-video {
+  max-width: var(--video-grid-max-width);
+}
+
+.big-video {
+  max-width: 100%;
+}
+
+.small-video {
+  max-width: 18%;
+}
+
+.multistream-buttons {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.multistream-buttons select {
+  /* margin: 0 0.5rem; */
+}
+
+.stage {
+  min-height: 30rem;
+}
+
+.stageThumbnails {
+  min-height: 7rem;
+}
+
+.stage-control-wrapper {
+  display: flex;
+  align-items: center;
+}
+
+.stage-control-wrapper span {
+  margin-right: 0.5rem;
+}
+
+.prefer-live-video {
+  display: flex;
+}
+
+.prefer-live-video span {
+  margin-top: 1rem;
+  margin-right: 0.5rem;
+}
+
+/* Utilities */
+
+.flex {
+  display: flex;
+}
+.flex--wrap {
+  flex-wrap: wrap;
+}
+.flex--center {
+  justify-content: center;
+}
+
+.flex--align-center {
+  align-items: center;
+}
+
+/* Margin utils */
+.u-m {
+  margin: 1rem !important;
+}
+
+.u-mv {
+  margin-top: 1rem !important;
+  margin-bottom: 1rem !important;
+}
+
+.u-mb {
+  margin-bottom: 1rem !important;
+}
+
+.u-mt {
+  margin-top: 1rem !important;
+}
+
+.u-ml {
+  margin-left: 1rem;
+}
+
+/* Padding Utils */
+.u-p {
+  padding: 1rem !important;
+}
+
+.u-pv {
+  padding-top: 1rem !important;
+  padding-bottom: 1rem !important;
+}
+
+.u-pb {
+  padding-bottom: 1rem !important;
+}
+
+.u-pt {
+  padding-top: 1rem !important;
+}
+
+/* Misc Styles */
+.note {
+  padding: 1rem 0;
+  margin: 0.8rem 0;
+  background: rgba(232, 232, 232, 0.4);
+  padding: 1rem;
+  border-radius: 6px;
+  color: #555;
+}
+
+.transcription {
+  display: flex;
+  flex-direction: column;
+}
+.transcription textarea {
+  width: 100%;
+  min-height: 10rem;
+}
+
+.device-type-label {
+  width: 125px;
+  display: inline-block;
+}
+
+.context-info {
+  width: 200px;
+  display: inline-block;
+}
+
+.meeting-list {
+  list-style-type: none;
+}
+
+/* Container - Docs / Streams Fixed */
+.container {
+  display: flex;
+  width: 100%;
+  gap: 1rem;
+  flex-direction: row;
+}
+
+.docs {
+  overflow: auto;
+}
+
+.hidden {
+  display: none;
+}
+
+.media-button-label {
+  flex: 0.25;
+  font-weight: 500;
+  color: #b70303;
+}
+
+.media-select {
+  flex: 0.15;
+  margin-right: 1rem;
+}
+
+.media-button {
+  flex: 0.5;
+  width: 23rem;
+}
+
+h2 {
+  color: #0052bf;
+}
+
+legend {
+  font-size: 1.05rem;
+  color: #1a73e8;
+}
+
+.video-container {
+  position: relative;
+}
+
+.video-resolution {
+  position: absolute;
+  left: 0.5rem;
+  top: 0.5rem;
+  opacity: 0.75;
+  user-select: none;
+  color: #083f88;
+  background-color: rgb(255 255 255);
+  padding: 0.3rem;
+}
+
+.webex-warning {
+  color: #7d4705;
+}
+
+.webex-error {
+  color: #de3434;
+}
+
+.arrow {
+  font-weight: 500;
+  font-size: 1.75rem;
+  float: right;
+  margin-top: -2px;
+}
+
+
+.global-toggle-btn-wrapper {
+  display: flex;
+  justify-content: end;
+  margin: -0.5rem auto;
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+
+.global-toggle-btn {
+  width: 10rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.25rem;
+  background-color: white;
+  color: #0052bf;
+  border: #0052bf 1px solid;
+  box-shadow: 3px 3px 4px 1px rgb(0 0 0 / 40%);
+}
+
+.global-toggle-btn:hover {
+  border: #1a73e8 1px solid;
+  background-color: whitesmoke
+}
+
+.global-toggle-btn:focus {
+  box-shadow: 3px 3px 4px 1px rgb(0 0 0 / 40%);
+}
+
+#voicea-transcription-formatted-display{
+  max-height: 200px;
+  overflow: auto;
+  padding: 0.5rem;
+  background-color: #eeeeee;
+  margin: 0.2rem;
+  border-radius: 5px;
+}
+
+.inline-code{
+  background-color:lightgrey;
+  border-radius:5px;
+  padding: 0 2px;
+}
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/__mocks__/workerMock.js b/packages/@webex/plugin-cc/__mocks__/workerMock.js
new file mode 100644
index 00000000000..7eb5a07eb16
--- /dev/null
+++ b/packages/@webex/plugin-cc/__mocks__/workerMock.js
@@ -0,0 +1,15 @@
+class Worker {
+  constructor(stringUrl) {
+    this.url = stringUrl;
+    this.onmessage = () => {};
+  }
+
+  postMessage(msg) {
+    this.onmessage(msg);
+  }
+
+  terminate() {}
+}
+
+global.Worker = Worker;
+global.URL.createObjectURL = jest.fn(() => 'blob:http://localhost:3000/12345');
diff --git a/packages/@webex/plugin-cc/package.json b/packages/@webex/plugin-cc/package.json
index f6daba0b555..cfd946ae866 100644
--- a/packages/@webex/plugin-cc/package.json
+++ b/packages/@webex/plugin-cc/package.json
@@ -12,8 +12,8 @@
     "node": ">=20.x"
   },
   "scripts": {
-    "build:src": "webex-legacy-tools build -dest \"./dist\" -src \"./src\" -js -ts && yarn build",
-    "build": "yarn run -T tsc --declaration true --declarationDir ./dist/types",
+    "build:src": "webex-legacy-tools build -dest \"./dist\" -src \"./src\" -js -ts -maps && yarn build",
+    "build": " yarn workspace @webex/calling run build:src && yarn run -T tsc --declaration true --declarationDir ./dist/types",
     "docs": "typedoc --emit none",
     "fix:lint": "eslint 'src/**/*.ts' --fix",
     "fix:prettier": "prettier \"src/**/*.ts\" --write",
diff --git a/packages/@webex/plugin-cc/src/AgentConfig/types.ts b/packages/@webex/plugin-cc/src/AgentConfig/types.ts
deleted file mode 100644
index 97f4a984421..00000000000
--- a/packages/@webex/plugin-cc/src/AgentConfig/types.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import {AuxCode, Team} from '../AgentConfigService/types';
-import {WebexSDK} from '../types';
-
-type Enum<T extends Record<string, unknown>> = T[keyof T];
-
-// Define the  object
-export const WORK_TYPE_CODE = {
-  WRAP_UP_CODE: 'WRAP_UP_CODE',
-  IDLE_CODE: 'IDLE_CODE',
-} as const;
-
-// Derive the type using the utility type
-type WORK_TYPE_CODE = Enum<typeof WORK_TYPE_CODE>;
-
-/**
- * Represents the request to a AgentConfig
- *
- * @public
- */
-export interface AgentConfigRequest {
-  /**
-   * Represents id of agent.
-   */
-  agentId: string;
-
-  /**
-   * Represents object of WebexSDK.
-   */
-
-  webex: WebexSDK;
-
-  /**
-   * Org id of the agent.
-   */
-  orgId: string;
-}
-
-/**
- * Represents the response from AgentConfig.
- *
- * @public
- */
-export interface IAgentProfile {
-  /**
-   * The id of the agent.
-   */
-
-  agentId: string;
-
-  /**
-   * The name of the agent.
-   */
-  agentName: string;
-
-  /**
-   * Identifier for a Desktop Profile.
-   */
-  agentProfileId: string;
-
-  /**
-   * The email address of the agent.
-   */
-
-  agentMailId: string;
-
-  /**
-   * Represents list of teams of an agent.
-   */
-  teams: Team[];
-
-  /**
-   * Represents the voice options of an agent.
-   */
-
-  loginVoiceOptions: string[];
-
-  /**
-   * Represents the Idle codes list that the agents can select in Agent Desktop.t.
-   */
-
-  idleCodes: AuxCode[];
-
-  /**
-   * Represents the wrap-up codes list that the agents can select when they wrap up a contact.
-   */
-  wrapUpCodes: AuxCode[];
-}
diff --git a/packages/@webex/plugin-cc/src/AgentConfigService/types.ts b/packages/@webex/plugin-cc/src/AgentConfigService/types.ts
deleted file mode 100644
index f6444510a5a..00000000000
--- a/packages/@webex/plugin-cc/src/AgentConfigService/types.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * Represents the response from getUserUsingCI method.
- *
- * @public
- */
-
-export interface AgentResponse {
-  /**
-   * The first name of the agent.
-   */
-  firstName: string;
-
-  /**
-   * The last name of the agent.
-   */
-  lastName: string;
-
-  /**
-   * Identifier for a Desktop Profile.
-   */
-  agentProfileId: string;
-
-  /**
-   * The email address of the agent.
-   */
-
-  email: string;
-
-  /**
-   * This Specify the teams id which got assigned to the agent.
-   */
-  teamIds: string[];
-}
-
-/**
- * Represents the response from getDesktopProfileById method.
- *
- * @public
- */
-export interface DesktopProfileResponse {
-  /**
-   * Represents the voice options of an agent.
-   */
-
-  loginVoiceOptions: string[];
-
-  /**
-   * Specify the wrap-up codes that the agents can select when they wrap up a contact. It can take one of these values: ALL - To make all wrap-up codes available. SPECIFIC - To make specific codes available.
-   */
-
-  accessWrapUpCode: string;
-
-  /**
-   * Specify the Idle codes that the agents can select in Agent Desktop. It can take one of these values: ALL - To make all wrap-up codes available. SPECIFIC - To make specific codes available.
-   */
-
-  accessIdleCode: string;
-
-  /**
-   * Specify the wrap-up codes list that the agents can select when they wrap up a contact.
-   */
-
-  wrapUpCodes: string[];
-
-  /**
-   * Specify the Idle codes list that the agents can select in Agent Desktop.
-   */
-
-  idleCodes: string[];
-}
-
-/**
- * Represents the response from getListOfTeams method.
- *
- * @public
- */
-export interface Team {
-  /**
-   * ID of the team.
-   */
-  id: string;
-
-  /**
-   *  Name of the Team.
-   */
-  name: string;
-}
-
-/**
- * Represents AuxCode.
- * @public
- */
-
-export interface AuxCode {
-  /**
-   * ID of the Auxiliary Code.
-   */
-  id: string;
-
-  /**
-   * Indicates whether the auxiliary code is active or not active.
-   */
-  active: boolean;
-
-  /**
-   * Indicates whether this is the default code (true) or not (false).
-   */
-  defaultCode: boolean;
-
-  /**
-   * Indicates whether this is the system default code (true) or not (false).
-   */
-  isSystemCode: boolean;
-
-  /**
-   * A short description indicating the context of the code.
-   */
-  description: string;
-
-  /**
-   * Name for the Auxiliary Code.
-   */
-  name: string;
-
-  /**
-   * Indicates the work type associated with this code..
-   */
-
-  workTypeCode: string;
-}
-
-/**
- * Represents the response from getListOfAuxCodes method.
- *
- * @public
- */
-
-export interface ListAuxCodesResponse {
-  data: AuxCode[];
-}
diff --git a/packages/@webex/plugin-cc/src/HttpRequest.ts b/packages/@webex/plugin-cc/src/HttpRequest.ts
deleted file mode 100644
index 4b87c822bc0..00000000000
--- a/packages/@webex/plugin-cc/src/HttpRequest.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-// This file can include common request to the API. Request method can be updated in the future based on needs.
-
-import {HTTP_METHODS, IHttpResponse, WebexSDK} from './types';
-
-export default class HttpRequest {
-  webex: WebexSDK;
-
-  constructor(webex: WebexSDK) {
-    this.webex = webex;
-  }
-
-  /**
-   * Common method to make HTTP Requests.
-   * @returns {Promise<IHttpResponse>} Returns the response from the API.
-   * @example
-   * Create an instance of a class HttpRequest by passing webex object and call the request method.
-   * const httpRequest = HttpRequest(webexObject);
-   * const response = await httpRequest.request('apiURL', 'GET', {});
-   */
-
-  public async request(URL: string, method: string, body: object = {}): Promise<IHttpResponse> {
-    try {
-      let response;
-      switch (method) {
-        case HTTP_METHODS.GET: {
-          response = await this.webex.request({
-            method,
-            uri: URL,
-          });
-          break;
-        }
-        case HTTP_METHODS.POST: {
-          response = await this.webex.request({
-            method,
-            uri: URL,
-            body,
-          });
-          break;
-        }
-        default: {
-          throw new Error(`Unsupported HTTP method: ${method}`);
-        }
-      }
-
-      return Promise.resolve(response);
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  }
-}
diff --git a/packages/@webex/plugin-cc/src/WebSocket/WebSocket.ts b/packages/@webex/plugin-cc/src/WebSocket/WebSocket.ts
deleted file mode 100644
index edc9fb0f5aa..00000000000
--- a/packages/@webex/plugin-cc/src/WebSocket/WebSocket.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import Mercury from '@webex/internal-plugin-mercury';
-import {HTTP_METHODS, SubscribeRequest, WebSocketEvent} from '../types';
-import webSocketConfig from './config';
-import IWebSocket from './types';
-
-class WebSocket extends (Mercury as any) implements IWebSocket {
-  /**
-   * @instance
-   * @memberof WebSocket
-   * @private
-   * @type {string}
-   */
-  private webSocketUrl: string;
-
-  /**
-   * @instance
-   * @memberof WebSocket
-   * @private
-   * @type {string}
-   */
-  private subscriptionId: string;
-
-  /**
-   * @instance
-   * @memberof WebSocket
-   * @private
-   * @type {string}
-   */
-  private datachannelUrl: string;
-
-  config = webSocketConfig; // overriding the config of Mercury with CC config
-
-  constructor(options = {}) {
-    super(options);
-    Mercury.prototype.initialize(this, options);
-  }
-
-  on(event: string, callback: (event: WebSocketEvent) => void): void {
-    super.on(event, callback);
-  }
-
-  off(event: string, callback: (event: WebSocketEvent) => void): void {
-    super.off(event, callback);
-  }
-
-  // TODO: this will be moved to a separate file in request module/file
-  /**
-   * Register to the websocket
-   * @param {object} params
-   * @param {string} params.datachannelUrl
-   * @param {object} params.body
-   * @returns {Promise<void>}
-   */
-  subscribeNotifications({
-    datachannelUrl,
-    body,
-  }: {
-    datachannelUrl: string;
-    body: SubscribeRequest;
-  }): Promise<void> {
-    return this.request({
-      method: HTTP_METHODS.POST,
-      url: datachannelUrl,
-      body,
-    })
-      .then((res) => {
-        this.webSocketUrl = res.body.webSocketUrl;
-        this.subscriptionId = res.body.subscriptionId;
-      })
-      .catch((error) => {
-        throw error;
-      });
-  }
-
-  /**
-   * Subscribe and connect to the websocket
-   * @param {object} params
-   * @param {string} params.datachannelUrl
-   * @param {SubscribeRequest} params.body
-   * @returns {Promise<void>}
-   */
-  subscribeAndConnect({
-    datachannelUrl,
-    body,
-  }: {
-    datachannelUrl: string;
-    body: SubscribeRequest;
-  }): Promise<void> {
-    return this.subscribeNotifications({datachannelUrl, body})
-      .then(() => {
-        this.datachannelUrl = datachannelUrl;
-
-        this.connect(this.webSocketUrl);
-
-        return Promise.resolve();
-      })
-      .catch((error) => {
-        throw error;
-      });
-  }
-
-  /**
-   * Tells if WebSocket socket is connected
-   * @returns {boolean} connected
-   */
-  isConnected(): boolean {
-    return this.connected;
-  }
-
-  /**
-   * Get the subscriptionId for the connection
-   * @returns {string} subscriptionId
-   */
-  getSubscriptionId(): string | undefined {
-    return this.subscriptionId;
-  }
-
-  /**
-   * Get data channel URL for the connection
-   * @returns {string} data channel Url
-   */
-  getDatachannelUrl(): string | undefined {
-    return this.datachannelUrl;
-  }
-
-  /**
-   * Disconnects websocket connection
-   * @returns {Promise<void>}
-   */
-  disconnectWebSocket(): Promise<void> {
-    return this.disconnect().then(() => {
-      this.datachannelUrl = undefined;
-      this.subscriptionId = undefined;
-      this.webSocketUrl = undefined;
-    });
-  }
-}
-
-export default WebSocket;
diff --git a/packages/@webex/plugin-cc/src/cc.ts b/packages/@webex/plugin-cc/src/cc.ts
index 74cc383167a..a32300b18b9 100644
--- a/packages/@webex/plugin-cc/src/cc.ts
+++ b/packages/@webex/plugin-cc/src/cc.ts
@@ -1,41 +1,41 @@
 import {WebexPlugin} from '@webex/webex-core';
-import AgentConfig from './AgentConfig/AgentConfig';
-import {IAgentProfile} from './AgentConfig/types';
+import AgentConfig from './features/Agentconfig';
 import {
   CCPluginConfig,
   IContactCenter,
   WebexSDK,
-  CC_EVENTS,
-  WebSocketEvent,
+  LoginOption,
+  WelcomeEvent,
+  IAgentProfile,
+  AgentLogin,
+  StationLoginResponse,
+  StationLogoutResponse,
+  StationReLoginResponse,
+  BuddyAgentsResponse,
+  BuddyAgents,
   SubscribeRequest,
-  EventResult,
 } from './types';
-import {
-  EVENT,
-  READY,
-  WEBSOCKET_EVENT_TIMEOUT,
-  SUBSCRIBE_API,
-  WCC_API_GATEWAY,
-  CC_FILE,
-} from './constants';
-import IWebSocket from './WebSocket/types';
-import WebSocket from './WebSocket/WebSocket';
-
-const REGISTER_EVENT = 'register';
+import {READY, CC_FILE, EMPTY_STRING} from './constants';
+import HttpRequest from './services/core/HttpRequest';
+import WebCallingService from './services/WebCallingService';
+import {AGENT, WEB_RTC_PREFIX} from './services/constants';
+import {WebSocketManager} from './services/core/WebSocket/WebSocketManager';
+import Services from './services';
+import LoggerProxy from './logger-proxy';
+import {ConnectionService} from './services/core/WebSocket/connection-service';
+import {Logout} from './services/agent/types';
+import {getErrorDetails} from './services/core/Utils';
 
 export default class ContactCenter extends WebexPlugin implements IContactCenter {
   namespace = 'cc';
-  $config: CCPluginConfig;
-  $webex: WebexSDK;
-  wccApiUrl: string;
-  agentProfile: IAgentProfile;
-  webSocket: IWebSocket;
-  ciUserId: string;
-  registered = false;
-  eventHandlers: Map<
-    string,
-    {resolve: (data: any) => void; reject: (error: any) => void; timeoutId: NodeJS.Timeout}
-  > = new Map();
+  private $config: CCPluginConfig;
+  private $webex: WebexSDK;
+  private agentConfig: IAgentProfile;
+  private httpRequest: HttpRequest;
+  private webSocketManager: WebSocketManager;
+  private webCallingService: WebCallingService;
+  private connectionService: ConnectionService;
+  private services: Services;
 
   constructor(...args) {
     super(...args);
@@ -46,9 +46,26 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.$webex.once(READY, () => {
       // @ts-ignore
       this.$config = this.config;
-      this.webSocket = new WebSocket({
-        parent: this.$webex,
+
+      /**
+       * This is used for handling the async requests by sending webex.request and wait for corresponding websocket event.
+       */
+      this.httpRequest = HttpRequest.getInstance({
+        webex: this.$webex,
       });
+
+      this.webSocketManager = new WebSocketManager({webex: this.$webex});
+
+      this.connectionService = new ConnectionService(
+        this.webSocketManager,
+        this.getConnectionConfig()
+      );
+
+      this.services = Services.getInstance(this.webSocketManager);
+
+      this.webCallingService = new WebCallingService(this.$webex, this.$config.callingClientConfig);
+
+      LoggerProxy.initialize(this.$webex.logger);
     });
   }
 
@@ -56,102 +73,154 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    * This is used for making the CC SDK ready by setting up the cc mercury connection.
    */
   public async register(): Promise<IAgentProfile> {
-    this.wccApiUrl = this.$webex.internal.services.get(WCC_API_GATEWAY);
-    this.listenForWebSocketEvents();
-
-    return new Promise((resolve, reject) => {
-      this.addEventHandler(
-        REGISTER_EVENT,
-        (result) => {
-          this.registered = true;
-          resolve(result);
-        },
-        reject
-      );
+    try {
+      return await this.connectWebsocket();
+    } catch (error) {
+      this.$webex.logger.error(`file: ${CC_FILE}: Error during register: ${error}`);
 
-      this.establishConnection(reject);
-    });
+      throw error;
+    }
   }
 
   /**
-   * This is used for unregistering the CC SDK by disconnecting the cc mercury connection.
-   * @returns Promise<void>
+   * Returns the list of buddy agents in the given state and media according to agent profile settings
+   *
+   * @param {BuddyAgents} data - The data required to fetch buddy agents, including additional agent profile information.
+   * @returns {Promise<BuddyAgentsResponse>} A promise that resolves to the response containing buddy agents information.
+   * @throws Error
+   * @example getBuddyAgents({state: 'Available', mediaType: 'telephony'})
    */
-  public unregister(): Promise<void> {
-    return this.webSocket.disconnectWebSocket().then(() => {
-      this.webSocket.off(EVENT, this.processEvent);
-      this.registered = false;
-    });
+  public async getBuddyAgents(data: BuddyAgents): Promise<BuddyAgentsResponse> {
+    try {
+      return await this.services.agent.buddyAgents({
+        data: {agentProfileId: this.agentConfig.agentProfileId, ...data},
+      });
+    } catch (error) {
+      throw getErrorDetails(error, 'getBuddyAgents');
+    }
   }
 
-  private listenForWebSocketEvents() {
-    this.webSocket.on(EVENT, this.processEvent);
+  /**
+   * This is used for connecting the websocket and fetching the agent profile.
+   * @returns Promise<IAgentProfile>
+   * @throws Error
+   * @private
+   */
+  private async connectWebsocket() {
+    try {
+      return this.webSocketManager
+        .initWebSocket({
+          body: this.getConnectionConfig(),
+        })
+        .then(async (data: WelcomeEvent) => {
+          const agentId = data.agentId;
+          const agentConfig = new AgentConfig(agentId, this.$webex, this.httpRequest);
+          this.agentConfig = await agentConfig.getAgentProfile();
+          this.$webex.logger.log(`file: ${CC_FILE}: agent config is fetched successfully`);
+
+          return this.agentConfig;
+        })
+        .catch((error) => {
+          throw error;
+        });
+    } catch (error) {
+      this.$webex.logger.error(`file: ${CC_FILE}: Error during register: ${error}`);
+
+      throw error;
+    }
   }
 
-  private processEvent = async (event: WebSocketEvent): Promise<void> => {
+  /**
+   * This is used for agent login.
+   * @param data
+   * @returns Promise<StationLoginResponse>
+   * @throws Error
+   */
+  public async stationLogin(data: AgentLogin): Promise<StationLoginResponse> {
     try {
-      switch (event.type) {
-        case CC_EVENTS.WELCOME: {
-          const agentId = event.data.agentId;
-          const agentProfile = new AgentConfig(agentId, this.$webex, this.wccApiUrl);
-          this.agentProfile = await agentProfile.getAgentProfile();
-          this.$webex.logger.log(
-            `Agent config fetch successfully. file: ${CC_FILE} method: ${this.processEvent.name}`
-          );
-          this.handleEvent(REGISTER_EVENT, this.agentProfile);
-          break;
-        }
-        default:
-          this.$webex.logger.info(`Unknown event: ${event.type}`);
+      const loginResponse = this.services.agent.stationLogin({
+        data: {
+          dialNumber:
+            data.loginOption === LoginOption.BROWSER ? this.agentConfig.agentId : data.dialNumber,
+          teamId: data.teamId,
+          deviceType: data.loginOption,
+          isExtension: data.loginOption === LoginOption.EXTENSION,
+          deviceId: this.getDeviceId(data.loginOption, data.dialNumber),
+          roles: [AGENT],
+          // TODO: The public API should not have the following properties so filling them with empty values for now. If needed, we can add them in the future.
+          teamName: EMPTY_STRING,
+          siteId: EMPTY_STRING,
+          usesOtherDN: false,
+          auxCodeId: EMPTY_STRING,
+        },
+      });
+
+      if (data.loginOption === LoginOption.BROWSER) {
+        await this.webCallingService.registerWebCallingLine();
       }
+
+      await loginResponse;
+
+      return loginResponse;
     } catch (error) {
-      this.$webex.logger.error(`Error in processing event: ${error}`);
+      throw getErrorDetails(error, 'stationLogin');
     }
-  };
+  }
 
-  private async establishConnection(reject: (error: Error) => void) {
-    const datachannelUrl = `${this.wccApiUrl}${SUBSCRIBE_API}`;
+  /** This is used for agent logout.
+   * @param data
+   * @returns Promise<StationLogoutResponse>
+   * @throws Error
+   */
+  public async stationLogout(data: Logout): Promise<StationLogoutResponse> {
+    try {
+      const logoutResponse = this.services.agent.logout({
+        data,
+      });
 
-    const connectionConfig: SubscribeRequest = {
-      force: this.$config?.force ?? true,
-      isKeepAliveEnabled: this.$config?.isKeepAliveEnabled ?? false,
-      clientType: this.$config?.clientType ?? 'WebexCCSDK',
-      allowMultiLogin: this.$config?.allowMultiLogin ?? true,
-    };
+      await logoutResponse;
 
+      if (this.webCallingService) {
+        this.webCallingService.deregisterWebCallingLine();
+      }
+
+      return logoutResponse;
+    } catch (error) {
+      throw getErrorDetails(error, 'stationLogout');
+    }
+  }
+
+  /* This is used for agent relogin.
+   * @returns Promise<StationReLoginResponse>
+   * @throws Error
+   */
+  public async stationReLogin(): Promise<StationReLoginResponse> {
     try {
-      await this.webSocket.subscribeAndConnect({
-        datachannelUrl,
-        body: connectionConfig,
-      });
-      this.$webex.logger.info('Successfully connected and subscribed.');
+      const reLoginResponse = await this.services.agent.reload();
+
+      return reLoginResponse;
     } catch (error) {
-      this.$webex.logger.info(`Error connecting and subscribing: ${error}`);
-      reject(error);
+      throw getErrorDetails(error, 'stationReLogin');
     }
   }
 
-  private handleEvent(eventName: string, result: EventResult) {
-    const handler = this.eventHandlers.get(eventName);
-    if (handler) {
-      clearTimeout(handler.timeoutId);
-      handler.resolve(result);
-      this.eventHandlers.delete(eventName);
+  private getDeviceId(loginOption: string, dialNumber: string): string {
+    if (loginOption === LoginOption.EXTENSION || loginOption === LoginOption.AGENT_DN) {
+      return dialNumber;
     }
+
+    return WEB_RTC_PREFIX + this.agentConfig.agentId;
   }
 
-  private addEventHandler(
-    eventName: string,
-    resolve: (data: EventResult) => void,
-    reject: (error: Error) => void
-  ) {
-    this.eventHandlers.set(eventName, {
-      resolve,
-      reject,
-      timeoutId: setTimeout(() => {
-        reject(new Error(`Time out waiting for event: ${eventName}`));
-        this.eventHandlers.delete(eventName);
-      }, WEBSOCKET_EVENT_TIMEOUT),
-    });
+  /**
+   * This method returns the connection configuration.
+   */
+  private getConnectionConfig(): SubscribeRequest {
+    return {
+      force: this.$config?.force ?? true,
+      isKeepAliveEnabled: this.$config?.isKeepAliveEnabled ?? false,
+      clientType: this.$config?.clientType ?? 'WebexCCSDK',
+      allowMultiLogin: this.$config?.allowMultiLogin ?? true,
+    };
   }
 }
diff --git a/packages/@webex/plugin-cc/src/config.ts b/packages/@webex/plugin-cc/src/config.ts
index a0cfedb5132..caaba9c18a5 100644
--- a/packages/@webex/plugin-cc/src/config.ts
+++ b/packages/@webex/plugin-cc/src/config.ts
@@ -1,3 +1,5 @@
+import {LOGGER} from '@webex/calling';
+
 export default {
   cc: {
     allowMultiLogin: true,
@@ -8,5 +10,15 @@ export default {
       clientName: 'WEBEX_JS_SDK',
       clientType: 'WebexCCSDK',
     },
+    callingClientConfig: {
+      logger: {
+        level: LOGGER.INFO,
+      },
+      serviceData: {
+        indicator: 'contactcenter',
+        // TODO: This should be dynamic based on the environment
+        domain: 'rtw.prod-us1.rtmsprod.net',
+      },
+    },
   },
 };
diff --git a/packages/@webex/plugin-cc/src/constants.ts b/packages/@webex/plugin-cc/src/constants.ts
index fff3d98515e..9eb57f14eac 100644
--- a/packages/@webex/plugin-cc/src/constants.ts
+++ b/packages/@webex/plugin-cc/src/constants.ts
@@ -1,7 +1,5 @@
-export const POST_AUTH = 'postauth';
-export const WCC_API_GATEWAY = 'wcc-api-gateway';
 export const EVENT = 'event';
 export const READY = 'ready';
-export const SUBSCRIBE_API = 'v1/notification/subscribe';
 export const CC_FILE = 'cc';
-export const WEBSOCKET_EVENT_TIMEOUT = 20000;
+export const TIMEOUT_DURATION = 20000; // 20 seconds timeout duration for webrtc registration
+export const EMPTY_STRING = '';
diff --git a/packages/@webex/plugin-cc/src/AgentConfig/AgentConfig.ts b/packages/@webex/plugin-cc/src/features/Agentconfig.ts
similarity index 86%
rename from packages/@webex/plugin-cc/src/AgentConfig/AgentConfig.ts
rename to packages/@webex/plugin-cc/src/features/Agentconfig.ts
index 4431316255f..7f02b70c50d 100644
--- a/packages/@webex/plugin-cc/src/AgentConfig/AgentConfig.ts
+++ b/packages/@webex/plugin-cc/src/features/Agentconfig.ts
@@ -1,8 +1,8 @@
-import {IAgentProfile, WORK_TYPE_CODE} from './types';
-import AgentConfigService from '../AgentConfigService/AgentConfigService';
-import {Team, AuxCode} from '../AgentConfigService/types';
-import {WebexSDK} from '../types';
+import {WORK_TYPE_CODE} from './types';
+import AgentConfigService from '../services/config';
+import {IAgentProfile, Team, AuxCode, WebexSDK} from '../types';
 import {DEFAULT_ATTRIBUTES, DEFAULT_PAGE, DEFAULT_PAGE_SIZE} from './constants';
+import HttpRequest from '../services/core/HttpRequest';
 
 export default class AgentConfig {
   agentId: string;
@@ -13,12 +13,12 @@ export default class AgentConfig {
   } as IAgentProfile;
 
   webex: WebexSDK;
-  wccAPIURL: string;
+  httpRequest: HttpRequest;
 
-  constructor(agentId: string, webex: WebexSDK, wccAPIURL: string) {
+  constructor(agentId: string, webex: WebexSDK, httpRequest: HttpRequest) {
     this.agentId = agentId;
     this.webex = webex;
-    this.wccAPIURL = wccAPIURL;
+    this.httpRequest = httpRequest;
   }
 
   /**
@@ -32,14 +32,7 @@ export default class AgentConfig {
 
   public async getAgentProfile(): Promise<IAgentProfile> {
     try {
-      const orgId = this.webex.internal.device.orgId;
-
-      const agentConfigService = new AgentConfigService(
-        this.agentId,
-        orgId,
-        this.webex,
-        this.wccAPIURL
-      );
+      const agentConfigService = new AgentConfigService(this.agentId, this.webex, this.httpRequest);
 
       const agent = await agentConfigService.getUserUsingCI();
       const {firstName, lastName, agentProfileId, email} = agent;
diff --git a/packages/@webex/plugin-cc/src/AgentConfig/constants.ts b/packages/@webex/plugin-cc/src/features/constants.ts
similarity index 100%
rename from packages/@webex/plugin-cc/src/AgentConfig/constants.ts
rename to packages/@webex/plugin-cc/src/features/constants.ts
diff --git a/packages/@webex/plugin-cc/src/features/types.ts b/packages/@webex/plugin-cc/src/features/types.ts
new file mode 100644
index 00000000000..40fab576405
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/features/types.ts
@@ -0,0 +1,35 @@
+import {WebexSDK} from '../types';
+
+type Enum<T extends Record<string, unknown>> = T[keyof T];
+
+// Define the  object
+export const WORK_TYPE_CODE = {
+  WRAP_UP_CODE: 'WRAP_UP_CODE',
+  IDLE_CODE: 'IDLE_CODE',
+} as const;
+
+// Derive the type using the utility type
+type WORK_TYPE_CODE = Enum<typeof WORK_TYPE_CODE>;
+
+/**
+ * Represents the request to a AgentConfig
+ *
+ * @public
+ */
+export type AgentConfigRequest = {
+  /**
+   * Represents id of agent.
+   */
+  agentId: string;
+
+  /**
+   * Represents object of WebexSDK.
+   */
+
+  webex: WebexSDK;
+
+  /**
+   * Org id of the agent.
+   */
+  orgId: string;
+};
diff --git a/packages/@webex/plugin-cc/src/logger-proxy.ts b/packages/@webex/plugin-cc/src/logger-proxy.ts
new file mode 100644
index 00000000000..5d2dd2f04c9
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/logger-proxy.ts
@@ -0,0 +1,9 @@
+import {Logger} from './types';
+
+export default class LoggerProxy {
+  public static logger: Logger;
+
+  public static initialize(logger: Logger): void {
+    LoggerProxy.logger = logger;
+  }
+}
diff --git a/packages/@webex/plugin-cc/src/services/WebCallingService.ts b/packages/@webex/plugin-cc/src/services/WebCallingService.ts
new file mode 100644
index 00000000000..27154131ac7
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/WebCallingService.ts
@@ -0,0 +1,63 @@
+import {
+  createClient,
+  ICall,
+  ICallingClient,
+  ILine,
+  LINE_EVENTS,
+  CallingClientConfig,
+} from '@webex/calling';
+import {WebexSDK} from '../types';
+import {TIMEOUT_DURATION} from '../constants';
+
+export default class WebCallingService {
+  private callingClient: ICallingClient;
+  private callingClientConfig: CallingClientConfig;
+  private line: ILine;
+  private call: ICall;
+  private webex: WebexSDK;
+  constructor(webex: WebexSDK, callingClientConfig: CallingClientConfig) {
+    this.webex = webex;
+    this.callingClientConfig = callingClientConfig;
+  }
+
+  public async registerWebCallingLine(): Promise<void> {
+    this.callingClient = await createClient(this.webex as any, this.callingClientConfig);
+    this.line = Object.values(this.callingClient.getLines())[0];
+
+    this.line.on(LINE_EVENTS.UNREGISTERED, () => {
+      this.webex.logger.log(`WxCC-SDK: Desktop un registered successfully`);
+    });
+
+    // Start listening for incoming calls
+    this.line.on(LINE_EVENTS.INCOMING_CALL, (callObj: ICall) => {
+      this.call = callObj;
+
+      const incomingCallEvent = new CustomEvent(LINE_EVENTS.INCOMING_CALL, {
+        detail: {
+          call: this.call,
+        },
+      });
+
+      window.dispatchEvent(incomingCallEvent);
+    });
+
+    return new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('WebCallingService Registration timed out'));
+      }, TIMEOUT_DURATION);
+
+      this.line.on(LINE_EVENTS.REGISTERED, (deviceInfo: ILine) => {
+        clearTimeout(timeout);
+        this.webex.logger.log(
+          `WxCC-SDK: Desktop registered successfully, mobiusDeviceId: ${deviceInfo.mobiusDeviceId}`
+        );
+        resolve();
+      });
+      this.line.register();
+    });
+  }
+
+  public async deregisterWebCallingLine() {
+    this.line?.deregister();
+  }
+}
diff --git a/packages/@webex/plugin-cc/src/WebSocket/config.ts b/packages/@webex/plugin-cc/src/services/WebSocket/config.ts
similarity index 100%
rename from packages/@webex/plugin-cc/src/WebSocket/config.ts
rename to packages/@webex/plugin-cc/src/services/WebSocket/config.ts
diff --git a/packages/@webex/plugin-cc/src/services/WebSocket/index.ts b/packages/@webex/plugin-cc/src/services/WebSocket/index.ts
new file mode 100644
index 00000000000..4392bf24b4e
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/WebSocket/index.ts
@@ -0,0 +1,70 @@
+import Mercury from '@webex/internal-plugin-mercury';
+import {WebSocketEvent} from '../config/types';
+import webSocketConfig from './config';
+import IWebSocket from './types';
+
+class WebSocket extends (Mercury as any) implements IWebSocket {
+  /**
+   * @instance
+   * @memberof WebSocket
+   * @private
+   * @type {string}
+   */
+  private webSocketUrl: string;
+
+  config = webSocketConfig; // overriding the config of Mercury with CC config
+
+  constructor(options = {}) {
+    super(options);
+    Mercury.prototype.initialize(this, options);
+  }
+
+  on(event: string, callback: (event: WebSocketEvent) => void): void {
+    super.on(event, callback);
+  }
+
+  off(event: string, callback: (event: WebSocketEvent) => void): void {
+    super.off(event, callback);
+  }
+
+  /**
+   * Subscribe and connect to the websocket
+   * @param {object} params
+   * @param {string} params.datachannelUrl
+   * @param {SubscribeRequest} params.body
+   * @returns {Promise<void>}
+   */
+  connectWebSocket(options: {webSocketUrl: string}): void {
+    const {webSocketUrl} = options;
+    this.webSocketUrl = webSocketUrl;
+    this.connect(webSocketUrl);
+  }
+
+  /**
+   * Tells if WebSocket socket is connected
+   * @returns {boolean} connected
+   */
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  /**
+   * Get data channel URL for the connection
+   * @returns {string} data channel Url
+   */
+  getWebSocketUrl(): string | undefined {
+    return this.webSocketUrl;
+  }
+
+  /**
+   * Disconnects websocket connection
+   * @returns {Promise<void>}
+   */
+  disconnectWebSocket(): Promise<void> {
+    return this.disconnect().then(() => {
+      this.webSocketUrl = undefined;
+    });
+  }
+}
+
+export default WebSocket;
diff --git a/packages/@webex/plugin-cc/src/WebSocket/types.ts b/packages/@webex/plugin-cc/src/services/WebSocket/types.ts
similarity index 65%
rename from packages/@webex/plugin-cc/src/WebSocket/types.ts
rename to packages/@webex/plugin-cc/src/services/WebSocket/types.ts
index a5a8bb33c4d..51ae926d9d9 100644
--- a/packages/@webex/plugin-cc/src/WebSocket/types.ts
+++ b/packages/@webex/plugin-cc/src/services/WebSocket/types.ts
@@ -1,4 +1,4 @@
-import {SubscribeRequest, WebSocketEvent} from '../types';
+import {WebSocketEvent} from '../config/types';
 
 // ts doc
 /**
@@ -21,12 +21,10 @@ interface IWebSocket {
   off(event: string, callback: (event: WebSocketEvent) => void): void;
   /**
    * Subscribe and connect to the WebSocket
-   * @param {object} params
-   * @param {string} params.datachannelUrl
-   * @param {object} params.body
-   * @returns {Promise<void>}
+   * @param {object} options
+   * @returns {void}
    */
-  subscribeAndConnect(params: {datachannelUrl: string; body: SubscribeRequest}): Promise<void>;
+  connectWebSocket(options: {webSocketUrl: string}): void;
   /**
    * Check if the WebSocket connection is connected
    * @returns {boolean}
@@ -37,16 +35,11 @@ interface IWebSocket {
    * @returns {Promise<void>}
    */
   disconnectWebSocket(): Promise<void>;
-  /**
-   * Get the subscriptionId for the connection
-   * @returns {string} subscriptionId
-   */
-  getSubscriptionId(): string | undefined;
   /**
    * Get data channel URL for the connection
    * @returns {string} data channel Url
    */
-  getDatachannelUrl(): string | undefined;
+  getWebSocketUrl(): string | undefined;
 }
 
 export default IWebSocket;
diff --git a/packages/@webex/plugin-cc/src/services/agent/index.ts b/packages/@webex/plugin-cc/src/services/agent/index.ts
new file mode 100644
index 00000000000..de5ee8ec1b4
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/agent/index.ts
@@ -0,0 +1,125 @@
+import * as Err from '../core/Err';
+import {createErrDetailsObject as err} from '../core/Utils';
+import * as Agent from './types';
+import AqmReqs from '../core/aqm-reqs';
+import {HTTP_METHODS} from '../../types';
+import {WCC_API_GATEWAY} from '../constants';
+import {CC_EVENTS} from '../config/types';
+
+/*
+ * routingAgent
+ * @param reqs
+ * @category Routing Service
+ */
+
+export default function routingAgent(routing: AqmReqs) {
+  return {
+    reload: routing.reqEmpty(() => ({
+      host: WCC_API_GATEWAY,
+      url: '/v1/agents/reload',
+      data: {},
+      err,
+      notifSuccess: {
+        bind: {
+          type: CC_EVENTS.AGENT_RELOGIN_SUCCESS,
+          data: {type: CC_EVENTS.AGENT_RELOGIN_SUCCESS},
+        },
+        msg: {} as Agent.ReloginSuccess,
+      },
+      notifFail: {
+        bind: {
+          type: CC_EVENTS.AGENT_RELOGIN_FAILED,
+          data: {type: CC_EVENTS.AGENT_RELOGIN_FAILED},
+        },
+        errId: 'Service.aqm.agent.reload',
+      },
+    })),
+    logout: routing.req((p: {data: Agent.Logout}) => ({
+      url: '/v1/agents/logout',
+      host: WCC_API_GATEWAY,
+      data: p.data,
+      err,
+      notifSuccess: {
+        bind: {
+          type: CC_EVENTS.AGENT_LOGOUT,
+          data: {type: CC_EVENTS.AGENT_LOGOUT_SUCCESS},
+        },
+        msg: {} as Agent.LogoutSuccess,
+      },
+      notifFail: {
+        bind: {
+          type: CC_EVENTS.AGENT_LOGOUT,
+          data: {type: CC_EVENTS.AGENT_LOGOUT_FAILED},
+        },
+        errId: 'Service.aqm.agent.logout',
+      },
+    })),
+    stationLogin: routing.req((p: {data: Agent.UserStationLogin}) => ({
+      url: '/v1/agents/login',
+      host: WCC_API_GATEWAY,
+      data: p.data,
+      err: /* istanbul ignore next */ (e: any) =>
+        new Err.Details('Service.aqm.agent.stationLogin', {
+          status: e.response?.status ?? 0,
+          type: e.response?.data?.errorType,
+          trackingId: e.response?.headers?.trackingid?.split('_')[1],
+        }),
+      notifSuccess: {
+        bind: {
+          type: CC_EVENTS.AGENT_STATION_LOGIN,
+          data: {type: CC_EVENTS.AGENT_STATION_LOGIN_SUCCESS},
+        },
+        msg: {} as Agent.StationLoginSuccess,
+      },
+      notifFail: {
+        bind: {
+          type: CC_EVENTS.AGENT_STATION_LOGIN,
+          data: {type: CC_EVENTS.AGENT_STATION_LOGIN_FAILED},
+        },
+        errId: 'Service.aqm.agent.stationLoginFailed',
+      },
+    })),
+    stateChange: routing.req((p: {data: Agent.StateChange}) => ({
+      url: '/v1/agents/session/state',
+      host: WCC_API_GATEWAY,
+      data: {...p.data, auxCodeId: p.data.auxCodeIdArray},
+      err,
+      method: HTTP_METHODS.PUT,
+      notifSuccess: {
+        bind: {
+          type: CC_EVENTS.AGENT_STATE_CHANGE,
+          data: {type: CC_EVENTS.AGENT_STATE_CHANGE_SUCCESS},
+        },
+        msg: {} as Agent.StateChangeSuccess,
+      },
+      notifFail: {
+        bind: {
+          type: CC_EVENTS.AGENT_STATE_CHANGE,
+          data: {type: CC_EVENTS.AGENT_STATE_CHANGE_FAILED},
+        },
+        errId: 'Service.aqm.agent.stateChange',
+      },
+    })),
+    buddyAgents: routing.req((p: {data: Agent.BuddyAgents}) => ({
+      url: `/v1/agents/buddyList`,
+      host: WCC_API_GATEWAY,
+      data: {...p.data},
+      err,
+      method: HTTP_METHODS.POST,
+      notifSuccess: {
+        bind: {
+          type: CC_EVENTS.AGENT_BUDDY_AGENTS,
+          data: {type: CC_EVENTS.AGENT_BUDDY_AGENTS_SUCCESS},
+        },
+        msg: {} as Agent.BuddyAgentsSuccess,
+      },
+      notifFail: {
+        bind: {
+          type: CC_EVENTS.AGENT_BUDDY_AGENTS,
+          data: {type: CC_EVENTS.AGENT_BUDDY_AGENTS_RETRIEVE_FAILED},
+        },
+        errId: 'Service.aqm.agent.BuddyAgentsRetrieveFailed',
+      },
+    })),
+  };
+}
diff --git a/packages/@webex/plugin-cc/src/services/agent/types.ts b/packages/@webex/plugin-cc/src/services/agent/types.ts
new file mode 100644
index 00000000000..49973b6e09e
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/agent/types.ts
@@ -0,0 +1,147 @@
+import {Msg} from '../core/GlobalTypes';
+
+export type LogoutSuccess = Msg<{
+  eventType: 'AgentDesktopMessage';
+  agentId: string;
+  trackingId: string;
+  agentSessionId: string;
+  orgId: string;
+  status: string;
+  subStatus: string;
+  loggedOutBy?: string;
+  roles?: string[];
+  type: 'AgentLogoutSuccess';
+}>;
+
+export type ReloginSuccess = Msg<{
+  eventType: 'AgentDesktopMessage';
+  agentId: string;
+  trackingId: string;
+  auxCodeId: string;
+  teamId: string;
+  agentSessionId: string;
+  dn: string;
+  orgId: string;
+  interactionIds: string[];
+  isExtension: boolean;
+  status: 'LoggedIn';
+  subStatus: 'Idle';
+  siteId: string;
+  lastIdleCodeChangeTimestamp: number;
+  lastStateChangeTimestamp: number;
+  lastStateChangeReason?: string;
+  profileType: string;
+  channelsMap: Record<string, string[]>;
+  dialNumber?: string;
+  roles?: string[];
+  deviceType?: DeviceType;
+  deviceId?: string | null;
+  isEmergencyModalAlreadyDisplayed?: boolean;
+  type: 'AgentReloginSuccess';
+}>;
+
+export type StateChangeSuccess = Msg<{
+  eventType: 'AgentDesktopMessage';
+  agentId: string;
+  trackingId: string;
+  auxCodeId: string;
+  agentSessionId: string;
+  orgId: string;
+  status: string;
+  subStatus: 'Available' | 'Idle';
+  lastIdleCodeChangeTimestamp: number;
+  lastStateChangeTimestamp: number;
+  type: 'AgentStateChangeSuccess';
+  changedBy: string | null;
+  changedById: string | null;
+  changedByName: string | null;
+  lastStateChangeReason: string;
+}>;
+
+export type StationLoginSuccess = Msg<{
+  eventType: 'AgentDesktopMessage';
+  agentId: string;
+  trackingId: string;
+  auxCodeId: string;
+  teamId: string;
+  agentSessionId: string;
+  orgId: string;
+  interactionIds: string[];
+  status: string;
+  subStatus: 'Available' | 'Idle';
+  siteId: string;
+  lastIdleCodeChangeTimestamp: number;
+  lastStateChangeTimestamp: number;
+  profileType: string;
+  channelsMap: Record<string, string[]>;
+  dialNumber?: string;
+  roles?: string[];
+  supervisorSessionId?: string;
+  type: 'AgentStationLoginSuccess';
+}>;
+
+export type DNRegistered = Msg<{
+  eventType: 'RoutingMessage';
+  agentId: string;
+  trackingId: string;
+  dn: string;
+  orgId: string;
+  type: 'AgentDNRegistered';
+}>;
+
+export type Logout = {logoutReason?: 'User requested logout' | 'Inactivity Logout'};
+
+export type StateChange = {
+  state: AgentState;
+  auxCodeIdArray: string;
+  lastStateChangeReason?: string;
+  agentId?: string;
+};
+
+export type AgentState = 'Available' | 'Idle' | 'RONA' | string;
+
+export type UserStationLogin = {
+  dialNumber?: string | null;
+  dn?: string | null;
+  teamId: string | null;
+  teamName: string | null;
+  roles?: Array<string>;
+  siteId: string;
+  usesOtherDN: boolean;
+  skillProfileId?: string;
+  auxCodeId: string;
+  isExtension?: boolean;
+  deviceType?: DeviceType;
+  deviceId?: string | null;
+  isEmergencyModalAlreadyDisplayed?: boolean;
+};
+
+export type LoginOption = 'AGENT_DN' | 'EXTENSION' | 'BROWSER';
+
+export type DeviceType = LoginOption | string;
+
+export type BuddyAgents = {
+  agentProfileId: string;
+  mediaType: string;
+  /** Filter for agent state eg : Available | Idle  */
+  state?: string;
+};
+
+export type BuddyDetails = {
+  agentId: string;
+  state: string;
+  teamId: string;
+  dn: string;
+  agentName: string;
+  siteId: string;
+};
+
+export type BuddyAgentsSuccess = Msg<{
+  eventType: string;
+  agentId: string;
+  trackingId: string;
+  agentSessionId: string;
+  orgId: string;
+  type: string;
+  agentList: Array<BuddyDetails>;
+}>;
diff --git a/packages/@webex/plugin-cc/src/AgentConfigService/AgentConfigService.ts b/packages/@webex/plugin-cc/src/services/config/index.ts
similarity index 73%
rename from packages/@webex/plugin-cc/src/AgentConfigService/AgentConfigService.ts
rename to packages/@webex/plugin-cc/src/services/config/index.ts
index 2fd144f7e14..7be743098e0 100644
--- a/packages/@webex/plugin-cc/src/AgentConfigService/AgentConfigService.ts
+++ b/packages/@webex/plugin-cc/src/services/config/index.ts
@@ -1,20 +1,19 @@
-import {WebexSDK, HTTP_METHODS} from '../types';
-import {DesktopProfileResponse, ListAuxCodesResponse, Team, AgentResponse} from './types';
-import HttpRequest from '../HttpRequest';
+import {WebexSDK, HTTP_METHODS, Team} from '../../types';
+import {DesktopProfileResponse, ListAuxCodesResponse, AgentResponse} from './types';
+import HttpRequest from '../core/HttpRequest';
+import {WCC_API_GATEWAY} from '../constants';
 
 export default class AgentConfigService {
   agentId: string;
   orgId: string;
   webex: WebexSDK;
-  wccAPIURL: string;
   httpReq: HttpRequest;
 
-  constructor(agentId: string, orgId: string, webex: WebexSDK, wccAPIURL: string) {
+  constructor(agentId: string, webex: WebexSDK, httpRequest: HttpRequest) {
     this.agentId = agentId;
-    this.orgId = orgId;
     this.webex = webex;
-    this.wccAPIURL = wccAPIURL;
-    this.httpReq = new HttpRequest(this.webex);
+    this.orgId = this.webex.internal.device.orgId;
+    this.httpReq = httpRequest;
   }
 
   /**
@@ -24,8 +23,11 @@ export default class AgentConfigService {
 
   public async getUserUsingCI(): Promise<AgentResponse> {
     try {
-      const URL = `${this.wccAPIURL}organization/${this.orgId}/user/by-ci-user-id/${this.agentId}`;
-      const response = await this.httpReq.request(URL, HTTP_METHODS.GET);
+      const response = await this.httpReq.request({
+        service: WCC_API_GATEWAY,
+        resource: `organization/${this.orgId}/user/by-ci-user-id/${this.agentId}`,
+        method: HTTP_METHODS.GET,
+      });
 
       if (response.statusCode !== 200) {
         throw new Error(`API call failed with ${response.statusCode}`);
@@ -47,8 +49,11 @@ export default class AgentConfigService {
 
   public async getDesktopProfileById(desktopProfileId: string): Promise<DesktopProfileResponse> {
     try {
-      const URL = `${this.wccAPIURL}organization/${this.orgId}/agent-profile/${desktopProfileId}`;
-      const response = await this.httpReq.request(URL, HTTP_METHODS.GET);
+      const response = await this.httpReq.request({
+        service: WCC_API_GATEWAY,
+        resource: `organization/${this.orgId}/agent-profile/${desktopProfileId}`,
+        method: HTTP_METHODS.GET,
+      });
 
       if (response.statusCode !== 200) {
         throw new Error(`API call failed with ${response.statusCode}`);
@@ -78,13 +83,15 @@ export default class AgentConfigService {
     attributes: string[]
   ): Promise<Team> {
     try {
-      const URL = `${this.wccAPIURL}organization/${
-        this.orgId
-      }/team?page=${page}&pageSize=${pageSize}${
+      const resource = `organization/${this.orgId}/team?page=${page}&pageSize=${pageSize}${
         filter && filter.length > 0 ? `&filter=id=in=${filter}` : ''
       }&attributes=${attributes}`;
 
-      const response = await this.httpReq.request(URL, HTTP_METHODS.GET);
+      const response = await this.httpReq.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.GET,
+      });
 
       if (response.statusCode !== 200) {
         throw new Error(`API call failed with ${response.statusCode}`);
@@ -103,7 +110,7 @@ export default class AgentConfigService {
    * @param {number} page Index of the page of results to be fetched. Defaults to 0.
    * @param {number} pageSize Number of items to be displayed on a page. Defaults to 10.
    * @param {Array<String>} filter Filter that can be applied to the elements to be fetched. Defaults to [].
-   * @param {Array<String>} attributes Specify the attributes to be returned. Defaults to ['id', 'name'].
+   * @param {Array<String>} attributes Specify the attributes to be returned. Defaults to ['id', 'name', 'active'].
    * @returns {Promise<ListAuxCodesResponse>} A promise that eventually resolves to an API response.
    */
 
@@ -114,13 +121,17 @@ export default class AgentConfigService {
     attributes: string[]
   ): Promise<ListAuxCodesResponse> {
     try {
-      const URL = `${this.wccAPIURL}organization/${
+      const resource = `organization/${
         this.orgId
       }/v2/auxiliary-code?page=${page}&pageSize=${pageSize}${
         filter && filter.length > 0 ? `&filter=id=in=${filter}` : ''
       }&attributes=${attributes}`;
 
-      const response = await this.httpReq.request(URL, HTTP_METHODS.GET);
+      const response = await this.httpReq.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.GET,
+      });
 
       if (response.statusCode !== 200) {
         throw new Error(`API call failed with ${response.statusCode}`);
diff --git a/packages/@webex/plugin-cc/src/services/config/types.ts b/packages/@webex/plugin-cc/src/services/config/types.ts
new file mode 100644
index 00000000000..d8f7be8e8d2
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/config/types.ts
@@ -0,0 +1,127 @@
+import {AuxCode, WelcomeEvent} from '../../types';
+import * as Agent from '../agent/types';
+
+type Enum<T extends Record<string, unknown>> = T[keyof T];
+
+// Define the CC_EVENTS object
+export const CC_EVENTS = {
+  WELCOME: 'Welcome',
+  AGENT_RELOGIN_SUCCESS: 'AgentReloginSuccess',
+  AGENT_RELOGIN_FAILED: 'AgentReloginFailed',
+  AGENT_LOGOUT: 'Logout',
+  AGENT_LOGOUT_SUCCESS: 'AgentLogoutSuccess',
+  AGENT_LOGOUT_FAILED: 'AgentLogoutFailed',
+  AGENT_STATION_LOGIN: 'StationLogin',
+  AGENT_STATION_LOGIN_SUCCESS: 'AgentStationLoginSuccess',
+  AGENT_STATION_LOGIN_FAILED: 'AgentStationLoginFailed',
+  AGENT_STATE_CHANGE: 'AgentStateChange',
+  AGENT_STATE_CHANGE_SUCCESS: 'AgentStateChangeSuccess',
+  AGENT_STATE_CHANGE_FAILED: 'AgentStateChangeFailed',
+  AGENT_BUDDY_AGENTS: 'BuddyAgents',
+  AGENT_BUDDY_AGENTS_SUCCESS: 'BuddyAgents',
+  AGENT_BUDDY_AGENTS_RETRIEVE_FAILED: 'BuddyAgentsRetrieveFailed',
+} as const;
+
+// Derive the type using the utility type
+export type CC_EVENTS = Enum<typeof CC_EVENTS>;
+
+export type WebSocketEvent = {
+  type: CC_EVENTS;
+  data:
+    | WelcomeEvent
+    | Agent.StationLoginSuccess
+    | Agent.LogoutSuccess
+    | Agent.ReloginSuccess
+    | Agent.StateChangeSuccess
+    | Agent.BuddyAgentsSuccess;
+};
+
+/**
+ * Represents the response from getUserUsingCI method.
+ *
+ * @public
+ */
+
+export type AgentResponse = {
+  /**
+   * The first name of the agent.
+   */
+  firstName: string;
+
+  /**
+   * The last name of the agent.
+   */
+  lastName: string;
+
+  /**
+   * Identifier for a Desktop Profile.
+   */
+  agentProfileId: string;
+
+  /**
+   * The email address of the agent.
+   */
+
+  email: string;
+
+  /**
+   * This Specify the teams id which got assigned to the agent.
+   */
+  teamIds: string[];
+};
+
+/**
+ * Represents the response from getDesktopProfileById method.
+ *
+ * @public
+ */
+export type DesktopProfileResponse = {
+  /**
+   * Represents the voice options of an agent.
+   */
+
+  loginVoiceOptions: string[];
+
+  /**
+   * Specify the wrap-up codes that the agents can select when they wrap up a contact. It can take one of these values: ALL - To make all wrap-up codes available. SPECIFIC - To make specific codes available.
+   */
+
+  accessWrapUpCode: string;
+
+  /**
+   * Specify the Idle codes that the agents can select in Agent Desktop. It can take one of these values: ALL - To make all wrap-up codes available. SPECIFIC - To make specific codes available.
+   */
+
+  accessIdleCode: string;
+
+  /**
+   * Specify the wrap-up codes list that the agents can select when they wrap up a contact.
+   */
+
+  wrapUpCodes: string[];
+
+  /**
+   * Specify the Idle codes list that the agents can select in Agent Desktop.
+   */
+
+  idleCodes: string[];
+};
+
+export type SubscribeResponse = {
+  statusCode: number;
+  body: {
+    webSocketUrl?: string;
+    subscriptionId?: string;
+  };
+  message: string | null;
+};
+
+/**
+ * Represents the response from getListOfAuxCodes method.
+ *
+ * @public
+ */
+
+export type ListAuxCodesResponse = {
+  data: AuxCode[];
+};
diff --git a/packages/@webex/plugin-cc/src/services/constants.ts b/packages/@webex/plugin-cc/src/services/constants.ts
new file mode 100644
index 00000000000..24198ef0e33
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/constants.ts
@@ -0,0 +1,9 @@
+export const WCC_API_GATEWAY = 'wcc-api-gateway';
+export const WEBSOCKET_EVENT_TIMEOUT = 20000;
+
+export const AGENT = 'agent';
+
+// CC GATEWAY API URL PATHS
+export const SUBSCRIBE_API = 'v1/notification/subscribe';
+export const LOGIN_API = 'v1/agents/login';
+export const WEB_RTC_PREFIX = 'webrtc-';
diff --git a/packages/@webex/plugin-cc/src/services/core/Err.ts b/packages/@webex/plugin-cc/src/services/core/Err.ts
new file mode 100644
index 00000000000..ef3c1a7c500
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/Err.ts
@@ -0,0 +1,97 @@
+import {WebexRequestPayload} from '../../types';
+import {Failure} from './GlobalTypes';
+
+export type ErrDetails = {status: number; type: string; trackingId: string};
+
+export type AgentErrorIds =
+  | {'Service.aqm.agent.stationLogin': ErrDetails}
+  | {'Service.aqm.agent.stationLoginFailed': Failure}
+  | {'Service.aqm.agent.stateChange': Failure}
+  | {'Service.aqm.agent.reload': Failure}
+  | {'Service.aqm.agent.logout': Failure}
+  | {'Service.reqs.generic.failure': {trackingId: string}}
+  | {'Service.aqm.agent.BuddyAgentsRetrieveFailed': Failure};
+
+export type ReqError =
+  | 'Service.aqm.reqs.GenericRequestError'
+  | {'Service.aqm.reqs.Pending': {key: string; msg: string}}
+  | {'Service.aqm.reqs.PendingEvent': {key: string}}
+  | {'Service.aqm.reqs.Timeout': {key: string; response: WebexRequestPayload}}
+  | {'Service.aqm.reqs.TimeoutEvent': {key: string}};
+
+export interface Ids {
+  'Service.aqm.agent': AgentErrorIds;
+  'Service.aqm.reqs': ReqError;
+}
+
+export type IdsGlobal =
+  | 'system' // to handle errors that was not created by 'new Err.WithId()'
+  | 'handle'
+  | 'fallback';
+
+export type IdsSub = Ids[keyof Ids];
+
+export type IdsMessage = IdsGlobal | keyof Ids | Exclude<IdsSub, object>;
+
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I
+) => void
+  ? I
+  : never;
+
+export type FlattenUnion<T> = {
+  [K in keyof UnionToIntersection<T>]: K extends keyof T
+    ? T[K] extends any[]
+      ? T[K]
+      : T[K] extends object
+      ? FlattenUnion<T[K]>
+      : T[K]
+    : UnionToIntersection<T>[K];
+};
+export type IdsDetailsType = FlattenUnion<Exclude<IdsSub, string>>;
+
+export type IdsDetails = keyof IdsDetailsType;
+
+export type Id = IdsMessage | IdsDetails;
+
+export class Message extends Error {
+  readonly id: Id;
+
+  constructor(id: IdsMessage);
+  constructor(id: IdsMessage, message: string);
+  constructor(id: IdsMessage, errror: Error);
+  constructor(id: IdsMessage, value?: string | Error) {
+    super();
+
+    this.id = id;
+    this.stack = new Error().stack!;
+
+    if (typeof value === 'string') {
+      this.message = value;
+    } else if (value instanceof Error) {
+      this.message = value.message;
+      this.name = value.name;
+    } else {
+      this.message = '';
+    }
+  }
+
+  // Marker to distinct Err class from other errors
+  private isErr = 'yes';
+}
+
+export class Details<T extends IdsDetails> extends Error {
+  readonly id: Id;
+  readonly details: IdsDetailsType[T];
+
+  constructor(id: T, details: IdsDetailsType[T]) {
+    super();
+
+    this.id = id;
+    this.stack = new Error().stack!;
+    this.details = details;
+  }
+
+  // Marker to distinct Err class from other errors
+  private isErr = 'yes';
+}
diff --git a/packages/@webex/plugin-cc/src/services/core/GlobalTypes.ts b/packages/@webex/plugin-cc/src/services/core/GlobalTypes.ts
new file mode 100644
index 00000000000..8995427fc32
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/GlobalTypes.ts
@@ -0,0 +1,14 @@
+export type Msg<T = any> = {
+  type: string;
+  orgId: string;
+  trackingId: string;
+  data: T;
+};
+
+export type Failure = Msg<{
+  agentId: string;
+  trackingId: string;
+  reasonCode: number;
+  orgId: string;
+  reason: string;
+}>;
diff --git a/packages/@webex/plugin-cc/src/services/core/HttpRequest.ts b/packages/@webex/plugin-cc/src/services/core/HttpRequest.ts
new file mode 100644
index 00000000000..2d320d58c02
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/HttpRequest.ts
@@ -0,0 +1,37 @@
+import {WebexSDK, HTTP_METHODS, IHttpResponse, RequestBody} from '../../types';
+
+class HttpRequest {
+  private webex: WebexSDK;
+  private static instance: HttpRequest;
+
+  public static getInstance(options?: {webex: WebexSDK}): HttpRequest {
+    if (!HttpRequest.instance && options && options.webex) {
+      HttpRequest.instance = new HttpRequest(options);
+    }
+
+    return HttpRequest.instance;
+  }
+
+  private constructor(options: {webex: WebexSDK}) {
+    const {webex} = options;
+    this.webex = webex;
+  }
+
+  public async request(options: {
+    service: string;
+    resource: string;
+    method: HTTP_METHODS;
+    body?: RequestBody;
+  }): Promise<IHttpResponse> {
+    const {service, resource, method, body} = options;
+
+    return this.webex.request({
+      service,
+      resource,
+      method,
+      body,
+    });
+  }
+}
+
+export default HttpRequest;
diff --git a/packages/@webex/plugin-cc/src/services/core/Utils.ts b/packages/@webex/plugin-cc/src/services/core/Utils.ts
new file mode 100644
index 00000000000..3228b88df98
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/Utils.ts
@@ -0,0 +1,24 @@
+import * as Err from './Err';
+import {WebexRequestPayload} from '../../types';
+import {Failure} from './GlobalTypes';
+import LoggerProxy from '../../logger-proxy';
+
+const getCommonErrorDetails = (errObj: WebexRequestPayload) => {
+  return {
+    trackingId: errObj?.headers?.trackingid || errObj?.headers?.TrackingID,
+    msg: errObj?.body,
+  };
+};
+
+export const getErrorDetails = (error: any, methodName: string) => {
+  const failure = error.details as Failure;
+  LoggerProxy.logger.error(`${methodName} failed with trackingId: ${failure?.trackingId}`);
+
+  return new Error(failure?.data?.reason ?? `Error while performing ${methodName}`);
+};
+
+export const createErrDetailsObject = (errObj: WebexRequestPayload) => {
+  const details = getCommonErrorDetails(errObj);
+
+  return new Err.Details('Service.reqs.generic.failure', details);
+};
diff --git a/packages/@webex/plugin-cc/src/services/core/WebSocket/WebSocketManager.ts b/packages/@webex/plugin-cc/src/services/core/WebSocket/WebSocketManager.ts
new file mode 100644
index 00000000000..bb42a3b6c18
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/WebSocket/WebSocketManager.ts
@@ -0,0 +1,170 @@
+import {WebexSDK, SubscribeRequest, HTTP_METHODS, WelcomeResponse} from '../../../types';
+import {SUBSCRIBE_API, WCC_API_GATEWAY} from '../../constants';
+import {SubscribeResponse} from '../../config/types';
+import LoggerProxy from '../../../logger-proxy';
+import workerScript from './keepalive.worker';
+import {KEEPALIVE_WORKER_INTERVAL, CLOSE_SOCKET_TIMEOUT} from '../constants';
+
+export class WebSocketManager extends EventTarget {
+  private websocket: WebSocket;
+  shouldReconnect: boolean;
+  isSocketClosed: boolean;
+  private isWelcomeReceived: boolean;
+  private url: string | null = null;
+  private forceCloseWebSocketOnTimeout: boolean;
+  private isConnectionLost: boolean;
+  private webex: WebexSDK;
+  private welcomePromiseResolve:
+    | ((value: WelcomeResponse | PromiseLike<WelcomeResponse>) => void)
+    | null = null;
+
+  private keepaliveWorker: Worker;
+
+  constructor(options: {webex: WebexSDK}) {
+    super();
+    const {webex} = options;
+    this.webex = webex;
+    this.shouldReconnect = true;
+    this.websocket = {} as WebSocket;
+    this.isSocketClosed = false;
+    this.isWelcomeReceived = false;
+    this.forceCloseWebSocketOnTimeout = false;
+    this.isConnectionLost = false;
+
+    const workerScriptBlob = new Blob([workerScript], {type: 'application/javascript'});
+    this.keepaliveWorker = new Worker(URL.createObjectURL(workerScriptBlob));
+  }
+
+  async initWebSocket(options: {body: SubscribeRequest}): Promise<WelcomeResponse> {
+    const connectionConfig = options.body;
+    await this.register(connectionConfig);
+
+    return new Promise((resolve, reject) => {
+      this.welcomePromiseResolve = resolve;
+      this.connect().catch((error) => {
+        LoggerProxy.logger.error(`[WebSocketStatus] | Error in connecting Websocket ${error}`);
+        reject(error);
+      });
+    });
+  }
+
+  close(shouldReconnect: boolean, reason = 'Unknown') {
+    if (!this.isSocketClosed && this.shouldReconnect) {
+      this.shouldReconnect = shouldReconnect;
+      this.websocket.close();
+      this.keepaliveWorker.postMessage({type: 'terminate'});
+      LoggerProxy.logger.error(
+        `[WebSocketStatus] | event=webSocketClose | WebSocket connection closed manually REASON: ${reason}`
+      );
+    }
+  }
+
+  private async register(connectionConfig: SubscribeRequest) {
+    try {
+      const subscribeResponse: SubscribeResponse = await this.webex.request({
+        service: WCC_API_GATEWAY,
+        resource: SUBSCRIBE_API,
+        method: HTTP_METHODS.POST,
+        body: connectionConfig,
+      });
+      this.url = subscribeResponse.body.webSocketUrl;
+    } catch (e) {
+      LoggerProxy.logger.error(
+        `Register API Failed, Request to RoutingNotifs websocket registration API failed ${e}`
+      );
+    }
+  }
+
+  private async connect() {
+    if (!this.url) {
+      return undefined;
+    }
+    LoggerProxy.logger.log(
+      `[WebSocketStatus] | event=webSocketConnecting | Connecting to WebSocket: ${this.url}`
+    );
+    this.websocket = new WebSocket(this.url);
+
+    return new Promise((resolve, reject) => {
+      this.websocket.onopen = () => {
+        this.isSocketClosed = false;
+        this.shouldReconnect = true;
+
+        this.websocket.send(JSON.stringify({keepalive: 'true'}));
+        this.keepaliveWorker.onmessage = (keepAliveEvent: {data: any}) => {
+          if (keepAliveEvent?.data?.type === 'keepalive') {
+            this.websocket.send(JSON.stringify({keepalive: 'true'}));
+          }
+
+          if (keepAliveEvent?.data?.type === 'closeSocket' && this.isConnectionLost) {
+            this.forceCloseWebSocketOnTimeout = true;
+            this.close(true, 'WebSocket did not auto close within 16 secs');
+            LoggerProxy.logger.error(
+              '[webSocketTimeout] | event=webSocketTimeout | WebSocket connection closed forcefully'
+            );
+          }
+        };
+
+        this.keepaliveWorker.postMessage({
+          type: 'start',
+          intervalDuration: KEEPALIVE_WORKER_INTERVAL, // Keepalive interval
+          isSocketClosed: this.isSocketClosed,
+          closeSocketTimeout: CLOSE_SOCKET_TIMEOUT, // Close socket timeout
+        });
+      };
+
+      this.websocket.onerror = (event: any) => {
+        LoggerProxy.logger.error(
+          `[WebSocketStatus] | event=socketConnectionFailed | WebSocket connection failed ${event}`
+        );
+        reject();
+      };
+
+      this.websocket.onclose = async (event: any) => {
+        this.webSocketOnCloseHandler(event);
+      };
+
+      this.websocket.onmessage = (e: MessageEvent) => {
+        this.dispatchEvent(new CustomEvent('message', {detail: e.data}));
+        const eventData = JSON.parse(e.data);
+
+        if (eventData.type === 'Welcome') {
+          this.isWelcomeReceived = true;
+          if (this.welcomePromiseResolve) {
+            this.welcomePromiseResolve(eventData.data as WelcomeResponse);
+            this.welcomePromiseResolve = null;
+          }
+        }
+
+        if (eventData.type === 'AGENT_MULTI_LOGIN') {
+          this.close(false, 'multiLogin');
+          LoggerProxy.logger.error(
+            '[WebSocketStatus] | event=agentMultiLogin | WebSocket connection closed by agent multiLogin'
+          );
+        }
+      };
+    });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private async webSocketOnCloseHandler(event: any) {
+    this.isSocketClosed = true;
+    this.keepaliveWorker.postMessage({type: 'terminate'});
+    if (this.shouldReconnect) {
+      this.dispatchEvent(new Event('socketClose'));
+      let issueReason;
+      if (this.forceCloseWebSocketOnTimeout) {
+        issueReason = 'WebSocket auto close timed out. Forcefully closed websocket.';
+      } else {
+        const onlineStatus = navigator.onLine;
+        LoggerProxy.logger.info(`[WebSocketStatus] | desktop online status is ${onlineStatus}`);
+        issueReason = !onlineStatus
+          ? 'network issue'
+          : 'missing keepalive from either desktop or notif service';
+      }
+      LoggerProxy.logger.error(
+        `[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: ${issueReason}`
+      );
+      this.forceCloseWebSocketOnTimeout = false;
+    }
+  }
+}
diff --git a/packages/@webex/plugin-cc/src/services/core/WebSocket/connection-service.ts b/packages/@webex/plugin-cc/src/services/core/WebSocket/connection-service.ts
new file mode 100644
index 00000000000..0d0184fd65e
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/WebSocket/connection-service.ts
@@ -0,0 +1,144 @@
+import {WebSocketManager} from './WebSocketManager';
+import {SubscribeRequest} from '../../../types';
+import LoggerProxy from '../../../logger-proxy';
+import {
+  LOST_CONNECTION_RECOVERY_TIMEOUT,
+  WS_DISCONNECT_ALLOWED,
+  CONNECTIVITY_CHECK_INTERVAL,
+} from '../constants';
+
+type ConnectionLostDetails = {
+  isConnectionLost: boolean;
+  isRestoreFailed: boolean;
+  isSocketReconnected: boolean;
+  isKeepAlive: boolean;
+};
+
+type ConnectionProp = {
+  lostConnectionRecoveryTimeout: number;
+};
+
+export class ConnectionService extends EventTarget {
+  private connectionProp: ConnectionProp = {
+    lostConnectionRecoveryTimeout: LOST_CONNECTION_RECOVERY_TIMEOUT,
+  };
+
+  private wsDisconnectAllowed = WS_DISCONNECT_ALLOWED;
+  private reconnectingTimer: ReturnType<typeof setTimeout>;
+  private restoreTimer: ReturnType<typeof setTimeout>;
+  private isConnectionLost: boolean;
+  private isRestoreFailed: boolean;
+  private isSocketReconnected: boolean;
+  private isKeepAlive: boolean;
+  private reconnectInterval: ReturnType<typeof setInterval>;
+  private webSocketManager: WebSocketManager;
+  private subscribeRequest: SubscribeRequest;
+
+  constructor(webSocketManager: WebSocketManager, subscribeRequest: SubscribeRequest) {
+    super();
+    this.webSocketManager = webSocketManager;
+    this.subscribeRequest = subscribeRequest;
+
+    this.isConnectionLost = false;
+    this.isRestoreFailed = false;
+    this.isSocketReconnected = false;
+    this.isKeepAlive = false;
+
+    this.webSocketManager.addEventListener('message', this.onPing);
+    this.webSocketManager.addEventListener('socketClose', this.onSocketClose);
+  }
+
+  private dispatchConnectionEvent(socketReconnected = false): void {
+    const event = new CustomEvent<ConnectionLostDetails>('connectionLost', {
+      detail: {
+        isConnectionLost: this.isConnectionLost,
+        isRestoreFailed: this.isRestoreFailed,
+        isSocketReconnected:
+          !this.webSocketManager.isSocketClosed && (socketReconnected || this.isSocketReconnected),
+        isKeepAlive: this.isKeepAlive,
+      },
+    });
+    this.dispatchEvent(event);
+  }
+
+  private handleConnectionLost = (): void => {
+    this.isConnectionLost = true;
+    this.dispatchConnectionEvent();
+  };
+
+  private clearTimerOnRestoreFailed = async () => {
+    if (this.reconnectInterval) {
+      clearInterval(this.reconnectInterval);
+    }
+  };
+
+  private handleRestoreFailed = async () => {
+    this.isRestoreFailed = true;
+    this.webSocketManager.shouldReconnect = false;
+    this.dispatchConnectionEvent();
+    await this.clearTimerOnRestoreFailed();
+  };
+
+  private updateConnectionData = (): void => {
+    this.isRestoreFailed = false;
+    this.isConnectionLost = false;
+    this.isSocketReconnected = false;
+  };
+
+  public setConnectionProp(prop: ConnectionProp): void {
+    this.connectionProp = prop;
+  }
+
+  private onPing = (event: Event): void => {
+    const msg = (event as CustomEvent<string>).detail;
+    const parsedEvent = JSON.parse(msg);
+    if (this.reconnectingTimer) {
+      clearTimeout(this.reconnectingTimer);
+    }
+    if (this.restoreTimer) {
+      clearTimeout(this.restoreTimer);
+    }
+    this.isKeepAlive = parsedEvent.keepalive === 'true';
+    const shouldUpdateConnectionData =
+      this.isKeepAlive || (this.isConnectionLost && !this.isRestoreFailed);
+    const shouldDispatchEvent =
+      this.isKeepAlive || (this.isConnectionLost && !this.isRestoreFailed);
+    const shouldDispatchEventWithReconnect = this.isSocketReconnected && this.isKeepAlive;
+
+    if (shouldUpdateConnectionData) {
+      this.updateConnectionData();
+    }
+
+    if (shouldDispatchEvent) {
+      this.dispatchConnectionEvent();
+    } else if (shouldDispatchEventWithReconnect) {
+      this.dispatchConnectionEvent(true);
+    }
+
+    this.reconnectingTimer = setTimeout(this.handleConnectionLost, this.wsDisconnectAllowed);
+    this.restoreTimer = setTimeout(
+      this.handleRestoreFailed,
+      this.connectionProp && this.connectionProp.lostConnectionRecoveryTimeout
+    );
+  };
+
+  private handleSocketClose = async (): Promise<void> => {
+    LoggerProxy.logger.info(`event=socketConnectionRetry | Trying to reconnect to notifs socket`);
+    const onlineStatus = navigator.onLine;
+    if (onlineStatus) {
+      await this.webSocketManager.initWebSocket({body: this.subscribeRequest});
+      await this.clearTimerOnRestoreFailed();
+      this.isSocketReconnected = true;
+    } else {
+      throw new Error('event=socketConnectionRetry | browser network not available');
+    }
+  };
+
+  private onSocketClose = (): void => {
+    this.clearTimerOnRestoreFailed();
+
+    this.reconnectInterval = setInterval(async () => {
+      await this.handleSocketClose();
+    }, CONNECTIVITY_CHECK_INTERVAL);
+  };
+}
diff --git a/packages/@webex/plugin-cc/src/services/core/WebSocket/keepalive.worker.js b/packages/@webex/plugin-cc/src/services/core/WebSocket/keepalive.worker.js
new file mode 100644
index 00000000000..1eaac795aeb
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/WebSocket/keepalive.worker.js
@@ -0,0 +1,88 @@
+// TODO: Try to find alternative to using Blob and script here
+const workerScript = `
+console.log("*** Keepalive Worker Thread ***");
+let intervalId, intervalDuration, timeOutId, isSocketClosed, closeSocketTimeout;
+let initialised = false;
+let initiateWebSocketClosure = false;
+
+const resetOfflineHandler = function () {
+  if (timeOutId) {
+    initialised = false;
+    clearTimeout(timeOutId);
+    timeOutId = null;
+  }
+};
+
+const checkOnlineStatus = function () {
+  const onlineStatus = navigator.onLine;
+  console.log(
+    \`[WebSocketStatus] event=checkOnlineStatus | timestamp=${new Date()}, UTC=${new Date().toUTCString()} | online status=\`,
+    onlineStatus
+  );
+  return onlineStatus;
+};
+
+// Checks network status and if it's offline then force closes WebSocket
+const checkNetworkStatus = function () {
+  const onlineStatus = checkOnlineStatus();
+  postMessage({ type: "keepalive", onlineStatus });
+  if (!onlineStatus && !initialised) {
+    initialised = true;
+    // Sets a timeout of 16s, checks if socket didn't close then it closes forcefully
+    timeOutId = setTimeout(() => {
+      if (!isSocketClosed) {
+        initiateWebSocketClosure = true;
+        postMessage({ type: "closeSocket" });
+      }
+    }, closeSocketTimeout);
+  }
+
+  if (onlineStatus && initialised) {
+    initialised = false;
+  }
+
+  if (initiateWebSocketClosure) {
+    initiateWebSocketClosure = false;
+    clearTimeout(timeOutId);
+    timeOutId = null;
+  }
+};
+
+addEventListener("message", (event) => {
+  if (event.data?.type === "start") {
+    intervalDuration = event.data?.intervalDuration || 4000;
+    closeSocketTimeout = event.data?.closeSocketTimeout || 5000;
+    console.log("event=Websocket startWorker | keepalive Worker started");
+    intervalId = setInterval(
+      (checkIfSocketClosed) => {
+        checkNetworkStatus();
+        isSocketClosed = checkIfSocketClosed;
+      },
+      intervalDuration,
+      event.data?.isSocketClosed
+    );
+
+    resetOfflineHandler();
+  }
+
+  if (event.data?.type === "terminate" && intervalId) {
+    console.log("event=Websocket terminateWorker | keepalive Worker stopped");
+    clearInterval(intervalId);
+    intervalId = null;
+    resetOfflineHandler();
+  }
+});
+
+// Listen for online and offline events
+self.addEventListener('online', () => {
+  console.log('Network status: online');
+  checkNetworkStatus();
+});
+
+self.addEventListener('offline', () => {
+  console.log('Network status: offline');
+  checkNetworkStatus();
+});
+`;
+
+export default workerScript;
diff --git a/packages/@webex/plugin-cc/src/services/core/aqm-reqs.ts b/packages/@webex/plugin-cc/src/services/core/aqm-reqs.ts
new file mode 100644
index 00000000000..762d51589e5
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/aqm-reqs.ts
@@ -0,0 +1,248 @@
+import {Msg} from './GlobalTypes';
+import * as Err from './Err';
+import {HTTP_METHODS, WebexRequestPayload} from '../../types';
+import {WebSocketManager} from './WebSocket/WebSocketManager';
+import HttpRequest from './HttpRequest';
+import LoggerProxy from '../../logger-proxy';
+import {CbRes, Conf, ConfEmpty, Pending, Req, Res, ResEmpty} from './types';
+import {TIMEOUT_REQ} from './constants';
+
+export default class AqmReqs {
+  private pendingRequests: Record<string, Pending> = {};
+  private pendingNotifCancelrequest: Record<string, Pending> = {};
+  private webSocketManager: WebSocketManager;
+  private httpRequest: HttpRequest;
+
+  constructor(webSocketManager: WebSocketManager) {
+    this.httpRequest = HttpRequest.getInstance();
+    this.webSocketManager = webSocketManager;
+    this.webSocketManager.addEventListener('message', this.onMessage);
+  }
+
+  req<TRes, TErr, TReq>(c: Conf<TRes, TErr, TReq>): Res<TRes, TReq> {
+    return (p: TReq, cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(p), cbRes);
+  }
+
+  reqEmpty<TRes, TErr>(c: ConfEmpty<TRes, TErr>): ResEmpty<TRes> {
+    return (cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(), cbRes);
+  }
+
+  private async makeAPIRequest<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>): Promise<TRes> {
+    return this.createPromise(c, cbRes);
+  }
+
+  private createPromise<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>) {
+    return new Promise<TRes>((resolve, reject) => {
+      const keySuccess = this.bindPrint(c.notifSuccess.bind);
+      const keyFail = c.notifFail ? this.bindPrint(c.notifFail.bind) : null;
+      const keyCancel = c.notifCancel?.bind ? this.bindPrint(c.notifCancel.bind) : null;
+      let k = '';
+      if (this.pendingRequests[keySuccess]) {
+        k = keySuccess;
+      }
+      if (keyFail && this.pendingRequests[keyFail]) {
+        k += keyFail;
+      }
+      if (k && c.timeout !== 'disabled') {
+        reject(
+          new Err.Details('Service.aqm.reqs.Pending', {
+            key: k,
+            msg: 'The request has been already created, multiple requests are not allowed.',
+          })
+        );
+
+        return;
+      }
+
+      let isClear = false;
+      const clear = () => {
+        delete this.pendingRequests[keySuccess];
+        if (keyFail) {
+          delete this.pendingRequests[keyFail];
+        }
+        if (keyCancel) {
+          delete this.pendingNotifCancelrequest[keyCancel];
+        }
+        isClear = true;
+      };
+
+      this.pendingRequests[keySuccess] = {
+        check: (msg: Msg) => this.bindCheck(c.notifSuccess.bind, msg),
+        handle: (msg: Msg) => {
+          clear();
+          resolve(msg as any);
+        },
+      };
+      if (keyCancel) {
+        this.pendingRequests[keySuccess].alternateBind = keyCancel;
+        this.pendingNotifCancelrequest[keyCancel] = {
+          check: (msg: Msg) => this.bindCheck(c.notifCancel?.bind, msg),
+          handle: (msg: Msg) => {
+            const alternateBindKey = this.pendingNotifCancelrequest[keyCancel].alternateBind;
+            if (alternateBindKey) {
+              this.pendingRequests[alternateBindKey].handle(msg);
+            }
+          },
+          alternateBind: keySuccess,
+        };
+      }
+
+      if (keyFail) {
+        this.pendingRequests[keyFail] = {
+          check: (msg: Msg) => this.bindCheck(c.notifFail!.bind, msg),
+          handle: (msg: Msg) => {
+            clear();
+            const notifFail = c.notifFail!;
+            if ('errId' in notifFail) {
+              LoggerProxy.logger.log(`Routing request failed: ${msg}`);
+              const eerr = new Err.Details(notifFail.errId, msg as any);
+              LoggerProxy.logger.log(`Routing request failed: ${eerr}`);
+              reject(eerr);
+            } else {
+              reject(notifFail.err(msg as any));
+            }
+          },
+        };
+      }
+      let response: WebexRequestPayload | null = null;
+      this.httpRequest
+        .request({
+          service: c.host ?? '',
+          resource: c.url,
+          // eslint-disable-next-line no-nested-ternary
+          method: c.method ? c.method : c.data ? HTTP_METHODS.POST : HTTP_METHODS.GET,
+
+          body: c.data,
+        })
+        .then((res: any) => {
+          response = res;
+          if (cbRes) {
+            cbRes(res);
+          }
+        })
+        .catch((error: WebexRequestPayload) => {
+          clear();
+          if (error?.headers) {
+            error.headers.Authorization = '*';
+          }
+          if (error?.headers) {
+            error.headers.Authorization = '*';
+          }
+          if (typeof c.err === 'function') {
+            reject(c.err(error));
+          } else if (typeof c.err === 'string') {
+            reject(new Err.Message(c.err));
+          } else {
+            reject(new Err.Message('Service.aqm.reqs.GenericRequestError'));
+          }
+        });
+
+      if (c.timeout !== 'disabled') {
+        window.setTimeout(
+          () => {
+            if (isClear) {
+              return;
+            }
+            clear();
+            if (response?.headers) {
+              response.headers.Authorization = '*';
+            }
+            LoggerProxy.logger.error(`Routing request timeout${keySuccess}${response!}${c.url}`);
+            reject(
+              new Err.Details('Service.aqm.reqs.Timeout', {
+                key: keySuccess,
+                response: response!,
+              })
+            );
+          },
+          c.timeout && c.timeout > 0 ? c.timeout : TIMEOUT_REQ
+        );
+      }
+    });
+  }
+
+  private bindPrint(bind: any) {
+    let result = '';
+    // eslint-disable-next-line no-restricted-syntax
+    for (const k in bind) {
+      if (Array.isArray(bind[k])) {
+        result += `${k}=[${bind[k].join(',')}],`;
+      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
+        result += `${k}=(${this.bindPrint(bind[k])}),`;
+      } else {
+        result += `${k}=${bind[k]},`;
+      }
+    }
+
+    return result ? result.slice(0, -1) : result;
+  }
+
+  private bindCheck(bind: any, msg: any) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const k in bind) {
+      if (Array.isArray(bind[k])) {
+        // Check if the message value matches any of the values in the array
+        if (!bind[k].includes(msg[k])) {
+          return false;
+        }
+      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
+        if (typeof msg[k] === 'object' && msg[k] !== null) {
+          if (!this.bindCheck(bind[k], msg[k])) {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      } else if (!msg[k] || msg[k] !== bind[k]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // must be lambda
+  private readonly onMessage = (msg: any) => {
+    const event = JSON.parse(msg.detail);
+    if (event.type === 'Welcome') {
+      LoggerProxy.logger.info(`Welcome message from Notifs Websocket`);
+
+      return;
+    }
+
+    if (event.keepalive === 'true') {
+      LoggerProxy.logger.info(`Keepalive from web socket`);
+
+      return;
+    }
+
+    let isHandled = false;
+
+    const kReq = Object.keys(this.pendingRequests);
+    for (const thisReq of kReq) {
+      const req = this.pendingRequests[thisReq];
+      if (req.check(event)) {
+        req.handle(event);
+        isHandled = true;
+        break;
+      }
+    }
+    // pendingNotifCancelrequest stores the secondary bind key, checks for the secondary bind key and handles the event
+    const kReqAlt = Object.keys(this.pendingNotifCancelrequest);
+    for (const thisReq of kReqAlt) {
+      const req = this.pendingNotifCancelrequest[thisReq];
+      if (req.check(event)) {
+        req.handle(event);
+        isHandled = true;
+      }
+    }
+
+    // TODO:  add event emitter for unhandled events to replicate event.listen or .on
+
+    if (!isHandled) {
+      LoggerProxy.logger.info(
+        `event=missingEventHandler | [AqmReqs] missing routing message handler`
+      );
+    }
+  };
+}
diff --git a/packages/@webex/plugin-cc/src/services/core/constants.ts b/packages/@webex/plugin-cc/src/services/core/constants.ts
new file mode 100644
index 00000000000..a5c6cc95ab8
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/constants.ts
@@ -0,0 +1,11 @@
+export const KEEPALIVE_WORKER_INTERVAL = 4000;
+export const NOTIFS_RESOLVE_DELAY = 1200;
+export const CLOSE_SOCKET_TIMEOUT_DURATION = 16000;
+export const PING_API_URL = '/health';
+export const WELCOME_TIMEOUT = 30000;
+export const RTD_PING_EVENT = 'rtd-online-status';
+export const TIMEOUT_REQ = 20000;
+export const LOST_CONNECTION_RECOVERY_TIMEOUT = 20000;
+export const WS_DISCONNECT_ALLOWED = 8000;
+export const CONNECTIVITY_CHECK_INTERVAL = 5000;
+export const CLOSE_SOCKET_TIMEOUT = 16000;
diff --git a/packages/@webex/plugin-cc/src/services/core/types.ts b/packages/@webex/plugin-cc/src/services/core/types.ts
new file mode 100644
index 00000000000..59b83a91992
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/core/types.ts
@@ -0,0 +1,48 @@
+import {HTTP_METHODS, RequestBody, WebexRequestPayload} from '../../types';
+import * as Err from './Err';
+import {Msg} from './GlobalTypes';
+
+export type Pending = {
+  check: (msg: Msg) => boolean;
+  handle: (msg: Msg) => void;
+  alternateBind?: string;
+};
+
+export type BindType = string | string[] | {[key: string]: BindType};
+interface Bind {
+  type: BindType;
+  data?: any;
+}
+
+export type Timeout = number | 'disabled';
+
+export type Req<TRes, TErr> = {
+  url: string;
+  host?: string;
+  method?: HTTP_METHODS;
+  err?:
+    | ((errObj: WebexRequestPayload) => Err.Details<'Service.reqs.generic.failure'>)
+    | Err.IdsMessage
+    | ((e: WebexRequestPayload) => Err.Message | Err.Details<Err.IdsDetails>);
+  notifSuccess: {bind: Bind; msg: TRes};
+  notifFail?:
+    | {
+        bind: Bind;
+        errMsg: TErr;
+        err: (e: TErr) => Err.Details<Err.IdsDetails>;
+      }
+    | {
+        bind: Bind;
+        errId: Err.IdsDetails;
+      };
+  data?: RequestBody;
+  headers?: Record<string, string>;
+  timeout?: Timeout;
+  notifCancel?: {bind: Bind; msg: TRes};
+};
+
+export type Conf<TRes, TErr, TReq> = (p: TReq) => Req<TRes, TErr>;
+export type ConfEmpty<TRes, TErr> = () => Req<TRes, TErr>;
+export type Res<TRes, TReq> = (p: TReq, cbRes?: CbRes<TRes>) => Promise<TRes>;
+export type ResEmpty<TRes> = (cbRes?: CbRes<TRes>) => Promise<TRes>;
+export type CbRes<TRes> = (res: any) => void | TRes;
diff --git a/packages/@webex/plugin-cc/src/services/index.ts b/packages/@webex/plugin-cc/src/services/index.ts
new file mode 100644
index 00000000000..67fc11023b7
--- /dev/null
+++ b/packages/@webex/plugin-cc/src/services/index.ts
@@ -0,0 +1,21 @@
+import routingAgent from './agent';
+import AqmReqs from './core/aqm-reqs';
+import {WebSocketManager} from './core/WebSocket/WebSocketManager';
+
+export default class Services {
+  public readonly agent: ReturnType<typeof routingAgent>;
+  private static instance: Services;
+
+  constructor(webSocketManager: WebSocketManager) {
+    const aqmReq = new AqmReqs(webSocketManager);
+    this.agent = routingAgent(aqmReq);
+  }
+
+  public static getInstance(webSocketManager: WebSocketManager): Services {
+    if (!this.instance) {
+      this.instance = new Services(webSocketManager);
+    }
+
+    return this.instance;
+  }
+}
diff --git a/packages/@webex/plugin-cc/src/types.ts b/packages/@webex/plugin-cc/src/types.ts
index 31c2d8c3fb4..990bdb306ad 100644
--- a/packages/@webex/plugin-cc/src/types.ts
+++ b/packages/@webex/plugin-cc/src/types.ts
@@ -1,4 +1,5 @@
-import {IAgentProfile} from './AgentConfig/types';
+import {CallingClientConfig} from '@webex/calling';
+import * as Agent from './services/agent/types';
 
 type Enum<T extends Record<string, unknown>> = T[keyof T];
 
@@ -14,7 +15,9 @@ export const HTTP_METHODS = {
 // Derive the type using the utility type
 export type HTTP_METHODS = Enum<typeof HTTP_METHODS>;
 
-type WebexRequestPayload = {
+export type WebexRequestPayload = {
+  service?: string;
+  resource?: string;
   method?: HTTP_METHODS;
   uri?: string;
   addAuthHeader?: boolean;
@@ -50,8 +53,18 @@ export interface CCPluginConfig {
     enable: boolean;
     verboseEvents: boolean;
   };
+  callingClientConfig: CallingClientConfig;
 }
 
+export type Logger = {
+  log: (payload: string) => void;
+  error: (payload: string) => void;
+  warn: (payload: string) => void;
+  info: (payload: string) => void;
+  trace: (payload: string) => void;
+  debug: (payload: string) => void;
+};
+
 export interface WebexSDK {
   version: string;
   canAuthorize: boolean;
@@ -90,21 +103,13 @@ export interface WebexSDK {
         'ucmgmt-gateway': string;
         contactsService: string;
       };
-      get(name: string, priorityHost?: boolean, serviceGroup?: string): string;
     };
     metrics: {
       submitClientMetrics: (name: string, data: unknown) => void;
     };
   };
   // public plugins
-  logger: {
-    log: (payload: string) => void;
-    error: (payload: string) => void;
-    warn: (payload: string) => void;
-    info: (payload: string) => void;
-    trace: (payload: string) => void;
-    debug: (payload: string) => void;
-  };
+  logger: Logger;
 }
 
 /**
@@ -112,28 +117,10 @@ export interface WebexSDK {
  * The `ContactCenter` package is designed to provide a set of APIs to perform various operations for the Agent flow within Webex Contact Center.
  */
 export interface IContactCenter {
-  /**
-   * @ignore
-   */
-  $config: CCPluginConfig;
-  /**
-   * @ignore
-   */
-  $webex: WebexSDK;
-  /**
-   * WCC API Gateway Url
-   */
-  wccApiUrl: string;
   /**
    * This will be public API used for making the CC SDK ready by setting up the cc mercury connection.
    */
   register(): Promise<IAgentProfile>;
-
-  /**
-   * This will be public API used for unregistering the CC SDK by disconnecting the cc mercury connection
-   * @returns Promise<void>
-   */
-  unregister(): Promise<void>;
 }
 
 export interface IHttpResponse {
@@ -144,26 +131,190 @@ export interface IHttpResponse {
   url: string;
 }
 
-// Define the CC_EVENTS object
-export const CC_EVENTS = {
-  WELCOME: 'Welcome',
+export const LoginOption = {
+  AGENT_DN: 'AGENT_DN',
+  EXTENSION: 'EXTENSION',
+  BROWSER: 'BROWSER',
 } as const;
 
 // Derive the type using the utility type
-export type CC_EVENTS = Enum<typeof CC_EVENTS>;
+export type LoginOption = Enum<typeof LoginOption>;
 
-export interface WebSocketEvent {
-  type: CC_EVENTS;
-  data: {
-    agentId: string;
-  };
-}
+export type WelcomeEvent = {
+  agentId: string;
+};
+
+export type WelcomeResponse = WelcomeEvent | Error;
 
-export interface SubscribeRequest {
+export type SubscribeRequest = {
   force: boolean;
   isKeepAliveEnabled: boolean;
   clientType: string;
   allowMultiLogin: boolean;
-}
+};
+
+/**
+ * Represents the response from getListOfTeams method.
+ *
+ * @public
+ */
+export type Team = {
+  /**
+   * ID of the team.
+   */
+  id: string;
+
+  /**
+   *  Name of the Team.
+   */
+  name: string;
+};
+
+/**
+ * Represents AuxCode.
+ * @public
+ */
+
+export type AuxCode = {
+  /**
+   * ID of the Auxiliary Code.
+   */
+  id: string;
+
+  /**
+   * Indicates whether the auxiliary code is active or not active.
+   */
+  active: boolean;
+
+  /**
+   * Indicates whether this is the default code (true) or not (false).
+   */
+  defaultCode: boolean;
+
+  /**
+   * Indicates whether this is the system default code (true) or not (false).
+   */
+  isSystemCode: boolean;
+
+  /**
+   * A short description indicating the context of the code.
+   */
+  description: string;
+
+  /**
+   * Name for the Auxiliary Code.
+   */
+  name: string;
+
+  /**
+   * Indicates the work type associated with this code..
+   */
+
+  workTypeCode: string;
+};
+
+/**
+ * Represents the response from AgentConfig.
+ *
+ * @public
+ */
+export type IAgentProfile = {
+  /**
+   * The id of the agent.
+   */
+
+  agentId: string;
+
+  /**
+   * The name of the agent.
+   */
+  agentName: string;
+
+  /**
+   * Identifier for a Desktop Profile.
+   */
+  agentProfileId: string;
+
+  /**
+   * The email address of the agent.
+   */
+
+  agentMailId: string;
+
+  /**
+   * Represents list of teams of an agent.
+   */
+  teams: Team[];
+
+  /**
+   * Represents the voice options of an agent.
+   */
+
+  loginVoiceOptions: string[];
+
+  /**
+   * Represents the Idle codes list that the agents can select in Agent Desktop.t.
+   */
+
+  idleCodes: AuxCode[];
+
+  /**
+   * Represents the wrap-up codes list that the agents can select when they wrap up a contact.
+   */
+  wrapUpCodes: AuxCode[];
+};
 
 export type EventResult = IAgentProfile;
+
+/**
+ * Represents the request to a AgentLogin
+ *
+ * @public
+ */
+export type AgentLogin = {
+  /**
+   * A dialNumber field contains the number to dial such as a route point or extension.
+   */
+
+  dialNumber?: string;
+
+  /**
+   * The unique ID representing a team of users.
+   */
+
+  teamId: string;
+
+  /**
+   * The loginOption field contains the type of login.
+   */
+
+  loginOption: LoginOption;
+};
+export type RequestBody =
+  | SubscribeRequest
+  | Agent.Logout
+  | Agent.UserStationLogin
+  | Agent.StateChange
+  | Agent.BuddyAgents;
+
+/**
+ * Represents the options to fetch buddy agents for the logged in agent.
+ * @public
+ */
+export type BuddyAgents = {
+  /**
+   * The media type for the request. The supported values are telephony, chat, social and email.
+   */
+  mediaType: 'telephony' | 'chat' | 'social' | 'email';
+  /**
+   * It represents the current state of the returned agents which can be either Available or Idle.
+   * If state is omitted, the API will return a list of both available and idle agents.
+   * This is useful for consult scenarios, since consulting an idle agent is also supported.
+   */
+  state?: 'Available' | 'Idle';
+};
+
+export type StationLoginResponse = Agent.StationLoginSuccess | Error;
+export type StationLogoutResponse = Agent.LogoutSuccess | Error;
+export type StationReLoginResponse = Agent.ReloginSuccess | Error;
+export type BuddyAgentsResponse = Agent.BuddyAgentsSuccess | Error;
diff --git a/packages/@webex/plugin-cc/test/unit/spec/AgentConfig/AgentConfig.ts b/packages/@webex/plugin-cc/test/unit/spec/AgentConfig/AgentConfig.ts
deleted file mode 100644
index 3e79c74a2ca..00000000000
--- a/packages/@webex/plugin-cc/test/unit/spec/AgentConfig/AgentConfig.ts
+++ /dev/null
@@ -1,344 +0,0 @@
-import { IAgentProfile } from '../../../../src/AgentConfig/types';
-import AgentConfigService from '../../../../src/AgentConfigService/AgentConfigService';
-import { WebexSDK } from '../../../../src/types';
-import { WORK_TYPE_CODE } from '../../../../src/AgentConfig/types';
-import AgentConfig from '../../../../src/AgentConfig/AgentConfig';
-import {
-  DesktopProfileResponse,
-  ListAuxCodesResponse,
-  Team,
-  AgentResponse,
-} from '../../../../src/AgentConfigService/types';
-
-const mockWebex: WebexSDK = {
-  internal: {
-    device: {
-      orgId: 'testOrgId',
-    },
-  },
-};
-
-const mockAgentResponse: AgentResponse = {
-  firstName: 'John',
-  lastName: 'Doe',
-  agentProfileId: 'profile123',
-  email: 'john.doe@example.com',
-  teamIds: ['team1', 'team2'],
-};
-
-const mockDesktopProfileResponse: DesktopProfileResponse = {
-  loginVoiceOptions: ['option1', 'option2'],
-  accessWrapUpCode: 'ALL',
-  accessIdleCode: 'ALL',
-  wrapUpCodes: [],
-  idleCodes: [],
-};
-
-const mockTeamsListResponse: Team[] = [{ id: '123', name: 'Team 1' }];
-
-const mockAuxCodesResponse: ListAuxCodesResponse = {
-  data: [
-    { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,},
-    { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE,}
-  ],
-};
-
-describe('AgentConfig', () => {
-  let agentConfig: AgentConfig;
-  let getUserUsingCISpy: jest.SpyInstance;
-  let getDesktopProfileByIdSpy: jest.SpyInstance;
-  let getListOfTeamsSpy: jest.SpyInstance;
-  let getListOfAuxCodesSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    agentConfig = new AgentConfig('agent123', mockWebex, 'http://api.url');
-
-    getUserUsingCISpy = jest.spyOn(AgentConfigService.prototype, 'getUserUsingCI').mockResolvedValue(mockAgentResponse);
-    getDesktopProfileByIdSpy = jest.spyOn(AgentConfigService.prototype, 'getDesktopProfileById').mockResolvedValue(mockDesktopProfileResponse);
-    getListOfAuxCodesSpy = jest.spyOn(AgentConfigService.prototype, 'getListOfAuxCodes').mockResolvedValue(mockAuxCodesResponse);
-    getListOfTeamsSpy = jest.spyOn(AgentConfigService.prototype, 'getListOfTeams').mockResolvedValue(mockTeamsListResponse);
-  });
-
-  it('should fetch agent profile successfully', async () => {
-    const page = 0;
-    const pageSize = 10;
-    const auxCodeFilter = [...mockDesktopProfileResponse.idleCodes, ...mockDesktopProfileResponse.wrapUpCodes];
-    const attributes = ['id', 'name'];
-
-    const expectedProfile: IAgentProfile = {
-      agentId: 'agent123',
-      agentName: 'John Doe',
-      agentProfileId: 'profile123',
-      agentMailId: 'john.doe@example.com',
-      teams: mockTeamsListResponse,
-      loginVoiceOptions: ['option1', 'option2'],
-      wrapUpCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE}],
-      idleCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE}]
-    };
-
-    const result = await agentConfig.getAgentProfile();
-
-    expect(getUserUsingCISpy).toHaveBeenCalledTimes(1);
-    expect(getUserUsingCISpy).toHaveBeenCalledWith();
-
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledTimes(1);
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledWith(mockAgentResponse.agentProfileId);
-
-    expect(getListOfTeamsSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfTeamsSpy).toHaveBeenCalledWith(page, pageSize, mockAgentResponse.teamIds, attributes);
-
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledWith(page, pageSize, auxCodeFilter, attributes);
-
-    expect(result).toEqual(expectedProfile);
-  });
-
-  it('should handle errors when fetching agent profile', async () => {
-    getUserUsingCISpy.mockRejectedValue(new Error('Network error'));
-
-    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
-      'Fetching Agent Profile failed: Network error'
-    );
-  });
-
-  it('should handle errors when fetching desktop profile', async () => {
-    getDesktopProfileByIdSpy.mockRejectedValue(new Error('API error'));
-
-    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
-      'Fetching Agent Profile failed: API error'
-    );
-  });
-
-  it('should handle errors when fetching list of teams', async () => {
-    getListOfTeamsSpy.mockRejectedValue(new Error('API error'));
-
-    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
-      'Fetching Agent Profile failed: API error'
-    );
-  });
-
-  it('should handle errors when fetching list of aux codes', async () => {
-    getListOfAuxCodesSpy.mockRejectedValue(new Error('API error'));
-
-    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
-      'Fetching Agent Profile failed: API error'
-    );
-  });
-
-  it('should handle both accessIdleCode and accessWrapUpCode as ALL', async () => {
-
-    const page = 0;
-    const pageSize = 10;
-    const auxCodeFilter = [...mockDesktopProfileResponse.idleCodes, ...mockDesktopProfileResponse.wrapUpCodes];
-    const attributes = ['id', 'name'];
-
-    const allDesktopProfileResponse: DesktopProfileResponse = {
-      loginVoiceOptions: ['option1', 'option2'],
-      accessWrapUpCode: 'ALL',
-      accessIdleCode: 'ALL',
-      wrapUpCodes: [],
-      idleCodes: [],
-    };
-
-    getDesktopProfileByIdSpy.mockResolvedValue(allDesktopProfileResponse);
-
-    const allAuxCodesResponse: ListAuxCodesResponse = {
-      data: [
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE},
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE}
-      ],
-    };
-
-    getListOfAuxCodesSpy.mockResolvedValue(allAuxCodesResponse);
-
-    const expectedProfile: IAgentProfile = {
-      agentId: 'agent123',
-      agentName: 'John Doe',
-      agentProfileId: 'profile123',
-      agentMailId: 'john.doe@example.com',
-      teams: mockTeamsListResponse,
-      loginVoiceOptions: ['option1', 'option2'],
-      wrapUpCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE}],
-      idleCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE}]
-    };
-
-    const result = await agentConfig.getAgentProfile();
-
-    expect(getUserUsingCISpy).toHaveBeenCalledTimes(1);
-    expect(getUserUsingCISpy).toHaveBeenCalledWith();
-
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledTimes(1);
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledWith(mockAgentResponse.agentProfileId);
-
-    expect(getListOfTeamsSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfTeamsSpy).toHaveBeenCalledWith(page, pageSize, mockAgentResponse.teamIds, attributes);
-
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledWith(page, pageSize, auxCodeFilter, attributes);
-
-    expect(result).toEqual(expectedProfile);
-  });
-
-  it('should handle SPECIFIC accessIdleCode and accessWrapUpCode', async () => {
-
-    const specificDesktopProfileResponse: DesktopProfileResponse = {
-      loginVoiceOptions: ['option1', 'option2'],
-      accessWrapUpCode: 'SPECIFIC',
-      accessIdleCode: 'SPECIFIC',
-      wrapUpCodes: ['aux1'],
-      idleCodes: ['aux2'],
-    };
-
-    const page = 0;
-    const pageSize = 10;
-    const auxCodeFilter = [specificDesktopProfileResponse.wrapUpCodes, specificDesktopProfileResponse.idleCodes];
-    const attributes = ['id', 'name'];
-
-    getDesktopProfileByIdSpy.mockResolvedValue(specificDesktopProfileResponse);
-
-    const specificAuxCodesResponse: ListAuxCodesResponse = {
-      data: [
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,},
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE,}
-      ],
-    };
-
-    getListOfAuxCodesSpy.mockResolvedValue(specificAuxCodesResponse);
-
-    const expectedProfile: IAgentProfile = {
-      agentId: 'agent123',
-      agentName: 'John Doe',
-      agentProfileId: 'profile123',
-      agentMailId: 'john.doe@example.com',
-      teams: mockTeamsListResponse,
-      loginVoiceOptions: ['option1', 'option2'],
-      wrapUpCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE}],
-      idleCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE}]
-    };
-
-    const result = await agentConfig.getAgentProfile();
-
-    expect(getUserUsingCISpy).toHaveBeenCalledTimes(1);
-    expect(getUserUsingCISpy).toHaveBeenCalledWith();
-
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledTimes(1);
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledWith(mockAgentResponse.agentProfileId);
-
-    expect(getListOfTeamsSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfTeamsSpy).toHaveBeenCalledWith(page, pageSize, mockAgentResponse.teamIds, attributes);
-
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledWith(page, pageSize, auxCodeFilter, attributes);
-
-    expect(result).toEqual(expectedProfile);
-  });
-
-  it('should handle accessIdleCode as ALL and accessWrapUpCode as SPECIFIC', async () => {
-
-    const page = 0;
-    const pageSize = 10;
-    const auxCodeFilter = [...mockDesktopProfileResponse.idleCodes, ...mockDesktopProfileResponse.wrapUpCodes];
-    const attributes = ['id', 'name'];
-
-    const mixedDesktopProfileResponse: DesktopProfileResponse = {
-      loginVoiceOptions: ['option1', 'option2'],
-      accessWrapUpCode: 'SPECIFIC',
-      accessIdleCode: 'ALL',
-      wrapUpCodes: ['aux1'],
-      idleCodes: [],
-    };
-
-    getDesktopProfileByIdSpy.mockResolvedValue(mixedDesktopProfileResponse);
-
-    const mixedAuxCodesResponse: ListAuxCodesResponse = {
-      data: [
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,},
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE,}
-      ],
-    };
-
-    getListOfAuxCodesSpy.mockResolvedValue(mixedAuxCodesResponse);
-
-    const expectedProfile: IAgentProfile = {
-      agentId: 'agent123',
-      agentName: 'John Doe',
-      agentProfileId: 'profile123',
-      agentMailId: 'john.doe@example.com',
-      teams: mockTeamsListResponse,
-      loginVoiceOptions: ['option1', 'option2'],
-      wrapUpCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE}],
-      idleCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE}]
-    };
-
-    const result = await agentConfig.getAgentProfile();
-
-    expect(getUserUsingCISpy).toHaveBeenCalledTimes(1);
-    expect(getUserUsingCISpy).toHaveBeenCalledWith();
-
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledTimes(1);
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledWith(mockAgentResponse.agentProfileId);
-
-    expect(getListOfTeamsSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfTeamsSpy).toHaveBeenCalledWith(page, pageSize, mockAgentResponse.teamIds, attributes);
-
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledWith(page, pageSize, auxCodeFilter, attributes);
-
-    expect(result).toEqual(expectedProfile);
-  });
-
-  it('should handle accessIdleCode as SPECIFIC and accessWrapUpCode as ALL', async () => {
-
-    const page = 0;
-    const pageSize = 10;
-    const auxCodeFilter = [...mockDesktopProfileResponse.idleCodes, ...mockDesktopProfileResponse.wrapUpCodes];
-    const attributes = ['id', 'name'];
-
-    const mixedDesktopProfileResponse: DesktopProfileResponse = {
-      loginVoiceOptions: ['option1', 'option2'],
-      accessWrapUpCode: 'ALL',
-      accessIdleCode: 'SPECIFIC',
-      wrapUpCodes: [],
-      idleCodes: ['aux2'],
-    };
-
-    getDesktopProfileByIdSpy.mockResolvedValue(mixedDesktopProfileResponse);
-
-    const mixedAuxCodesResponse: ListAuxCodesResponse = {
-      data: [
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,},
-        { id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE,}
-      ],
-    };
-
-    getListOfAuxCodesSpy.mockResolvedValue(mixedAuxCodesResponse);
-
-    const expectedProfile: IAgentProfile = {
-      agentId: 'agent123',
-      agentName: 'John Doe',
-      agentProfileId: 'profile123',
-      agentMailId: 'john.doe@example.com',
-      teams: mockTeamsListResponse,
-      loginVoiceOptions: ['option1', 'option2'],
-      wrapUpCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE}],
-      idleCodes: [{id: 'aux1', active: true, defaultCode: true, isSystemCode: true, description: 'test', name: 'testName', workTypeCode: WORK_TYPE_CODE.IDLE_CODE}]
-    };
-
-    const result = await agentConfig.getAgentProfile();
-
-    expect(getUserUsingCISpy).toHaveBeenCalledTimes(1);
-    expect(getUserUsingCISpy).toHaveBeenCalledWith();
-
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledTimes(1);
-    expect(getDesktopProfileByIdSpy).toHaveBeenCalledWith(mockAgentResponse.agentProfileId);
-
-    expect(getListOfTeamsSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfTeamsSpy).toHaveBeenCalledWith(page, pageSize, mockAgentResponse.teamIds, attributes);
-
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledTimes(1);
-    expect(getListOfAuxCodesSpy).toHaveBeenCalledWith(page, pageSize, auxCodeFilter, attributes);
-
-    expect(result).toEqual(expectedProfile);
-  });
-});
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/test/unit/spec/AgentConfigService/AgentConfigService.ts b/packages/@webex/plugin-cc/test/unit/spec/AgentConfigService/AgentConfigService.ts
deleted file mode 100644
index 52e98570d1a..00000000000
--- a/packages/@webex/plugin-cc/test/unit/spec/AgentConfigService/AgentConfigService.ts
+++ /dev/null
@@ -1,211 +0,0 @@
-import { WebexSDK } from '../../../../src/types';
-import AgentConfigService from '../../../../src/AgentConfigService/AgentConfigService';
-
-describe('AgentConfigService', () => {
-  let agentConfigService: AgentConfigService;
-  let mockWebexSDK: WebexSDK;
-  const mockWccAPIURL = 'https://api.example.com/';
-  const mockAgentId = 'agent123';
-  const mockOrgId = 'org123';
-
-  beforeEach(() => {
-    mockWebexSDK = {
-      request: jest.fn(),
-      logger: {
-        log: jest.fn(),
-      },
-    } as unknown as WebexSDK;
-    agentConfigService = new AgentConfigService(mockAgentId, mockOrgId, mockWebexSDK, mockWccAPIURL);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('getUserUsingCI', () => {
-    it('should return AgentResponse on success', async () => {
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          firstName: 'John',
-          lastName: 'Doe',
-          agentProfileId: 'profile123',
-          email: 'john.doe@example.com',
-          teamIds: ['123', '456'],
-        },
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      const result = await agentConfigService.getUserUsingCI();
-
-      expect(mockWebexSDK.request).toHaveBeenCalledWith({
-        method: 'GET',
-        uri: `${mockWccAPIURL}organization/${mockOrgId}/user/by-ci-user-id/${mockAgentId}`,
-      });
-      expect(result).toEqual(mockResponse.body);
-      expect(mockWebexSDK.logger.log).toHaveBeenCalledWith('getUserUsingCI api success.');
-    });
-
-    it('should throw an error if the status code is not 200', async () => {
-      const mockResponse = {
-        statusCode: 500,
-        body: {},
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      await expect(agentConfigService.getUserUsingCI()).rejects.toThrow(`API call failed with ${mockResponse.statusCode}`)
-    });
-
-    it('should throw an error if the API call fails', async () => {
-      const mockError = new Error('API call failed');
-      (mockWebexSDK.request as jest.Mock).mockRejectedValue(mockError);
-
-      await expect(agentConfigService.getUserUsingCI()).rejects.toThrow(
-        'API call failed'
-      );
-    });
-
-  });
-
-  describe('getDesktopProfileById', () => {
-    const desktopProfileId = 'profile123';
-
-    it('should return DesktopProfileResponse on success', async () => {
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          loginVoiceOptions: ['option1', 'option2'],
-          accessWrapUpCode: 'ALL',
-          accessIdleCode: 'SPECIFIC',
-          wrapUpCodes: ['code1', 'code2'],
-          idleCodes: ['idle1', 'idle2'],
-        },
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      const result = await agentConfigService.getDesktopProfileById(desktopProfileId);
-
-      expect(mockWebexSDK.request).toHaveBeenCalledWith({
-        method: 'GET',
-        uri: `${mockWccAPIURL}organization/${mockOrgId}/agent-profile/${desktopProfileId}`,
-      });
-      expect(result).toEqual(mockResponse.body);
-      expect(mockWebexSDK.logger.log).toHaveBeenCalledWith('getDesktopProfileById api success.');
-    });
-
-    it('should throw an error if the status code is not 200', async () => {
-      const mockResponse = {
-        statusCode: 500,
-        body: {},
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      await expect(agentConfigService.getDesktopProfileById(desktopProfileId)).rejects.toThrow(`API call failed with ${mockResponse.statusCode}`)
-    });
-
-
-    it('should throw an error if the API call fails', async () => {
-      const mockError = new Error('API call failed');
-      (mockWebexSDK.request as jest.Mock).mockRejectedValue(mockError);
-
-      await expect(agentConfigService.getDesktopProfileById(desktopProfileId)).rejects.toThrow(
-        'API call failed'
-      );
-    });
-  });
-
-  describe('getListOfTeams', () => {
-    const page = 0;
-    const pageSize = 10;
-    const filter: string[] = ['123'];
-    const attributes: string[] = ['id'];
-
-    it('should return team on success', async () => {
-      const mockResponse = {
-        statusCode: 200,
-        body: [
-          { id: '123', name: 'Team 1' },
-          { id: '12345', name: 'Team 2' },
-        ],
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      const result = await agentConfigService.getListOfTeams(page, pageSize, filter, attributes);
-
-      expect(mockWebexSDK.request).toHaveBeenCalledWith({
-        method: 'GET',
-        uri: `${mockWccAPIURL}organization/${mockOrgId}/team?page=${page}&pageSize=${pageSize}&filter=id=in=${filter}&attributes=${attributes}`,
-      });
-      expect(result).toEqual(mockResponse.body);
-      expect(mockWebexSDK.logger.log).toHaveBeenCalledWith('getListOfTeams api success.');
-    });
-
-    it('should throw an error if the status code is not 200', async () => {
-      const mockResponse = {
-        statusCode: 500,
-        body: {},
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      await expect(agentConfigService.getListOfTeams(page, pageSize, filter, attributes)).rejects.toThrow(`API call failed with ${mockResponse.statusCode}`)
-    });
-
-
-    it('should throw an error if the API call fails', async () => {
-      const mockError = new Error('API call failed');
-      (mockWebexSDK.request as jest.Mock).mockRejectedValue(mockError);
-
-      await expect(agentConfigService.getListOfTeams(page, pageSize, filter, attributes)).rejects.toThrow(
-        'API call failed'
-      );
-    });
-  });
-
-  describe('getListOfAuxCodes', () => {
-    const page = 0;
-    const pageSize = 10;
-    const filter: string[] = ['123'];
-    const attributes: string[] = ['id'];
-
-    it('should return ListAuxCodesResponse on success', async () => {
-      const mockResponse = {
-        statusCode: 200,
-        body: {
-          data: [
-            { id: 'aux1', active: true, defaultCode: false, isSystemCode: false, description: 'Aux 1', name: 'Aux 1', workTypeCode: 'work1' },
-            { id: 'aux2', active: true, defaultCode: false, isSystemCode: false, description: 'Aux 2', name: 'Aux 2', workTypeCode: 'work2' },
-          ],
-        },
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      const result = await agentConfigService.getListOfAuxCodes(page, pageSize, filter, attributes);
-
-      expect(mockWebexSDK.request).toHaveBeenCalledWith({
-        method: 'GET',
-        uri: `${mockWccAPIURL}organization/${mockOrgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}&filter=id=in=${filter}&attributes=${attributes}`,
-      });
-      expect(result).toEqual(mockResponse.body);
-      expect(mockWebexSDK.logger.log).toHaveBeenCalledWith('getListOfAuxCodes api success.');
-    });
-
-    it('should throw an error if the status code is not 200', async () => {
-      const mockResponse = {
-        statusCode: 500,
-        body: {},
-      };
-      (mockWebexSDK.request as jest.Mock).mockResolvedValue(mockResponse);
-
-      await expect(agentConfigService.getListOfAuxCodes(page, pageSize, filter, attributes)).rejects.toThrow(`API call failed with ${mockResponse.statusCode}`)
-    });
-
-    it('should throw an error if the API call fails', async () => {
-      const mockError = new Error('API call failed');
-      (mockWebexSDK.request as jest.Mock).mockRejectedValue(mockError);
-
-      await expect(agentConfigService.getListOfAuxCodes(page, pageSize, filter, attributes)).rejects.toThrow(
-        'API call failed'
-      );
-    });
-  });
-});
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/test/unit/spec/HttpRequest.ts b/packages/@webex/plugin-cc/test/unit/spec/HttpRequest.ts
deleted file mode 100644
index 3fa64459cc5..00000000000
--- a/packages/@webex/plugin-cc/test/unit/spec/HttpRequest.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import HttpRequest from '../../../src/HttpRequest';
-import { HTTP_METHODS, WebexSDK } from '../../../src/types';
-
-describe('HttpRequest', () => {
-  let webex: WebexSDK;
-  let httpRequest: HttpRequest;
-
-  beforeEach(() => {
-    webex = {
-      request: jest.fn(),
-    } as unknown as WebexSDK;
-    httpRequest = new HttpRequest(webex);
-  });
-
-  describe('request', () => {
-    const URL = 'https://api.example.com/accessResource';
-    const body = { id: '123', name: 'test' };
-
-    it('should make a GET request successfully', async () => {
-      const mockResponse = { data: 'response data' };
-      jest.spyOn(webex, 'request').mockResolvedValue(mockResponse);
-
-      const response = await httpRequest.request(URL, HTTP_METHODS.GET);
-
-      expect(webex.request).toHaveBeenCalledWith({
-        method: HTTP_METHODS.GET,
-        uri: URL,
-      });
-      expect(response).toEqual(mockResponse);
-    });
-
-    it('should make a POST request successfully', async () => {
-      const mockResponse = { data: 'response data' };
-      jest.spyOn(webex, 'request').mockResolvedValue(mockResponse);
-
-      const response = await httpRequest.request(URL, HTTP_METHODS.POST, body);
-
-      expect(webex.request).toHaveBeenCalledWith({
-        method: HTTP_METHODS.POST,
-        uri: URL,
-        body,
-      });
-      expect(response).toEqual(mockResponse);
-    });
-
-    it('should throw an error if the request fails', async () => {
-      const mockError = new Error('Request failed');
-      jest.spyOn(webex, 'request').mockRejectedValue(mockError);
-
-      await expect(httpRequest.request(URL, HTTP_METHODS.GET)).rejects.toThrow(
-        'Request failed'
-      );
-    });
-
-    it('should throw an error for unsupported HTTP methods', async () => {
-      const unsupportedMethod = 'PUT';
-
-      await expect(httpRequest.request(URL, unsupportedMethod)).rejects.toThrow(
-        'Unsupported HTTP method: PUT'
-      );
-    });
-  });
-});
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/test/unit/spec/WebSocket.ts b/packages/@webex/plugin-cc/test/unit/spec/WebSocket.ts
deleted file mode 100644
index 6c99c62b60d..00000000000
--- a/packages/@webex/plugin-cc/test/unit/spec/WebSocket.ts
+++ /dev/null
@@ -1,195 +0,0 @@
-import MockWebex from '@webex/test-helper-mock-webex';
-import { assert } from '@webex/test-helper-chai';
-import Mercury from '@webex/internal-plugin-mercury';
-import WebSocket from '../../../src/WebSocket/WebSocket';
-import { HTTP_METHODS, SubscribeRequest } from '../../../src/types';
-
-describe('plugin-cc WebSocket tests', () => {
-  const datachannelUrl = 'datachannelUrl';
-
-  describe('WebSocket', () => {
-    let webex, webSocket;
-
-    beforeEach(() => {
-      webex = new MockWebex({
-        children: {
-          mercury: Mercury,
-        },
-      });
-
-      webSocket = new WebSocket({
-        parent: webex, // Ensure the parent is set correctly
-      });
-    });
-
-    describe('#subscribeNotifications', () => {
-      it('should register to the websocket and update webSocketUrl and subscriptionId', async () => {
-        const response = {
-          body: {
-            webSocketUrl: 'wss://websocket.example.com',
-            subscriptionId: 'subscriptionId',
-          },
-        };
-
-        jest.spyOn(webSocket, 'request').mockResolvedValue(response);
-
-        await webSocket.subscribeNotifications({
-          datachannelUrl,
-          body: {} as SubscribeRequest,
-        });
-
-        assert.equal(webSocket.webSocketUrl, 'wss://websocket.example.com');
-        assert.equal(webSocket.subscriptionId, 'subscriptionId');
-      });
-
-      it('should throw an error if the request fails', async () => {
-        const error = new Error('Request failed');
-        jest.spyOn(webSocket, 'request').mockRejectedValue(error);
-        try {
-          await webSocket.subscribeNotifications({
-            datachannelUrl,
-            body: {} as SubscribeRequest,
-          });
-          assert.fail('Expected error was not thrown');
-        } catch (err) {
-          assert.equal(err, error);
-        }
-      });
-    });
-
-    describe('#subscribeAndConnect', () => {
-      it('should subscribe and connect to the websocket', async () => {
-        const connectSpy = jest.spyOn(webSocket, 'connect');
-        const response = {
-          body: {
-            webSocketUrl: 'wss://websocket.example.com',
-            subscriptionId: 'subscriptionId',
-          },
-        };
-        jest.spyOn(webSocket, 'request').mockResolvedValue(response);
-        await webSocket.subscribeAndConnect({
-          datachannelUrl,
-          body: {} as SubscribeRequest,
-        });
-
-        expect(webSocket.datachannelUrl).toBe(datachannelUrl);
-        expect(connectSpy).toHaveBeenCalledWith('wss://websocket.example.com');
-        connectSpy.mockRestore();
-      });
-
-      it('should throw an error if subscribeNotifications fails', async () => {
-        const error = new Error('Subscription failed');
-        jest.spyOn(webSocket, 'subscribeNotifications').mockRejectedValue(error);
-
-        try {
-          await webSocket.subscribeAndConnect({
-            datachannelUrl,
-            body: {} as SubscribeRequest,
-          });
-          assert.fail('Expected error was not thrown');
-        } catch (err) {
-          expect(err).toBe(error);
-        }
-      });
-
-      it('should return undefined if datachannelUrl is not provided', async () => {
-        const response = {
-          body: {
-            webSocketUrl: 'wss://websocket.example.com',
-            subscriptionId: 'subscriptionId',
-          },
-        };
-        jest.spyOn(webSocket, 'request').mockResolvedValue(response);
-
-        const result = await webSocket.subscribeAndConnect({
-          datachannelUrl: undefined,
-          body: {} as SubscribeRequest,
-        });
-
-        expect(result).toBeUndefined();
-        expect(webSocket.datachannelUrl).toBeUndefined();
-      });
-    });
-
-    describe('#isConnected', () => {
-      it('should return the connected status', () => {
-        webSocket.connected = true;
-        assert.isTrue(webSocket.isConnected());
-
-        webSocket.connected = false;
-        assert.isFalse(webSocket.isConnected());
-      });
-    });
-
-    describe('#getSubscriptionId', () => {
-      it('should return the subscriptionId', () => {
-        webSocket.subscriptionId = 'subscriptionId';
-        assert.equal(webSocket.getSubscriptionId(), 'subscriptionId');
-      });
-
-      it('should return undefined if subscriptionId is not set', () => {
-        webSocket.subscriptionId = undefined;
-        assert.isUndefined(webSocket.getSubscriptionId());
-      });
-    });
-
-    describe('#getDatachannelUrl', () => {
-      it('should return the datachannelUrl', () => {
-        webSocket.datachannelUrl = 'datachannelUrl';
-        assert.equal(webSocket.getDatachannelUrl(), 'datachannelUrl');
-      });
-
-      it('should return undefined if datachannelUrl is not set', () => {
-        webSocket.datachannelUrl = undefined;
-        assert.isUndefined(webSocket.getDatachannelUrl());
-      });
-    });
-
-    describe('#disconnectWebSocket', () => {
-      it('should disconnect the websocket and clear related properties', async () => {
-        webSocket.disconnect = jest.fn();
-
-        webSocket.disconnect.mockResolvedValue();
-        await webSocket.disconnectWebSocket();
-
-        assert.isUndefined(webSocket.datachannelUrl);
-        assert.isUndefined(webSocket.subscriptionId);
-        assert.isUndefined(webSocket.webSocketUrl);
-      });
-
-      it('should throw an error if disconnect fails', async () => {
-        const error = new Error('Disconnect failed');
-        webSocket.disconnect = jest.fn().mockRejectedValue(error);
-
-        try {
-          await webSocket.disconnectWebSocket();
-          assert.fail('Expected error was not thrown');
-        } catch (err) {
-          expect(err).toBe(error);
-        }
-      });
-    });
-
-    describe('#on and #off', () => {
-      it('should add and remove event listeners', () => {
-        const event = 'message';
-        const callback = jest.fn();
-      
-        // Add the event listener
-        webSocket.on(event, callback);
-      
-        // Emit the event and check if the callback is called
-        webSocket.emit(event, 'test data');
-        expect(callback).toHaveBeenCalledWith('test data');
-      
-        // Remove the event listener
-        webSocket.off(event, callback);
-      
-        // Emit the event again and check if the callback is not called
-        callback.mockClear(); // Clear the mock call history
-        webSocket.emit(event, 'test data');
-        expect(callback).not.toHaveBeenCalled();
-      });
-    });
-  });
-});
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/test/unit/spec/cc.ts b/packages/@webex/plugin-cc/test/unit/spec/cc.ts
index 3fcb97a0893..6ba0affb9df 100644
--- a/packages/@webex/plugin-cc/test/unit/spec/cc.ts
+++ b/packages/@webex/plugin-cc/test/unit/spec/cc.ts
@@ -1,91 +1,150 @@
-import { assert } from '@webex/test-helper-chai';
-import MockWebex from '@webex/test-helper-mock-webex';
-import WebSocket from '../../../src/WebSocket/WebSocket';
-import { EVENT, READY, WCC_API_GATEWAY, WEBSOCKET_EVENT_TIMEOUT } from '../../../src/constants';
-import { CC_EVENTS } from '../../../src/types';
+import 'jsdom-global/register';
+import {
+  BuddyAgents,
+  BuddyAgentsResponse,
+  LoginOption,
+  StationLogoutResponse,
+  WebexSDK,
+} from '../../../src/types';
 import ContactCenter from '../../../src/cc';
-import AgentConfig from '../../../src/AgentConfig/AgentConfig';
+import MockWebex from '@webex/test-helper-mock-webex';
+import { StationLoginSuccess } from '../../../src/services/agent/types';
+import { IAgentProfile } from '../../../src/types';
+import { AGENT, WEB_RTC_PREFIX } from '../../../src/services/constants';
+import Services from '../../../src/services';
+import config from '../../../src/config';
+import LoggerProxy from '../../../src/logger-proxy';
+import { getErrorDetails, createErrDetailsObject } from '../../../src/services/core/Utils';
+
+// Mock the Worker API
+import '../../../__mocks__/workerMock';
+
+jest.mock('../../../src/logger-proxy', () => ({
+  __esModule: true,
+  default: {
+    logger: {
+      log: jest.fn(),
+      error: jest.fn(),
+    },
+    initialize: jest.fn(),
+  },
+}));
+
+jest.mock('../../../src/services/config');
+jest.mock('../../../src/services/core/WebSocket/WebSocketManager');
+jest.mock('../../../src/services/core/WebSocket/connection-service');
+jest.mock('../../../src/services/WebCallingService');
+jest.mock('../../../src/services');
+
+// Mock AgentConfig
+const mockAgentConfig = {
+  getAgentProfile: jest.fn(),
+};
+jest.mock('../../../src/features/Agentconfig', () => {
+  return jest.fn().mockImplementation(() => mockAgentConfig);
+});
+
+global.URL.createObjectURL = jest.fn(() => 'blob:http://localhost:3000/12345');
 
 describe('webex.cc', () => {
   let webex;
-  let webSocketMock;
-  let eventEmitter;
-  let mockAgentProfile: AgentConfig;
+  let mockWebSocketManager;
 
   beforeEach(() => {
-    webex = new MockWebex({
+    webex = MockWebex({
       children: {
         cc: ContactCenter,
       },
-    });
+      logger: {
+        log: jest.fn(),
+        error: jest.fn(),
+      },
+      config: config,
+      once: jest.fn((event, callback) => callback()),
+    }) as unknown as WebexSDK;
+
+    // Instantiate ContactCenter to ensure it's fully initialized
+    webex.cc = new ContactCenter({parent: webex});
 
-    // Ensure webex.internal.services is initialized correctly
-    webex.internal = {
-      ...webex.internal,
-      services: {
-        get: jest.fn().mockReturnValue('https://api.example.com/'),
+    mockWebSocketManager = {
+      initWebSocket: jest.fn(),
+    };
+    webex.cc.webSocketManager = mockWebSocketManager;
+
+    // Mock Services instance
+    const mockServicesInstance = {
+      agent: {
+        stationLogin: jest.fn(),
+        logout: jest.fn(),
+        reload: jest.fn(),
+        buddyAgents: jest.fn(),
       },
     };
+    (Services.getInstance as jest.Mock).mockReturnValue(mockServicesInstance);
+    webex.cc.services = mockServicesInstance;
+  });
 
-    // Manually mock the necessary methods
-    webSocketMock = {
-      on: jest.fn(),
-      subscribeAndConnect: jest.fn(),
-      disconnectWebSocket: jest.fn(),
-      off: jest.fn(),
-    };
-    webex.cc.webSocket = webSocketMock;
-    
-    // Mock event emitter
-    eventEmitter = new (require('events')).EventEmitter();
-    webSocketMock.on.mockImplementation((event, callback) => {
-      eventEmitter.on(event, callback);
-    });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
 
-    global.WEBSOCKET_EVENT_TIMEOUT = 100; // Set to a smaller value for tests
+  it('should initialize services and logger proxy on READY event', () => {
+    webex.once('READY', () => {
+      expect(Services.getInstance).toHaveBeenCalled();
+      expect(LoggerProxy.initialize).toHaveBeenCalledWith(webex.logger);
+    });
 
+    webex.emit('READY');
   });
 
-  afterEach(() => {
-    jest.resetAllMocks();
+  describe('cc.getDeviceId', () => {
+    it('should return dialNumber when loginOption is EXTENSION', () => {
+      const loginOption = LoginOption.EXTENSION;
+      const dialNumber = '12345';
+      const result = webex.cc['getDeviceId'](loginOption, dialNumber);
+      expect(result).toBe(dialNumber);
+    });
+
+    it('should return dialNumber when loginOption is AGENT_DN', () => {
+      const loginOption = LoginOption.AGENT_DN;
+      const dialNumber = '12345';
+      const result = webex.cc['getDeviceId'](loginOption, dialNumber);
+      expect(result).toBe(dialNumber);
+    });
+
+    it('should return prefix + agentId for other loginOptions', () => {
+      const loginOption = 'OTHER_OPTION';
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+      };
+      const result = webex.cc['getDeviceId'](loginOption, '');
+      expect(result).toBe(WEB_RTC_PREFIX + 'agentId');
+    });
   });
 
-  describe('#register', () => {
-
-    it('should resolve with success message on successful registration even if $config is undefined', async () => {
-      webex.$config = undefined;
-      const promise = webex.cc.register();
-      const agentProfileMock = {
-          teams: [
-              {
-                id: "123",
-                name: "Sandbox Team"
-              }
-          ],
-          idleCodes: [],
-          wrapUpCodes: [],
-          agentId: "123",
-          name: "test1 test2",
-          agentProfileId: "456",
-          agentMailId: "test@test.com",
-          loginVoiceOptions: [
-              "EXTENSION",
-              "BROWSER",
-              "AGENT_DN"
-          ]
-      }
-      jest.spyOn(AgentConfig.prototype, 'getAgentProfile').mockResolvedValue(agentProfileMock);
-
-      // Emit the welcome event to simulate the WebSocket message
-      eventEmitter.emit(EVENT, {
-        type: CC_EVENTS.WELCOME,
-        data: { agentId: 'mockAgentId' },
+  describe('register', () => {
+    it('should register successfully and return agent profile', async () => {
+      const mockAgentProfile: IAgentProfile = {
+        agentId: 'agent123',
+        agentMailId: '',
+        agentName: 'John',
+        teams: [],
+        agentProfileId: '',
+        loginVoiceOptions: [],
+        idleCodes: [],
+        wrapUpCodes: [],
+      };
+      const connectWebsocketSpy = jest.spyOn(webex.cc, 'connectWebsocket');
+
+      mockAgentConfig.getAgentProfile.mockResolvedValue(mockAgentProfile);
+      mockWebSocketManager.initWebSocket.mockResolvedValue({
+        agentId: 'agent123',
       });
 
-      const result = await promise;
+      const result = await webex.cc.register();
 
-      expect(webSocketMock.subscribeAndConnect).toHaveBeenCalledWith({
-        datachannelUrl: 'https://api.example.com/v1/notification/subscribe',
+      expect(connectWebsocketSpy).toHaveBeenCalled();
+      expect(mockWebSocketManager.initWebSocket).toHaveBeenCalledWith({
         body: {
           force: true,
           isKeepAliveEnabled: false,
@@ -93,49 +152,36 @@ describe('webex.cc', () => {
           allowMultiLogin: true,
         },
       });
-
-      expect(result).toEqual(agentProfileMock);
+      expect(mockAgentConfig.getAgentProfile).toHaveBeenCalled();
+      expect(webex.logger.log).toHaveBeenCalledWith(
+        'file: cc: agent config is fetched successfully'
+      );
+      expect(result).toEqual(mockAgentProfile);
     });
 
-    it('should resolve with success message on successful registration with $config has values', async () => {
-      webex.cc.$config = {
-        force: true,
-        isKeepAliveEnabled: false,
-        clientType: 'WebexCCSDK',
-        allowMultiLogin: true,
+    it('should register successfully when config is undefined and return agent profile', async () => {
+      webex.cc.$config = undefined;
+      const mockAgentProfile: IAgentProfile = {
+        agentId: 'agent123',
+        agentMailId: '',
+        agentName: 'John',
+        teams: [],
+        agentProfileId: '',
+        loginVoiceOptions: [],
+        idleCodes: [],
+        wrapUpCodes: [],
       };
-      const promise = webex.cc.register();
-
-      const agentProfileMock = {
-          teams: [
-              {
-                id: "123",
-                name: "Sandbox Team"
-              }
-          ],
-          idleCodes: [],
-          wrapUpCodes: [],
-          agentId: "123",
-          name: "test1 test2",
-          agentProfileId: "456",
-          agentMailId: "test@test.com",
-          loginVoiceOptions: [
-              "EXTENSION",
-              "BROWSER",
-              "AGENT_DN"
-          ]
-      }
-      jest.spyOn(AgentConfig.prototype, 'getAgentProfile').mockResolvedValue(agentProfileMock);
-
-      // Emit the welcome event to simulate the WebSocket message
-      eventEmitter.emit(EVENT, {
-        type: CC_EVENTS.WELCOME,
-        data: { agentId: 'mockAgentId' },
+      const connectWebsocketSpy = jest.spyOn(webex.cc, 'connectWebsocket');
+
+      mockAgentConfig.getAgentProfile.mockResolvedValue(mockAgentProfile);
+      mockWebSocketManager.initWebSocket.mockResolvedValue({
+        agentId: 'agent123',
       });
 
-      const result = await promise;
-      expect(webSocketMock.subscribeAndConnect).toHaveBeenCalledWith({
-        datachannelUrl: 'https://api.example.com/v1/notification/subscribe',
+      const result = await webex.cc.register();
+
+      expect(connectWebsocketSpy).toHaveBeenCalled();
+      expect(mockWebSocketManager.initWebSocket).toHaveBeenCalledWith({
         body: {
           force: true,
           isKeepAliveEnabled: false,
@@ -143,206 +189,265 @@ describe('webex.cc', () => {
           allowMultiLogin: true,
         },
       });
-
-      expect(result).toEqual(agentProfileMock);
+      expect(mockAgentConfig.getAgentProfile).toHaveBeenCalled();
+      expect(webex.logger.log).toHaveBeenCalledWith(
+        'file: cc: agent config is fetched successfully'
+      );
+      expect(result).toEqual(mockAgentProfile);
     });
 
-    it('should reject with error on registration failure', async () => {
-      const error = new Error('Connection error');
-      webSocketMock.subscribeAndConnect.mockRejectedValue(error);
+    it('should log error and reject if registration fails', async () => {
+      const mockError = new Error('Error while performing register');
+      mockWebSocketManager.initWebSocket.mockRejectedValue(mockError);
 
-      try {
-        await webex.cc.register();
-        assert.fail('Expected error was not thrown');
-      } catch (err) {
-        assert.equal(err, error);
-      }
+      await expect(webex.cc.register()).rejects.toThrow('Error while performing register');
+
+      expect(webex.logger.error).toHaveBeenCalledWith(
+        `file: cc: Error during register: ${mockError}`
+      );
     });
   });
 
-  describe('#unregister', () => {
-    it('should disconnect the WebSocket and remove event listeners', async () => {
-      webSocketMock.disconnectWebSocket.mockResolvedValue();
-      webSocketMock.off = jest.fn();
+  describe('stationLogin', () => {
+    it('should login successfully with LoginOption.BROWSER', async () => {
+      const options = {
+        teamId: 'teamId',
+        loginOption: LoginOption.BROWSER,
+      };
 
-      await webex.cc.unregister();
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+      };
 
-      expect(webSocketMock.disconnectWebSocket).toHaveBeenCalled();
-      expect(webSocketMock.off).toHaveBeenCalled();
-      expect(webSocketMock.off).toHaveBeenCalledWith(EVENT, webex.cc.processEvent);
+      const registerWebCallingLineSpy = jest.spyOn(
+        webex.cc.webCallingService,
+        'registerWebCallingLine'
+      );
+
+      const stationLoginMock = jest
+        .spyOn(webex.cc.services.agent, 'stationLogin')
+        .mockResolvedValue({} as StationLoginSuccess);
+
+      const result = await webex.cc.stationLogin(options);
+
+      expect(registerWebCallingLineSpy).toHaveBeenCalled();
+      expect(stationLoginMock).toHaveBeenCalledWith({
+        data: {
+          dialNumber: 'agentId',
+          teamId: 'teamId',
+          deviceType: LoginOption.BROWSER,
+          isExtension: false,
+          deviceId: `${WEB_RTC_PREFIX}agentId`,
+          roles: [AGENT],
+          teamName: '',
+          siteId: '',
+          usesOtherDN: false,
+          auxCodeId: '',
+        },
+      });
+      expect(result).toEqual({});
     });
-  });
 
-  describe('#listenForWebSocketEvents', () => {
-    it('should set up event listener for WebSocket events', () => {
-      webSocketMock.on = jest.fn();
+    it('should login successfully with other LoginOption', async () => {
+      const options = {
+        teamId: 'teamId',
+        loginOption: LoginOption.AGENT_DN,
+        dialNumber: '1234567890',
+      };
 
-      webex.cc.listenForWebSocketEvents();
-      
-      expect(webSocketMock.on).toHaveBeenCalled();
-      expect(webSocketMock.on).toHaveBeenCalledWith(EVENT, webex.cc.processEvent);
+      const stationLoginMock = jest
+        .spyOn(webex.cc.services.agent, 'stationLogin')
+        .mockResolvedValue({} as StationLoginSuccess);
+
+      const result = await webex.cc.stationLogin(options);
+
+      expect(stationLoginMock).toHaveBeenCalledWith({
+        data: {
+          dialNumber: '1234567890',
+          teamId: 'teamId',
+          deviceType: LoginOption.AGENT_DN,
+          isExtension: false,
+          deviceId: '1234567890',
+          roles: [AGENT],
+          teamName: '',
+          siteId: '',
+          usesOtherDN: false,
+          auxCodeId: '',
+        },
+      });
+      expect(result).toEqual({});
     });
-  });
 
-  describe('#processEvent', () => {
-    it('should handle WELCOME event and resolve the register promise', async () => {
-      const resolveMock = jest.fn();
-      const rejectMock = jest.fn();
-      webex.cc.addEventHandler('register', resolveMock, rejectMock);
-      const promise = webex.cc.register();
+    it('should handle error during stationLogin', async () => {
+      const options = {
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1234567890',
+      };
 
-      const agentProfileMock = {
-        teams: [
-            {
-              id: "123",
-              name: "Sandbox Team"
-            }
-        ],
-        idleCodes: [],
-        wrapUpCodes: [],
-        agentId: "123",
-        name: "test1 test2",
-        agentProfileId: "456",
-        agentMailId: "test@test.com",
-        loginVoiceOptions: [
-            "EXTENSION",
-            "BROWSER",
-            "AGENT_DN"
-        ]
-    }
-      jest.spyOn(AgentConfig.prototype, 'getAgentProfile').mockResolvedValue(agentProfileMock);
-
-      webex.cc.processEvent({
-        type: CC_EVENTS.WELCOME,
-        data: { agentId: 'mockAgentId' },
-      });
+      const error = {
+        details: {
+          trackingId: '1234',
+          data: {
+            reason: 'Error while performing station login',
+          },
+        },
+      };
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockRejectedValue(error);
 
-      const result = await promise;
-      expect(result).toEqual(agentProfileMock);
-    });
+      await expect(webex.cc.stationLogin(options)).rejects.toThrow(error.details.data.reason);
 
-    it('should handle unknown event type gracefully and log info statement', () => {
-      const resolveMock = jest.fn();
-      const rejectMock = jest.fn();
-      webex.logger.info = jest.fn();
-    
-      webex.cc.addEventHandler('register', resolveMock, rejectMock);
-    
-      webex.cc.processEvent({
-        type: 'UNKNOWN_EVENT',
-        data: {},
-      });
-    
-      expect(resolveMock).not.toHaveBeenCalled();
-      expect(rejectMock).not.toHaveBeenCalled();
-      expect(webex.logger.info).toHaveBeenCalled();
-      expect(webex.logger.info).toHaveBeenCalledWith('Unknown event: UNKNOWN_EVENT');
+      expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+        `stationLogin failed with trackingId: ${error.details.trackingId}`
+      );
     });
   });
 
-  describe('#handleEvent', () => {
-    it('should resolve the event handler promise and clear timeout', () => {
-      const resolveMock = jest.fn();
-      const rejectMock = jest.fn();
-      const timeoutId = setTimeout(() => {}, 1000);
-      webex.cc.eventHandlers.set('register', { resolve: resolveMock, reject: rejectMock, timeoutId });
+  describe('stationLogout', () => {
+    it('should logout successfully', async () => {
+      const data = { logoutReason: 'Logout reason' };
+      const response = {};
+
+      const stationLogoutMock = jest
+        .spyOn(webex.cc.services.agent, 'logout')
+        .mockResolvedValue({} as StationLogoutResponse);
 
-      webex.cc.handleEvent('register', 'Success message');
+      const result = await webex.cc.stationLogout(data);
 
-      expect(resolveMock).toHaveBeenCalled();
-      expect(resolveMock).toHaveBeenCalledWith('Success message');
-      assert.isFalse(webex.cc.eventHandlers.has('register'));
+      expect(stationLogoutMock).toHaveBeenCalledWith({ data: data });
+      expect(result).toEqual(response);
     });
 
-    it('should do nothing if event handler is not found', () => {
-      const resolveMock = jest.fn();
-      const rejectMock = jest.fn();
+    it('should handle error during stationLogout', async () => {
+      const data = { logoutReason: 'Logout reason' };
+      const error = {
+        details: {
+          trackingId: '1234',
+          data: {
+            reason: 'Error while performing station logout',
+          },
+        },
+      };
+
+      jest.spyOn(webex.cc.services.agent, 'logout').mockRejectedValue(error);
 
-      webex.cc.handleEvent('nonexistent', 'Success message');
+      await expect(webex.cc.stationLogout(data)).rejects.toThrow(error.details.data.reason);
 
-      expect(resolveMock).not.toHaveBeenCalled();
-      expect(rejectMock).not.toHaveBeenCalled();
+      expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+        `stationLogout failed with trackingId: ${error.details.trackingId}`
+      );
     });
   });
 
-  describe('#addEventHandler', () => {
-    it('should add an event handler with timeout', () => {
-      jest.useFakeTimers();
-    
-      const resolveMock = jest.fn();
-      const rejectMock = jest.fn();
-    
-      webex.cc.addEventHandler('register', resolveMock, rejectMock);
-    
-      const eventHandler = webex.cc.eventHandlers.get('register');
-      expect(eventHandler).toBeDefined();
-      expect(eventHandler.resolve).toBe(resolveMock);
-      expect(eventHandler.reject).toBe(rejectMock);
-      expect(eventHandler.timeoutId).toBeDefined();
-    
-      expect(resolveMock).not.toHaveBeenCalled();
-    
-      // Fast-forward until all timers have been executed
-      jest.runAllTimers();
-    
-      expect(rejectMock).toHaveBeenCalled();
-      clearTimeout(eventHandler.timeoutId);
-    
-      jest.useRealTimers();
+  describe('stationRelogin', () => {
+    it('should relogin successfully', async () => {
+      const response = {};
+
+      const stationLoginMock = jest
+        .spyOn(webex.cc.services.agent, 'reload')
+        .mockResolvedValue({} as StationLoginSuccess);
+
+      const result = await webex.cc.stationReLogin();
+
+      expect(stationLoginMock).toHaveBeenCalled();
+      expect(result).toEqual(response);
     });
-  
-    // it('should reject the promise if the event times out', (done) => {
-    //   const resolveMock = jest.fn();
-    //   const rejectMock = jest.fn().mockImplementation((error) => {
-    //     expect(error.message).toBe('Time out waiting for event: register');
-    //     done();
-    //   });
-  
-    //   webex.cc.addEventHandler('register', resolveMock, rejectMock);
-  
-    //   const eventHandler = webex.cc.eventHandlers.get('register');
-    //   expect(eventHandler).toBeDefined();
-  
-    //   // Simulate timeout
-    //   setTimeout(() => {
-    //     expect(rejectMock).toHaveBeenCalled();
-    //   }, WEBSOCKET_EVENT_TIMEOUT + 100);
-    // }, WEBSOCKET_EVENT_TIMEOUT + 200);
-  });
 
-  describe('#establishConnection', () => {
-    it('should establish WebSocket connection with correct parameters', async () => {
-      webSocketMock.subscribeAndConnect.mockResolvedValue();
+    it('should handle error during relogin', async () => {
+      const error = {
+        details: {
+          trackingId: '1234',
+          data: {
+            reason: 'Error while performing station relogin',
+          },
+        },
+      };
 
-      webex.cc.register();
+      jest.spyOn(webex.cc.services.agent, 'reload').mockRejectedValue(error);
 
-      expect(webSocketMock.subscribeAndConnect).toHaveBeenCalled();
-      expect(webSocketMock.subscribeAndConnect).toHaveBeenCalledWith({
-        datachannelUrl: 'https://api.example.com/v1/notification/subscribe',
-        body: {
-          force: true,
-          isKeepAliveEnabled: false,
-          clientType: 'WebexCCSDK',
-          allowMultiLogin: true,
+      await expect(webex.cc.stationReLogin()).rejects.toThrow(error.details.data.reason);
+
+      expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+        `stationReLogin failed with trackingId: ${error.details.trackingId}`
+      );
+    });
+  });
+  describe('getBuddyAgents', () => {
+    it('should return buddy agents response when successful', async () => {
+      const data: BuddyAgents = {state: 'Available', mediaType: 'telephony'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        agentProfileId: 'test-agent-profile-id',
+      };
+
+      const buddyAgentsResponse: BuddyAgentsResponse = {
+        type: 'BuddyAgentsSuccess',
+        orgId: '',
+        trackingId: '1234',
+        data: {
+          eventType: 'BuddyAgents',
+          agentId: 'agentId',
+          trackingId: '1234',
+          orgId: '',
+          type: '',
+          agentSessionId: 'session123',
+          agentList: [
+            {
+              agentId: 'agentId',
+              state: 'Available',
+              teamId: 'teamId',
+              dn: '1234567890',
+              agentName: 'John',
+              siteId: 'siteId',
+            },
+          ],
         },
+      };
+
+      const buddyAgentsSpy = jest
+        .spyOn(webex.cc.services.agent, 'buddyAgents')
+        .mockResolvedValue(buddyAgentsResponse);
+
+      const result = await webex.cc.getBuddyAgents(data);
+
+      expect(buddyAgentsSpy).toHaveBeenCalledWith({
+        data: {agentProfileId: 'test-agent-profile-id', ...data},
       });
-    }, 1000);
-
-    it('should log error and throw if connection fails', async () => {
-      const error = new Error('Connection error');
-      webSocketMock.subscribeAndConnect.mockRejectedValue(error);
-      webex.logger.info = jest.fn();
-
-      try {
-        await webex.cc.establishConnection((err) => {
-          throw err;
-        });
-        assert.fail('Expected error was not thrown');
-      } catch (err) {
-        assert.equal(err, error);
-        expect(webex.logger.info).toHaveBeenCalled();
-        expect(webex.logger.info).toHaveBeenCalledWith(`Error connecting and subscribing: ${error}`);
-      }
-    }, 1000);
+
+      expect(result).toEqual(buddyAgentsResponse);
+    });
+
+    it('should handle error', async () => {
+      const data: BuddyAgents = {state: 'Available', mediaType: 'telephony'};
+      webex.cc.agentConfig = {
+        agentId: 'f520d6b5-28ad-4f2f-b83e-781bb64af617',
+        agentProfileId: 'test-agent-profile-id',
+      };
+
+      const error = {
+        details: {
+          data: {
+            agentId: 'f520d6b5-28ad-4f2f-b83e-781bb64af617',
+            eventTime: 1731402794534,
+            eventType: 'AgentDesktopMessage',
+            orgId: 'e7924666-777d-40d4-a504-01aa1e62dd2f',
+            reason: 'AGENT_NOT_FOUND',
+            reasonCode: 1038,
+            trackingId: '5d2ddfaf-9b8a-491f-9c3f-3bb8ba60d595',
+            type: 'BuddyAgentsRetrieveFailed',
+          },
+          orgId: 'e7924666-777d-40d4-a504-01aa1e62dd2f',
+          trackingId: 'notifs_a7727d9e-7651-4c60-90a7-ff3de47b784d',
+          type: 'BuddyAgents',
+        },
+      };
+
+      jest.spyOn(webex.cc.services.agent, 'buddyAgents').mockRejectedValue(error);
+
+      await expect(webex.cc.getBuddyAgents(data)).rejects.toThrow(error.details.data.reason);
+      expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+        `getBuddyAgents failed with trackingId: ${error.details.trackingId}`
+      );
+    });
   });
-});
\ No newline at end of file
+});
diff --git a/packages/@webex/plugin-cc/test/unit/spec/features/AgentConfig.ts b/packages/@webex/plugin-cc/test/unit/spec/features/AgentConfig.ts
new file mode 100644
index 00000000000..598f7f9eda2
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/features/AgentConfig.ts
@@ -0,0 +1,463 @@
+import {IAgentProfile} from '../../../../src/features/types';
+import AgentConfigService from '../../../../src/services/config';
+import {WebexSDK} from '../../../../src/types';
+import {WORK_TYPE_CODE} from '../../../../src/features/types';
+import AgentConfig from '../../../../src/features/Agentconfig';
+import {
+  DesktopProfileResponse,
+  ListAuxCodesResponse,
+  Team,
+  AgentResponse,
+} from '../../../../src/services/config/types';
+
+const mockWebex: WebexSDK = {
+  internal: {
+    device: {
+      orgId: 'testOrgId',
+    },
+  },
+};
+
+const mockAgentResponse: AgentResponse = {
+  firstName: 'John',
+  lastName: 'Doe',
+  agentProfileId: 'profile123',
+  email: 'john.doe@example.com',
+  teamIds: ['team1', 'team2'],
+};
+
+const mockDesktopProfileResponse: DesktopProfileResponse = {
+  loginVoiceOptions: ['option1', 'option2'],
+  accessWrapUpCode: 'ALL',
+  accessIdleCode: 'ALL',
+  wrapUpCodes: [],
+  idleCodes: [],
+};
+
+const mockTeamsListResponse: Team[] = [{id: '123', name: 'Team 1'}];
+
+const mockAuxCodesResponse: ListAuxCodesResponse = {
+  data: [
+    {
+      id: 'aux1',
+      active: true,
+      defaultCode: true,
+      isSystemCode: true,
+      description: 'test',
+      name: 'testName',
+      workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+    },
+    {
+      id: 'aux1',
+      active: true,
+      defaultCode: true,
+      isSystemCode: true,
+      description: 'test',
+      name: 'testName',
+      workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+    },
+  ],
+};
+
+describe('AgentConfig', () => {
+  let agentConfig: AgentConfig;
+  let getUserUsingCISpy: jest.SpyInstance;
+  let getDesktopProfileByIdSpy: jest.SpyInstance;
+  let getListOfTeamsSpy: jest.SpyInstance;
+  let getListOfAuxCodesSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    agentConfig = new AgentConfig('agent123', mockWebex, 'http://api.url');
+
+    getUserUsingCISpy = jest
+      .spyOn(AgentConfigService.prototype, 'getUserUsingCI')
+      .mockResolvedValue(mockAgentResponse);
+    getDesktopProfileByIdSpy = jest
+      .spyOn(AgentConfigService.prototype, 'getDesktopProfileById')
+      .mockResolvedValue(mockDesktopProfileResponse);
+    getListOfAuxCodesSpy = jest
+      .spyOn(AgentConfigService.prototype, 'getListOfAuxCodes')
+      .mockResolvedValue(mockAuxCodesResponse);
+    getListOfTeamsSpy = jest
+      .spyOn(AgentConfigService.prototype, 'getListOfTeams')
+      .mockResolvedValue(mockTeamsListResponse);
+  });
+
+  it('should fetch agent profile successfully', async () => {
+    const expectedProfile: IAgentProfile = {
+      agentId: 'agent123',
+      agentName: 'John Doe',
+      agentProfileId: 'profile123',
+      agentMailId: 'john.doe@example.com',
+      teams: mockTeamsListResponse,
+      loginVoiceOptions: ['option1', 'option2'],
+      wrapUpCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+      ],
+      idleCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    expect(getUserUsingCISpy).toHaveBeenCalledOnceWith;
+    expect(getDesktopProfileByIdSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfTeamsSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfAuxCodesSpy).toHaveBeenCalledOnceWith;
+
+    const result = await agentConfig.getAgentProfile();
+    expect(result).toEqual(expectedProfile);
+  });
+
+  it('should handle errors when fetching agent profile', async () => {
+    getUserUsingCISpy.mockRejectedValue(new Error('Network error'));
+
+    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
+      'Fetching Agent Profile failed: Network error'
+    );
+  });
+
+  it('should handle errors when fetching desktop profile', async () => {
+    getDesktopProfileByIdSpy.mockRejectedValue(new Error('API error'));
+
+    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
+      'Fetching Agent Profile failed: API error'
+    );
+  });
+
+  it('should handle errors when fetching list of teams', async () => {
+    getListOfTeamsSpy.mockRejectedValue(new Error('API error'));
+
+    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
+      'Fetching Agent Profile failed: API error'
+    );
+  });
+
+  it('should handle errors when fetching list of aux codes', async () => {
+    getListOfAuxCodesSpy.mockRejectedValue(new Error('API error'));
+
+    await expect(agentConfig.getAgentProfile()).rejects.toThrow(
+      'Fetching Agent Profile failed: API error'
+    );
+  });
+
+  it('should handle both accessIdleCode and accessWrapUpCode as ALL', async () => {
+    const allDesktopProfileResponse: DesktopProfileResponse = {
+      loginVoiceOptions: ['option1', 'option2'],
+      accessWrapUpCode: 'ALL',
+      accessIdleCode: 'ALL',
+      wrapUpCodes: [],
+      idleCodes: [],
+    };
+
+    getDesktopProfileByIdSpy.mockResolvedValue(allDesktopProfileResponse);
+
+    const allAuxCodesResponse: ListAuxCodesResponse = {
+      data: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    getListOfAuxCodesSpy.mockResolvedValue(allAuxCodesResponse);
+
+    const expectedProfile: IAgentProfile = {
+      agentId: 'agent123',
+      agentName: 'John Doe',
+      agentProfileId: 'profile123',
+      agentMailId: 'john.doe@example.com',
+      teams: mockTeamsListResponse,
+      loginVoiceOptions: ['option1', 'option2'],
+      wrapUpCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+      ],
+      idleCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    expect(getUserUsingCISpy).toHaveBeenCalledOnceWith;
+    expect(getDesktopProfileByIdSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfTeamsSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfAuxCodesSpy).toHaveBeenCalledOnceWith;
+
+    const result = await agentConfig.getAgentProfile();
+    expect(result).toEqual(expectedProfile);
+  });
+
+  it('should handle SPECIFIC accessIdleCode and accessWrapUpCode', async () => {
+    const specificDesktopProfileResponse: DesktopProfileResponse = {
+      loginVoiceOptions: ['option1', 'option2'],
+      accessWrapUpCode: 'SPECIFIC',
+      accessIdleCode: 'SPECIFIC',
+      wrapUpCodes: ['aux1'],
+      idleCodes: ['aux2'],
+    };
+
+    getDesktopProfileByIdSpy.mockResolvedValue(specificDesktopProfileResponse);
+
+    const specificAuxCodesResponse: ListAuxCodesResponse = {
+      data: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    getListOfAuxCodesSpy.mockResolvedValue(specificAuxCodesResponse);
+
+    const expectedProfile: IAgentProfile = {
+      agentId: 'agent123',
+      agentName: 'John Doe',
+      agentProfileId: 'profile123',
+      agentMailId: 'john.doe@example.com',
+      teams: mockTeamsListResponse,
+      loginVoiceOptions: ['option1', 'option2'],
+      wrapUpCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+      ],
+      idleCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    expect(getUserUsingCISpy).toHaveBeenCalledOnceWith;
+    expect(getDesktopProfileByIdSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfTeamsSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfAuxCodesSpy).toHaveBeenCalledOnceWith;
+
+    const result = await agentConfig.getAgentProfile();
+    expect(result).toEqual(expectedProfile);
+  });
+
+  it('should handle accessIdleCode as ALL and accessWrapUpCode as SPECIFIC', async () => {
+    const mixedDesktopProfileResponse: DesktopProfileResponse = {
+      loginVoiceOptions: ['option1', 'option2'],
+      accessWrapUpCode: 'SPECIFIC',
+      accessIdleCode: 'ALL',
+      wrapUpCodes: ['aux1'],
+      idleCodes: [],
+    };
+
+    getDesktopProfileByIdSpy.mockResolvedValue(mixedDesktopProfileResponse);
+
+    const mixedAuxCodesResponse: ListAuxCodesResponse = {
+      data: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    getListOfAuxCodesSpy.mockResolvedValue(mixedAuxCodesResponse);
+
+    const expectedProfile: IAgentProfile = {
+      agentId: 'agent123',
+      agentName: 'John Doe',
+      agentProfileId: 'profile123',
+      agentMailId: 'john.doe@example.com',
+      teams: mockTeamsListResponse,
+      loginVoiceOptions: ['option1', 'option2'],
+      wrapUpCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+      ],
+      idleCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    expect(getUserUsingCISpy).toHaveBeenCalledOnceWith;
+    expect(getDesktopProfileByIdSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfTeamsSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfAuxCodesSpy).toHaveBeenCalledOnceWith;
+
+    const result = await agentConfig.getAgentProfile();
+    expect(result).toEqual(expectedProfile);
+  });
+
+  it('should handle accessIdleCode as SPECIFIC and accessWrapUpCode as ALL', async () => {
+    const mixedDesktopProfileResponse: DesktopProfileResponse = {
+      loginVoiceOptions: ['option1', 'option2'],
+      accessWrapUpCode: 'ALL',
+      accessIdleCode: 'SPECIFIC',
+      wrapUpCodes: [],
+      idleCodes: ['aux2'],
+    };
+
+    getDesktopProfileByIdSpy.mockResolvedValue(mixedDesktopProfileResponse);
+
+    const mixedAuxCodesResponse: ListAuxCodesResponse = {
+      data: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    getListOfAuxCodesSpy.mockResolvedValue(mixedAuxCodesResponse);
+
+    const expectedProfile: IAgentProfile = {
+      agentId: 'agent123',
+      agentName: 'John Doe',
+      agentProfileId: 'profile123',
+      agentMailId: 'john.doe@example.com',
+      teams: mockTeamsListResponse,
+      loginVoiceOptions: ['option1', 'option2'],
+      wrapUpCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.WRAP_UP_CODE,
+        },
+      ],
+      idleCodes: [
+        {
+          id: 'aux1',
+          active: true,
+          defaultCode: true,
+          isSystemCode: true,
+          description: 'test',
+          name: 'testName',
+          workTypeCode: WORK_TYPE_CODE.IDLE_CODE,
+        },
+      ],
+    };
+
+    expect(getUserUsingCISpy).toHaveBeenCalledOnceWith;
+    expect(getDesktopProfileByIdSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfTeamsSpy).toHaveBeenCalledOnceWith;
+    expect(getListOfAuxCodesSpy).toHaveBeenCalledOnceWith;
+
+    const result = await agentConfig.getAgentProfile();
+    expect(result).toEqual(expectedProfile);
+  });
+});
diff --git a/packages/@webex/plugin-cc/test/unit/spec/services/WebCallingService.ts b/packages/@webex/plugin-cc/test/unit/spec/services/WebCallingService.ts
new file mode 100644
index 00000000000..330afeab234
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/services/WebCallingService.ts
@@ -0,0 +1,147 @@
+import 'jsdom-global/register';
+import WebCallingService from '../../../../src/services/WebCallingService';
+import {
+  createClient,
+  ICallingClient,
+  ILine,
+  LINE_EVENTS,
+  ICall,
+  CallingClientConfig,
+} from '@webex/calling';
+import {WebexSDK} from '../../../../src/types';
+import config from '../../../../src/config';
+jest.mock('@webex/calling');
+
+describe('WebCallingService', () => {
+  let webex: WebexSDK;
+  let callingClient: ICallingClient;
+  let line: ILine;
+  let webRTCCalling: WebCallingService;
+
+  beforeEach(() => {
+    webex = {
+      logger: {
+        log: jest.fn(),
+        error: jest.fn(),
+      },
+    } as unknown as WebexSDK;
+
+    callingClient = {
+      getLines: jest.fn().mockReturnValue({
+        line1: {
+          on: jest.fn(),
+          register: jest.fn(),
+          deregister: jest.fn(),
+        },
+      }),
+    } as unknown as ICallingClient;
+
+    (createClient as jest.Mock).mockResolvedValue(callingClient);
+
+    webRTCCalling = new WebCallingService(
+      webex,
+      config.cc.callingClientConfig as CallingClientConfig
+    );
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.useRealTimers();
+  });
+
+  describe('registerWebCallingLine', () => {
+    it('should register the web calling line successfully', async () => {
+      line = callingClient.getLines().line1 as ILine;
+      const deviceInfo = {
+        mobiusDeviceId: 'device123',
+        status: 'registered',
+        setError: jest.fn(),
+        getError: jest.fn(),
+        type: 'line',
+        id: 'line1',
+      };
+
+      const registeredHandler = jest.fn();
+      line.on.mockImplementation((event, handler) => {
+        if (event === LINE_EVENTS.REGISTERED) {
+          registeredHandler.mockImplementation(handler);
+          handler(deviceInfo);
+        }
+      });
+
+      await expect(webRTCCalling.registerWebCallingLine()).resolves.toBeUndefined();
+
+      expect(createClient).toHaveBeenCalledWith(webex, config.cc.callingClientConfig);
+      expect(line.on).toHaveBeenCalledWith(LINE_EVENTS.REGISTERED, expect.any(Function));
+      expect(line.register).toHaveBeenCalled();
+      expect(webex.logger.log).toHaveBeenCalledWith(
+        `WxCC-SDK: Desktop registered successfully, mobiusDeviceId: ${deviceInfo.mobiusDeviceId}`
+      );
+    }, 20000); // Increased timeout to 20 seconds
+
+    it('should reject if registration times out', async () => {
+      line = callingClient.getLines().line1 as ILine;
+
+      const promise = webRTCCalling.registerWebCallingLine();
+
+      await expect(promise).rejects.toThrow('WebCallingService Registration timed out');
+    }, 20003); // Increased timeout to 20 seconds
+
+    it('should handle incoming calls', async () => {
+      line = callingClient.getLines().line1 as ILine;
+      const callObj = {on: jest.fn()} as unknown as ICall;
+
+      const incomingCallHandler = jest.fn();
+      const registeredHandler = jest.fn();
+
+      line.on.mockImplementation((event, handler) => {
+        if (event === LINE_EVENTS.INCOMING_CALL) {
+          incomingCallHandler.mockImplementation(handler);
+          handler(callObj);
+        }
+        if (event === LINE_EVENTS.REGISTERED) {
+          registeredHandler.mockImplementation(handler);
+          handler({
+            mobiusDeviceId: 'device123',
+            status: 'registered',
+            setError: jest.fn(),
+            getError: jest.fn(),
+            type: 'line',
+            id: 'line1',
+          });
+        }
+      });
+
+      await webRTCCalling.registerWebCallingLine();
+
+      expect(line.on).toHaveBeenCalledWith(LINE_EVENTS.INCOMING_CALL, expect.any(Function));
+      expect(line.on).toHaveBeenCalledWith(LINE_EVENTS.REGISTERED, expect.any(Function));
+
+      const eventListener = jest.fn();
+      const loggerSpy = jest.spyOn(webex.logger, 'log').mockClear();
+
+      window.addEventListener('line:incoming_call', eventListener);
+
+      line.on.mock.calls.find((call) => call[0] === LINE_EVENTS.INCOMING_CALL)[1](callObj);
+
+      expect(eventListener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          detail: {call: callObj},
+        })
+      );
+    }, 20000); // Increased timeout to 20 seconds
+  });
+
+  describe('deregisterWebCallingLine', () => {
+    it('should deregister the web calling line', async () => {
+      line = callingClient.getLines().line1 as ILine;
+      webRTCCalling['line'] = line; // Ensure line is set before calling deregister
+
+      const deregisterSpy = jest.spyOn(line, 'deregister');
+
+      await webRTCCalling.deregisterWebCallingLine();
+
+      expect(deregisterSpy).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/packages/@webex/plugin-cc/test/unit/spec/services/agent/index.ts b/packages/@webex/plugin-cc/test/unit/spec/services/agent/index.ts
new file mode 100644
index 00000000000..ab20501f97c
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/services/agent/index.ts
@@ -0,0 +1,60 @@
+import routingAgent from '../../../../../src/services/agent';
+import AqmReqs from '../../../../../src/services/core/aqm-reqs';
+import * as Utils from '../../../../../src/services/core/Utils';
+
+jest.mock('../../../../../src/services/core/Utils', () => ({
+  createErrDetailsObject: jest.fn(),
+  getRoutingHost: jest.fn(),
+}));
+
+jest.mock('../../../../../src/services/core/aqm-reqs');
+
+describe('AQM routing agent', () => {
+  let fakeAqm: jest.Mocked<AqmReqs>;
+  let agent: ReturnType<typeof routingAgent>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    fakeAqm = new AqmReqs() as jest.Mocked<AqmReqs>;
+    fakeAqm.reqEmpty = jest.fn().mockImplementation((fn) => fn);
+    fakeAqm.req = jest.fn().mockImplementation((fn) => fn);
+
+    agent = routingAgent(fakeAqm);
+  });
+
+  it('logout', async () => {
+    const reqSpy = jest.spyOn(fakeAqm, 'reqEmpty');
+    reqSpy.mockRejectedValue(new Error('dasd'));
+    const req = await agent.logout({data: {logoutReason: 'User requested logout'}});
+    expect(req).toBeDefined();
+    expect(reqSpy).toHaveBeenCalled();
+  });
+
+  it('reload', async () => {
+    const reqSpy = jest.spyOn(fakeAqm, 'reqEmpty');
+    const req = await agent.reload();
+    expect(req).toBeDefined();
+    expect(reqSpy).toHaveBeenCalled();
+  });
+
+  it('stationLogin', async () => {
+    const reqSpy = jest.spyOn(fakeAqm, 'req');
+    const req = await agent.stationLogin({data: {} as any});
+    expect(req).toBeDefined();
+    expect(reqSpy).toHaveBeenCalled();
+  });
+
+  it('stateChange', async () => {
+    const reqSpy = jest.spyOn(fakeAqm, 'req');
+    const req = await agent.stateChange({data: {} as any});
+    expect(req).toBeDefined();
+    expect(reqSpy).toHaveBeenCalled();
+  });
+  it('buddyAgents', async () => {
+    const reqSpy = jest.spyOn(fakeAqm, 'req');
+    const req = await agent.buddyAgents({data: {} as any});
+    expect(req).toBeDefined();
+    expect(reqSpy).toHaveBeenCalled();
+  });
+});
diff --git a/packages/@webex/plugin-cc/test/unit/spec/services/config/index.ts b/packages/@webex/plugin-cc/test/unit/spec/services/config/index.ts
new file mode 100644
index 00000000000..bfb322f5602
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/services/config/index.ts
@@ -0,0 +1,252 @@
+import {WebexSDK} from '../../../../../src/types';
+import AgentConfigService from '../../../../../src/services/config';
+import HttpRequest from '../../../../../src/services/core/HttpRequest';
+import {WCC_API_GATEWAY} from '../../../../../src/services/constants';
+import MockWebex from '@webex/test-helper-mock-webex';
+
+describe('AgentConfigService', () => {
+  let agentConfigService: AgentConfigService;
+  let webex: WebexSDK;
+  let mockHttpRequest: HttpRequest;
+  const mockAgentId = 'agent123';
+  const mockOrgId = 'org123';
+  const mockWccAPIURL = WCC_API_GATEWAY;
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      logger: {
+        log: jest.fn(),
+      },
+    });
+
+    webex.internal.device.orgId = mockOrgId;
+
+    mockHttpRequest = HttpRequest.getInstance({webex});
+    mockHttpRequest.request = jest.fn();
+
+    agentConfigService = new AgentConfigService(mockAgentId, webex, mockHttpRequest);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getUserUsingCI', () => {
+    it('should return AgentResponse on success', async () => {
+      const mockResponse = {
+        statusCode: 200,
+        body: {
+          firstName: 'John',
+          lastName: 'Doe',
+          agentProfileId: 'profile123',
+          email: 'john.doe@example.com',
+          teamIds: ['123', '456'],
+        },
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await agentConfigService.getUserUsingCI();
+
+      expect(mockHttpRequest.request).toHaveBeenCalledWith({
+        service: mockWccAPIURL,
+        resource: `organization/${mockOrgId}/user/by-ci-user-id/${mockAgentId}`,
+        method: 'GET',
+      });
+      expect(result).toEqual(mockResponse.body);
+      expect(webex.logger.log).toHaveBeenCalledWith('getUserUsingCI api success.');
+    });
+
+    it('should throw an error if the API call fails', async () => {
+      const mockError = new Error('API call failed');
+      (mockHttpRequest.request as jest.Mock).mockRejectedValue(mockError);
+
+      await expect(agentConfigService.getUserUsingCI()).rejects.toThrow('API call failed');
+    });
+
+    it('should throw an error if the getUserUsingCI call fails with other than 200', async () => {
+      const mockResponse = {
+        statusCode: 400,
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      try {
+        await agentConfigService.getUserUsingCI();
+      } catch (error) {
+        expect(error).toEqual(new Error(`API call failed with ${mockResponse.statusCode}`));
+      }
+    });
+  });
+
+  describe('getDesktopProfileById', () => {
+    const desktopProfileId = 'profile123';
+
+    it('should return DesktopProfileResponse on success', async () => {
+      const mockResponse = {
+        statusCode: 200,
+        body: {
+          loginVoiceOptions: ['option1', 'option2'],
+          accessWrapUpCode: 'ALL',
+          accessIdleCode: 'SPECIFIC',
+          wrapUpCodes: ['code1', 'code2'],
+          idleCodes: ['idle1', 'idle2'],
+        },
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await agentConfigService.getDesktopProfileById(desktopProfileId);
+
+      expect(mockHttpRequest.request).toHaveBeenCalledWith({
+        service: mockWccAPIURL,
+        resource: `organization/${mockOrgId}/agent-profile/${desktopProfileId}`,
+        method: 'GET',
+      });
+      expect(result).toEqual(mockResponse.body);
+      expect(webex.logger.log).toHaveBeenCalledWith('getDesktopProfileById api success.');
+    });
+
+    it('should throw an error if the API call fails', async () => {
+      const mockError = new Error('API call failed');
+      (mockHttpRequest.request as jest.Mock).mockRejectedValue(mockError);
+
+      try {
+        await agentConfigService.getDesktopProfileById(desktopProfileId);
+      } catch (error) {
+        expect(error).toEqual(mockError);
+      }
+    });
+
+    it('should throw an error if the getDesktopProfileById call fails with other than 200', async () => {
+      const mockResponse = {
+        statusCode: 400,
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      try {
+        await agentConfigService.getDesktopProfileById(desktopProfileId);
+      } catch (error) {
+        expect(error).toEqual(new Error(`API call failed with ${mockResponse.statusCode}`));
+      }
+    });
+  });
+
+  describe('getListOfTeams', () => {
+    const page = 0;
+    const pageSize = 10;
+    const filter: string[] = ['123'];
+    const attributes: string[] = ['id'];
+
+    it('should return team on success', async () => {
+      const mockResponse = {
+        statusCode: 200,
+        body: [
+          {id: '123', name: 'Team 1'},
+          {id: '12345', name: 'Team 2'},
+        ],
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await agentConfigService.getListOfTeams(page, pageSize, filter, attributes);
+
+      expect(mockHttpRequest.request).toHaveBeenCalledWith({
+        service: mockWccAPIURL,
+        resource: `organization/${mockOrgId}/team?page=${page}&pageSize=${pageSize}&filter=id=in=${filter}&attributes=${attributes}`,
+        method: 'GET',
+      });
+      expect(result).toEqual(mockResponse.body);
+      expect(webex.logger.log).toHaveBeenCalledWith('getListOfTeams api success.');
+    });
+
+    it('should throw an error if the API call fails', async () => {
+      const mockError = new Error('API call failed');
+      (mockHttpRequest.request as jest.Mock).mockRejectedValue(mockError);
+
+      try {
+        await agentConfigService.getListOfTeams(page, pageSize, filter, attributes);
+      } catch (error) {
+        expect(error).toEqual(mockError);
+      }
+    });
+
+    it('should throw an error if the getListOfTeams call fails with other than 200', async () => {
+      const mockResponse = {
+        statusCode: 400,
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      try {
+        await agentConfigService.getListOfTeams(page, pageSize, filter, attributes);
+      } catch (error) {
+        expect(error).toEqual(new Error(`API call failed with ${mockResponse.statusCode}`));
+      }
+    });
+  });
+
+  describe('getListOfAuxCodes', () => {
+    const page = 0;
+    const pageSize = 10;
+    const filter: string[] = ['123'];
+    const attributes: string[] = ['id'];
+
+    it('should return ListAuxCodesResponse on success', async () => {
+      const mockResponse = {
+        statusCode: 200,
+        body: {
+          data: [
+            {
+              id: 'aux1',
+              active: true,
+              defaultCode: false,
+              isSystemCode: false,
+              description: 'Aux 1',
+              name: 'Aux 1',
+              workTypeCode: 'work1',
+            },
+            {
+              id: 'aux2',
+              active: true,
+              defaultCode: false,
+              isSystemCode: false,
+              description: 'Aux 2',
+              name: 'Aux 2',
+              workTypeCode: 'work2',
+            },
+          ],
+        },
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await agentConfigService.getListOfAuxCodes(page, pageSize, filter, attributes);
+
+      expect(mockHttpRequest.request).toHaveBeenCalledWith({
+        service: mockWccAPIURL,
+        resource: `organization/${mockOrgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}&filter=id=in=${filter}&attributes=${attributes}`,
+        method: 'GET',
+      });
+      expect(result).toEqual(mockResponse.body);
+      expect(webex.logger.log).toHaveBeenCalledWith('getListOfAuxCodes api success.');
+    });
+
+    it('should throw an error if the API call fails', async () => {
+      const mockError = new Error('API call failed');
+      (mockHttpRequest.request as jest.Mock).mockRejectedValue(mockError);
+      try {
+        await agentConfigService.getListOfAuxCodes(page, pageSize, filter, attributes);
+      } catch (error) {
+        expect(error).toEqual(mockError);
+      }
+    });
+
+    it('should throw an error if the getListOfAuxCodes call fails with other than 200', async () => {
+      const mockResponse = {
+        statusCode: 400,
+      };
+      (mockHttpRequest.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      try {
+        await agentConfigService.getListOfAuxCodes(page, pageSize, filter, attributes);
+      } catch (error) {
+        expect(error).toEqual(new Error(`API call failed with ${mockResponse.statusCode}`));
+      }
+    });
+  });
+});
diff --git a/packages/@webex/plugin-cc/test/unit/spec/services/core/HttpRequest.ts b/packages/@webex/plugin-cc/test/unit/spec/services/core/HttpRequest.ts
new file mode 100644
index 00000000000..6d268ba2707
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/services/core/HttpRequest.ts
@@ -0,0 +1,67 @@
+import HttpRequest from '../../../../../src/services/core/HttpRequest';
+import {HTTP_METHODS, WebexSDK} from '../../../../../src/types';
+import {IHttpResponse} from '../../../../../src/types';
+
+const mockWebex = {
+  request: jest.fn(),
+  logger: {
+    log: jest.fn(),
+    error: jest.fn(),
+  },
+} as unknown as WebexSDK;
+
+// Cast the request function to a Jest mock function
+const mockRequest = mockWebex.request as jest.Mock;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('HttpRequest', () => {
+  let httpRequest;
+  beforeEach(() => {
+    httpRequest = HttpRequest.getInstance({webex: mockWebex});
+  });
+
+  describe('request', () => {
+    it('should send a request and return the response', async () => {
+      const mockResponse: IHttpResponse = {
+        statusCode: 200,
+        body: { message: 'Success' },
+        method: 'POST',
+        url: 'https://example.com/resource',
+      };
+
+      mockRequest.mockResolvedValueOnce(mockResponse);
+
+      const result = await httpRequest.request({
+        service: 'service',
+        resource: 'resource',
+        method: HTTP_METHODS.POST,
+        body: { key: 'value' },
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(mockRequest).toHaveBeenCalledWith({
+        service: 'service',
+        resource: 'resource',
+        method: HTTP_METHODS.POST,
+        body: { key: 'value' },
+      });
+    });
+
+    it('should log and throw an error if the request fails', async () => {
+      const mockError = new Error('Request failed');
+      mockRequest.mockRejectedValueOnce(mockError);
+
+      await expect(
+        httpRequest.request({
+          service: 'service',
+          resource: 'resource',
+          method: HTTP_METHODS.POST,
+          body: { key: 'value' },
+        })
+      ).rejects.toThrow('Request failed');
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/WebSocketManager.ts b/packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/WebSocketManager.ts
new file mode 100644
index 00000000000..ccbcc2d864a
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/WebSocketManager.ts
@@ -0,0 +1,372 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { WebSocketManager } from '../../../../../../src/services/core/WebSocket/WebSocketManager';
+import { WebexSDK, SubscribeRequest } from '../../../../../../src/types';
+import { SUBSCRIBE_API, WCC_API_GATEWAY } from '../../../../../../src/services/constants';
+import LoggerProxy from '../../../../../../src/logger-proxy';
+
+jest.mock('../../../../../../src/services/core/HttpRequest');
+jest.mock('../../../../../../src/logger-proxy', () => ({
+  __esModule: true,
+  default: {
+    logger: {
+      log: jest.fn(),
+      error: jest.fn(),
+      info: jest.fn(),
+    },
+    initialize: jest.fn(),
+  },
+}));
+
+class MockWebSocket {
+  static inst: MockWebSocket;
+  onopen: () => void = () => { };
+  onerror: (event: any) => void = () => { };
+  onclose: (event: any) => void = () => { };
+  onmessage: (msg: any) => void = () => { };
+  close = jest.fn();
+  send = jest.fn();
+
+  constructor() {
+    MockWebSocket.inst = this;
+    setTimeout(() => {
+      this.onopen();
+    }, 10);
+  }
+}
+
+// Mock CustomEvent class
+class MockCustomEvent<T> extends Event {
+  detail: T;
+
+  constructor(event: string, params: { detail: T }) {
+    super(event);
+    this.detail = params.detail;
+  }
+}
+
+global.CustomEvent = MockCustomEvent as any;
+
+// Mock MessageEvent class
+class MockMessageEvent extends Event {
+  data: any;
+
+  constructor(type: string, eventInitDict: { data: any }) {
+    super(type);
+    this.data = eventInitDict.data;
+  }
+}
+
+global.MessageEvent = MockMessageEvent as any;
+
+describe('WebSocketManager', () => {
+  let webSocketManager: WebSocketManager;
+  let mockWebex: WebexSDK;
+  let mockWorker: any;
+
+  const fakeSubscribeRequest: SubscribeRequest = {
+    force: true,
+    isKeepAliveEnabled: false,
+    clientType: 'WebexCCSDK',
+    allowMultiLogin: true,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockWebex = {
+      request: jest.fn(),
+    } as unknown as WebexSDK;
+
+    mockWorker = {
+      postMessage: jest.fn(),
+      onmessage: jest.fn(),
+    };
+
+    global.Worker = jest.fn(() => mockWorker) as any;
+    global.WebSocket = MockWebSocket as any;
+
+    global.Blob = function (content: any[], options: any) {
+      return { content, options };
+    } as any;
+
+    global.URL.createObjectURL = function (blob: Blob) {
+      return 'blob:http://localhost:3000/12345';
+    };
+
+    webSocketManager = new WebSocketManager({ webex: mockWebex });
+
+    setTimeout(() => {
+      MockWebSocket.inst.onopen();
+      MockWebSocket.inst.onmessage({ data: JSON.stringify({ type: "Welcome" }) });
+    }, 1);
+
+    console.log = jest.fn();
+    console.error = jest.fn();
+  });
+
+  it('should initialize WebSocketManager', () => {
+    expect(webSocketManager).toBeDefined();
+  });
+
+  it('should register and connect to WebSocket', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    expect(mockWebex.request).toHaveBeenCalledWith({
+      service: WCC_API_GATEWAY,
+      resource: SUBSCRIBE_API,
+      method: 'POST',
+      body: fakeSubscribeRequest,
+    });
+  });
+
+  it('should close WebSocket connection', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    webSocketManager.close(true, 'Test reason');
+
+    expect(MockWebSocket.inst.close).toHaveBeenCalled();
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+  });
+
+  it('should handle WebSocket keepalive messages', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    setTimeout(() => {
+      MockWebSocket.inst.onopen();
+      MockWebSocket.inst.onmessage({ data: JSON.stringify({ type: 'keepalive' }) });
+      mockWorker.onmessage({
+        data: {
+          type: 'keepalive'
+        }
+      });
+    }, 1);
+
+    expect(MockWebSocket.inst.send).toHaveBeenCalledWith(JSON.stringify({ keepalive: 'true' }));
+  });
+
+  it('should handle WebSocket close due to network issue', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    // Mock navigator.onLine to simulate network issue
+    Object.defineProperty(global, 'navigator', {
+      value: {
+        onLine: false,
+      },
+      configurable: true,
+    });
+
+    // Simulate the WebSocket close event
+    setTimeout(() => {
+      MockWebSocket.inst.onclose({
+        wasClean: false,
+        code: 1006,
+        reason: 'network issue',
+        target: MockWebSocket.inst,
+      });
+    }, 1);
+
+    // Wait for the close event to be handled
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(LoggerProxy.logger.info).toHaveBeenCalledWith(
+      '[WebSocketStatus] | desktop online status is false'
+    );
+    expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+      '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: network issue'
+    );
+
+    // Restore navigator.onLine to true
+    Object.defineProperty(global, 'navigator', {
+      value: {
+        onLine: true,
+      },
+      configurable: true,
+    });
+  });
+
+  it('should handle WebSocket error event', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    const errorEvent = new Event('error');
+    MockWebSocket.inst.onerror(errorEvent);
+
+    expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+      '[WebSocketStatus] | event=socketConnectionFailed | WebSocket connection failed [object Event]'
+    );
+  });
+
+  it('should handle WebSocket message event with AGENT_MULTI_LOGIN', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    const messageEvent = new MessageEvent('message', {
+      data: JSON.stringify({ type: 'AGENT_MULTI_LOGIN' }),
+    });
+    MockWebSocket.inst.onmessage(messageEvent);
+
+    expect(MockWebSocket.inst.close).toHaveBeenCalled();
+    expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+      '[WebSocketStatus] | event=agentMultiLogin | WebSocket connection closed by agent multiLogin'
+    );
+  });
+
+  it('should handle WebSocket message event with Welcome', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    const messageEvent = new MessageEvent('message', {
+      data: JSON.stringify({ type: 'Welcome', data: { someData: 'data' } }),
+    });
+    MockWebSocket.inst.onmessage(messageEvent);
+
+    expect(webSocketManager['isWelcomeReceived']).toBe(true);
+  });
+
+  it('should handle WebSocket close with forceCloseWebSocketOnTimeout', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    webSocketManager['forceCloseWebSocketOnTimeout'] = true;
+
+    // Simulate the WebSocket close event
+    setTimeout(() => {
+      MockWebSocket.inst.onclose({
+        wasClean: false,
+        code: 1006,
+        reason: 'timeout',
+        target: MockWebSocket.inst,
+      });
+    }, 1);
+
+    webSocketManager.shouldReconnect = true;
+
+    // Wait for the close event to be handled
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(LoggerProxy.logger.error).toHaveBeenCalledWith(
+      '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: WebSocket auto close timed out. Forcefully closed websocket.'
+    );
+  });
+
+  it('should handle WebSocket close without reconnect', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+    webSocketManager.shouldReconnect = false;
+    // Simulate the WebSocket close event
+    setTimeout(() => {
+      MockWebSocket.inst.onclose({
+        wasClean: false,
+        code: 1006,
+        reason: 'no reconnect',
+        target: MockWebSocket.inst,
+      });
+    }, 1);
+    
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(LoggerProxy.logger.error).not.toHaveBeenCalledWith(
+      '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: no reconnect'
+    );
+  });
+
+  it('should handle WebSocket close with clean close', async () => {
+    const subscribeResponse = {
+      body: {
+        webSocketUrl: 'wss://fake-url',
+      },
+    };
+
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest });
+
+    // Simulate the WebSocket close event
+    setTimeout(() => {
+      MockWebSocket.inst.onclose({
+        wasClean: true,
+        code: 1000,
+        reason: 'clean close',
+        target: MockWebSocket.inst,
+      });
+    }, 1);
+
+    // Wait for the close event to be handled
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(LoggerProxy.logger.error).not.toHaveBeenCalledWith(
+      '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: clean close'
+    );
+  });
+});
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/connection-service.ts b/packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/connection-service.ts
new file mode 100644
index 00000000000..9a62dad53ad
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/services/core/WebSocket/connection-service.ts
@@ -0,0 +1,164 @@
+import {ConnectionService} from '../../../../../../src/services/core/WebSocket/connection-service';
+import {WebSocketManager} from '../../../../../../src/services/core/WebSocket/WebSocketManager';
+import {SubscribeRequest} from '../../../../../../src/types';
+import LoggerProxy from '../../../../../../src/logger-proxy';
+import {CONNECTIVITY_CHECK_INTERVAL} from '../../../../../../src/services/core/constants';
+
+jest.mock('../../../../../../src/services/core/WebSocket/WebSocketManager');
+jest.mock('../../../../../../src/logger-proxy', () => ({
+  __esModule: true,
+  default: {
+    logger: {
+      log: jest.fn(),
+      error: jest.fn(),
+      info: jest.fn(),
+    },
+    initialize: jest.fn(),
+  },
+}));
+
+// Mock CustomEvent class
+class MockCustomEvent<T> extends Event {
+  detail: T;
+
+  constructor(event: string, params: {detail: T}) {
+    super(event);
+    this.detail = params.detail;
+  }
+}
+
+global.CustomEvent = MockCustomEvent as any;
+
+describe('ConnectionService', () => {
+  let connectionService: ConnectionService;
+  let mockWebSocketManager: jest.Mocked<WebSocketManager>;
+  const mockSubscribeRequest: SubscribeRequest = {
+    force: true,
+    isKeepAliveEnabled: false,
+    clientType: 'WebexCCSDK',
+    allowMultiLogin: true,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+
+    mockWebSocketManager = new WebSocketManager({
+      webex: {} as any,
+    }) as jest.Mocked<WebSocketManager>;
+    mockWebSocketManager.initWebSocket = jest.fn().mockResolvedValue({});
+
+    // Mock the addEventListener method
+    mockWebSocketManager.addEventListener = jest.fn();
+
+    connectionService = new ConnectionService(mockWebSocketManager, mockSubscribeRequest);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.clearAllTimers();
+  });
+
+  it('should initialize ConnectionService', () => {
+    expect(connectionService).toBeDefined();
+  });
+
+  it('should set connection properties', () => {
+    const newProps = {lostConnectionRecoveryTimeout: 30000};
+    connectionService.setConnectionProp(newProps);
+    expect(connectionService['connectionProp']).toEqual(newProps);
+  });
+
+  it('should handle ping message and update connection data', () => {
+    const pingMessage = new CustomEvent<string>('message', {
+      detail: JSON.stringify({keepalive: 'true'}),
+    });
+    connectionService['onPing'](pingMessage);
+    expect(connectionService['isKeepAlive']).toBe(true);
+    expect(connectionService['isConnectionLost']).toBe(false);
+    expect(connectionService['isRestoreFailed']).toBe(false);
+    expect(connectionService['isSocketReconnected']).toBe(false);
+  });
+
+  it('should handle connection lost', () => {
+    connectionService['handleConnectionLost']();
+    expect(connectionService['isConnectionLost']).toBe(true);
+  });
+
+  it('should clear timer on restore failed', async () => {
+    connectionService['reconnectInterval'] = setInterval(() => {}, 1000);
+    jest.spyOn(global, 'clearInterval');
+    await connectionService['clearTimerOnRestoreFailed']();
+    expect(clearInterval).toHaveBeenCalledWith(connectionService['reconnectInterval']);
+  });
+
+  it('should handle restore failed', async () => {
+    await connectionService['handleRestoreFailed']();
+    expect(connectionService['isRestoreFailed']).toBe(true);
+    expect(connectionService['webSocketManager'].shouldReconnect).toBe(false);
+  });
+
+  it('should handle socket close when online', async () => {
+    Object.defineProperty(global, 'navigator', {
+      value: {
+        onLine: true,
+      },
+      configurable: true,
+    });
+
+    await connectionService['handleSocketClose']();
+    expect(LoggerProxy.logger.info).toHaveBeenCalledWith(
+      'event=socketConnectionRetry | Trying to reconnect to notifs socket'
+    );
+    expect(mockWebSocketManager.initWebSocket).toHaveBeenCalledWith({body: mockSubscribeRequest});
+  });
+
+  it('should handle ping message without keepalive and not update connection data', () => {
+    const pingMessage = new CustomEvent<string>('message', {
+      detail: JSON.stringify({ someOtherProperty: 'value' }),
+    });
+    connectionService['onPing'](pingMessage);
+    expect(connectionService['isKeepAlive']).toBe(false);
+    expect(connectionService['isConnectionLost']).toBe(false);
+    expect(connectionService['isRestoreFailed']).toBe(false);
+    expect(connectionService['isSocketReconnected']).toBe(false);
+  });
+
+  describe('ConnectionService Reconnect', () => {
+    it('should handle connection lost and set isConnectionLost to true', () => {
+      connectionService['handleConnectionLost']();
+      expect(connectionService['isConnectionLost']).toBe(true);
+    });
+
+    it('should handle restore failed and set isRestoreFailed to true', async () => {
+      await connectionService['handleRestoreFailed']();
+      expect(connectionService['isRestoreFailed']).toBe(true);
+    });
+
+    it('should handle restore failed and set shouldReconnect to false', async () => {
+      await connectionService['handleRestoreFailed']();
+      expect(connectionService['webSocketManager'].shouldReconnect).toBe(false);
+    });
+
+    it('should handle socket close and reconnect when online', async () => {
+      Object.defineProperty(global, 'navigator', {
+        value: {
+          onLine: true,
+        },
+        configurable: true,
+      });
+
+      await connectionService['handleSocketClose']();
+      expect(LoggerProxy.logger.info).toHaveBeenCalledWith(
+        'event=socketConnectionRetry | Trying to reconnect to notifs socket'
+      );
+      expect(mockWebSocketManager.initWebSocket).toHaveBeenCalledWith({body: mockSubscribeRequest});
+    });
+
+    it('should handle onSocketClose and start reconnect interval', () => {
+      jest.spyOn(global, 'setInterval');
+      connectionService['onSocketClose']();
+      expect(setInterval).toHaveBeenCalledWith(expect.any(Function), CONNECTIVITY_CHECK_INTERVAL);
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/@webex/plugin-cc/test/unit/spec/services/core/aqm-reqs.ts b/packages/@webex/plugin-cc/test/unit/spec/services/core/aqm-reqs.ts
new file mode 100644
index 00000000000..95e03970fee
--- /dev/null
+++ b/packages/@webex/plugin-cc/test/unit/spec/services/core/aqm-reqs.ts
@@ -0,0 +1,569 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import AqmReqs from '../../../../../src/services/core/aqm-reqs';
+import HttpRequest from '../../../../../src/services/core/HttpRequest';
+import {WebSocketManager} from '../../../../../src/services/core/WebSocket/WebSocketManager';
+import LoggerProxy from '../../../../../src/logger-proxy';
+import {IHttpResponse} from '../../../../../src/types';
+
+jest.mock('../../../../../src/services/core/HttpRequest');
+jest.mock('../../../../../src/logger-proxy', () => ({
+  __esModule: true,
+  default: {
+    logger: {
+      log: jest.fn(),
+      error: jest.fn(),
+      info: jest.fn(),
+    },
+    initialize: jest.fn(),
+  },
+}));
+jest.mock('../../../../../src/services/core/WebSocket/WebSocketManager');
+
+// Mock CustomEvent class
+class MockCustomEvent<T> extends Event {
+  detail: T;
+
+  constructor(event: string, params: {detail: T}) {
+    super(event);
+    this.detail = params.detail;
+  }
+}
+
+global.CustomEvent = MockCustomEvent as any;
+
+global.window = {
+  setTimeout: global.setTimeout,
+} as any;
+
+const mockHttpRequest = HttpRequest as jest.MockedClass<typeof HttpRequest>;
+const mockWebSocketManager = WebSocketManager as jest.MockedClass<typeof WebSocketManager>;
+
+describe('AqmReqs', () => {
+  let httpRequestInstance: jest.Mocked<HttpRequest>;
+  let webSocketManagerInstance: jest.Mocked<WebSocketManager>;
+  const mockHttpRequestResolvedValue: IHttpResponse = {
+    status: 202,
+    data: {webSocketUrl: 'fake-url'},
+    statusText: 'OK',
+    headers: {},
+    config: {},
+  };
+  let aqm: AqmReqs;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    httpRequestInstance = new HttpRequest() as jest.Mocked<HttpRequest>;
+    mockHttpRequest.getInstance = jest.fn().mockReturnValue(httpRequestInstance);
+
+    const mockWorker = {
+      postMessage: jest.fn(),
+      onmessage: jest.fn(),
+    };
+
+    global.Worker = jest.fn(() => mockWorker) as any;
+
+    webSocketManagerInstance = new WebSocketManager({
+      webex: {} as any,
+    }) as jest.Mocked<WebSocketManager>;
+
+    // Mock the addEventListener method
+    webSocketManagerInstance.addEventListener = jest.fn((event, callback) => {
+      if (event === 'message') {
+        webSocketManagerInstance.dispatchEvent = callback;
+      }
+    });
+
+    aqm = new AqmReqs(webSocketManagerInstance);
+    mockWebSocketManager.mockImplementation(() => webSocketManagerInstance);
+  });
+
+  it('AqmReqs should be defined', async () => {
+    httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+    const req = aqm.req(() => ({
+      url: '/url',
+      timeout: 2000,
+      notifSuccess: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {type: 'AgentConsultConferenced', interactionId: 'intrid'},
+        },
+        msg: {},
+      },
+      notifFail: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {type: 'AgentConsultConferenceFailed'},
+        },
+        errId: 'Service.aqm.contact.consult',
+      },
+    }));
+
+    try {
+      await req({});
+    } catch (e) {
+      expect(e).toBeDefined();
+    }
+  });
+
+  describe('Aqm notifs', () => {
+    it('AqmReqs notifcancel', async () => {
+      httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+      const req = aqm.req(() => ({
+        url: '/url',
+        timeout: 4000,
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentConsultCreated',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9905',
+            },
+          },
+          msg: {},
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultFailed'},
+          },
+          errId: 'Service.aqm.contact.consult',
+        },
+        notifCancel: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentCtqCancelled',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9905',
+            },
+          },
+          msg: {},
+        },
+      }));
+
+      try {
+        const p = await Promise.all([
+          req({}),
+          new Promise<void>((resolve) => {
+            setTimeout(() => {
+              webSocketManagerInstance.dispatchEvent(
+                new CustomEvent('message', {
+                  detail: JSON.stringify({
+                    type: 'RoutingMessage',
+                    data: {
+                      type: 'AgentCtqCancelled',
+                      interactionId: '6920dda3-337a-48b1-b82d-2333392f9905',
+                    },
+                  }),
+                })
+              );
+              resolve();
+            }, 1000);
+          }),
+        ]);
+        expect(p).toBeDefined();
+      } catch (e) {}
+    });
+
+    it('AqmReqs notif success', async () => {
+      httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+      const req = aqm.req(() => ({
+        url: '/url',
+        timeout: 4000,
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentConsultCreated',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9906',
+            },
+          },
+          msg: {},
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultFailed'},
+          },
+          errId: 'Service.aqm.contact.consult',
+        },
+        notifCancel: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentCtqCancelled',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9906',
+            },
+          },
+          msg: {},
+        },
+      }));
+
+      try {
+        const p = await Promise.all([
+          req({}),
+          new Promise<void>((resolve) => {
+            setTimeout(() => {
+              webSocketManagerInstance.dispatchEvent(
+                new CustomEvent('message', {
+                  detail: JSON.stringify({
+                    type: 'RoutingMessage',
+                    data: {
+                      type: 'AgentConsultCreated',
+                      interactionId: '6920dda3-337a-48b1-b82d-2333392f9906',
+                    },
+                  }),
+                })
+              );
+              resolve();
+            }, 1000);
+          }),
+        ]);
+        expect(p).toBeDefined();
+      } catch (e) {}
+    });
+
+    it('AqmReqs notif success with async error', async () => {
+      httpRequestInstance.request.mockRejectedValueOnce(new Error('Async error'));
+
+      const req = aqm.req(() => ({
+        url: '/url',
+        timeout: 4000,
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentConsultCreated',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9906',
+            },
+          },
+          msg: {},
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultFailed'},
+          },
+          errId: 'Service.aqm.contact.consult',
+        },
+        notifCancel: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentCtqCancelled',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9906',
+            },
+          },
+          msg: {},
+        },
+      }));
+
+      try {
+        await req({});
+      } catch (e) {
+        expect(e).toBeDefined();
+      }
+    });
+
+    it('AqmReqs notif fail', async () => {
+      httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+      const req = aqm.req(() => ({
+        url: '/url',
+        timeout: 4000,
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentConsultCreated',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9907',
+            },
+          },
+          msg: {},
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultFailed'},
+          },
+          errId: 'Service.aqm.contact.consult',
+        },
+        notifCancel: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {
+              type: 'AgentCtqCancelled',
+              interactionId: '6920dda3-337a-48b1-b82d-2333392f9907',
+            },
+          },
+          msg: {},
+        },
+      }));
+
+      try {
+        const p = await Promise.all([
+          req({}),
+          new Promise<void>((resolve) => {
+            setTimeout(() => {
+              webSocketManagerInstance.dispatchEvent(
+                new CustomEvent('message', {
+                  detail: JSON.stringify({
+                    type: 'RoutingMessage',
+                    data: {
+                      type: 'AgentConsultFailed',
+                      interactionId: '6920dda3-337a-48b1-b82d-2333392f9907',
+                    },
+                  }),
+                })
+              );
+              resolve();
+            }, 1000);
+          }),
+        ]);
+        expect(p).toBeDefined();
+      } catch (e) {}
+    });
+  });
+
+  describe('Event tests', () => {
+    it('should handle onMessage events', async () => {
+      httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+      const req = aqm.req(() => ({
+        url: '/url',
+        timeout: 2000,
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultConferenced', interactionId: 'intrid'},
+          },
+          msg: {},
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultConferenceFailed'},
+          },
+          errId: 'Service.aqm.contact.consult',
+        },
+      }));
+
+      try {
+        await req({});
+      } catch (e) {
+        expect(e).toBeDefined();
+      }
+
+      // Welcome event
+      webSocketManagerInstance.dispatchEvent(
+        new CustomEvent('message', {
+          detail: JSON.stringify({
+            type: 'Welcome',
+            data: {type: 'WelcomeEvent'},
+          }),
+        })
+      );
+
+      expect(LoggerProxy.logger.info).toHaveBeenCalledWith('Welcome message from Notifs Websocket');
+
+      // Keep-alive events
+      webSocketManagerInstance.dispatchEvent(
+        new CustomEvent('message', {
+          detail: JSON.stringify({
+            keepalive: 'true',
+            data: {type: 'KeepaliveEvent'},
+          }),
+        })
+      );
+
+      expect(LoggerProxy.logger.info).toHaveBeenCalledWith('Keepalive from web socket');
+
+      // Unhandled event
+      webSocketManagerInstance.dispatchEvent(
+        new CustomEvent('message', {
+          detail: JSON.stringify({
+            type: 'UnhandledMessage',
+            data: {type: 'UnhandledEvent'},
+          }),
+        })
+      );
+
+      expect(LoggerProxy.logger.info).toHaveBeenCalledWith(
+        'event=missingEventHandler | [AqmReqs] missing routing message handler'
+      );
+    });
+
+    it('should correctly print bind object', () => {
+      const bind = {
+        type: 'RoutingMessage',
+        data: {
+          type: 'AgentConsultCreated',
+          interactionId: 'intrid',
+        },
+      };
+      const result = aqm['bindPrint'](bind);
+      expect(result).toBe(
+        'type=RoutingMessage,data=(type=AgentConsultCreated,interactionId=intrid)'
+      );
+    });
+
+    it('should correctly check bind object', () => {
+      const bind = {
+        type: 'RoutingMessage',
+        data: {
+          type: 'AgentConsultCreated',
+          interactionId: 'intrid',
+        },
+      };
+      const msg = {
+        type: 'RoutingMessage',
+        data: {
+          type: 'AgentConsultCreated',
+          interactionId: 'intrid',
+        },
+      };
+      const result = aqm['bindCheck'](bind, msg);
+      expect(result).toBe(true);
+    });
+
+    it('should return false when message value does not match any of the values in the array', () => {
+      const bind = {
+        type: 'RoutingMessage',
+        data: {
+          type: ['AgentConsultCreated', 'AgentConsultFailed'],
+          interactionId: 'intrid',
+        },
+      };
+      const msg = {
+        type: 'RoutingMessage',
+        data: {
+          type: 'AgentConsultConferenced', // This value does not match any value in the bind array
+          interactionId: 'intrid',
+        },
+      };
+      const result = aqm['bindCheck'](bind, msg);
+      expect(result).toBe(false);
+    });
+
+    it('should handle reqEmpty', async () => {
+      httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+      const reqEmpty = aqm.reqEmpty(() => ({
+        url: '/url',
+        timeout: 2000,
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultConferenced', interactionId: 'intrid'},
+          },
+          msg: {},
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultConferenceFailed'},
+          },
+          errId: 'Service.aqm.contact.consult',
+        },
+      }));
+
+      try {
+        await reqEmpty();
+      } catch (e) {
+        expect(e).toBeDefined();
+      }
+    });
+
+    it('should handle failed request with err function', async () => {
+      httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+      const conf = {
+        host: 'fake-host',
+        url: '/url',
+        method: 'POST',
+        data: {},
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultCreated', interactionId: 'intrid'},
+          },
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultFailed'},
+          },
+          err: (msg: any) => new Error('Custom error'),
+        },
+      };
+
+      const promise = aqm['createPromise'](conf);
+      global.setTimeout(() => {
+        webSocketManagerInstance.dispatchEvent(
+          new CustomEvent('message', {
+            detail: JSON.stringify({
+              type: 'RoutingMessage',
+              data: {
+                type: 'AgentConsultFailed',
+                interactionId: 'intrid',
+              },
+            }),
+          })
+        );
+      }, 0);
+
+      await expect(promise).rejects.toThrow('Custom error');
+    });
+
+    it('should handle request with notifCancel', async () => {
+      httpRequestInstance.request.mockResolvedValueOnce(mockHttpRequestResolvedValue);
+
+      const conf = {
+        host: 'fake-host',
+        url: '/url',
+        method: 'POST',
+        data: {},
+        notifSuccess: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultCreated', interactionId: 'intrid'},
+          },
+        },
+        notifFail: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentConsultFailed'},
+          },
+          errId: 'Service.aqm.contact.consult',
+        },
+        notifCancel: {
+          bind: {
+            type: 'RoutingMessage',
+            data: {type: 'AgentCtqCancelled', interactionId: 'intrid'},
+          },
+        },
+      };
+
+      const promise = aqm['createPromise'](conf);
+      const eventData = {
+        type: 'RoutingMessage',
+        data: {
+          type: 'AgentCtqCancelled',
+          interactionId: 'intrid',
+        },
+      };
+      global.setTimeout(() => {
+        webSocketManagerInstance.dispatchEvent(
+          new CustomEvent('message', {
+            detail: JSON.stringify(eventData),
+          })
+        );
+      }, 0);
+
+      const result = await promise;
+      expect(result).toEqual(eventData);
+    });
+  });
+});
diff --git a/packages/calling/src/index.ts b/packages/calling/src/index.ts
index cdb92097f7e..1673dfccb6f 100644
--- a/packages/calling/src/index.ts
+++ b/packages/calling/src/index.ts
@@ -52,3 +52,4 @@ export {CallError, LineError} from './Errors';
 export {ICall, TransferType} from './CallingClient/calling/types';
 export {LOGGER} from './Logger/types';
 export {LocalMicrophoneStream} from '@webex/media-helpers';
+export {CallingClientConfig} from './CallingClient/types';
diff --git a/packages/webex/test/unit/spec/webex.js b/packages/webex/test/unit/spec/webex.js
index 96d6ad5075b..ef9849ca033 100644
--- a/packages/webex/test/unit/spec/webex.js
+++ b/packages/webex/test/unit/spec/webex.js
@@ -1,6 +1,7 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
+import 'jsdom-global/register';
 
 import {assert} from '@webex/test-helper-chai';
 import Webex from 'webex';
@@ -14,6 +15,17 @@ jest.mock('../../../../@webex/plugin-meetings', () => {
 });
 jest.mock('@webex/internal-plugin-calendar');
 
+const mockWorker = {
+  postMessage: jest.fn(),
+  onmessage: jest.fn(),
+};
+
+global.Worker = jest.fn(() => mockWorker);
+
+global.URL.createObjectURL = function (blob) {
+  return 'blob:http://localhost:3000/12345';
+};
+
 describe('webex', () => {
   describe('Webex', () => {
     describe('.version', () => {