@webex/contact-center 3.12.0-next.9 → 3.12.0-next.91

package/src/services/config/ai-docs/AGENTS.md

@@ -0,0 +1,255 @@
+# Config Service - AI Agent Guide
+
+> **Legacy/reference-only.** Canonical SDD: [`config-spec.md`](config-spec.md). Use the package [manifest](../../../../.sdd/manifest.json) and [`SPEC_INDEX.md`](../../../../ai-docs/SPEC_INDEX.md) for routing; code and tests remain the behavioral referee.
+>
+> **Purpose**: Fetch and aggregate agent configuration data from multiple API endpoints to build the AgentProfile.
+>
+> **Legacy scope:** See [Root AGENTS.md](../../../../AGENTS.md) for the orchestrator and cross-scope rules.
+
+---
+
+## Overview
+
+The Config Service is an **internal service** that builds the comprehensive AgentProfile (`Profile` type) by:
+1. Fetching user data
+2. Fetching desktop profile
+3. Fetching teams
+4. Fetching aux codes (idle/wrapup codes)
+5. Fetching organization settings
+6. Aggregating all data into a single AgentProfile
+
+The AgentProfile is the central configuration object required for an agent to operate within the contact center. It is built during the registration flow (`cc.register()`) and contains all the data an agent needs: identity, team assignments, dial plans, aux codes, login options, and feature flags. Once constructed, the AgentProfile is stored on the `ContactCenter` plugin instance as `this.agentConfig` and is used by other services (Agent, Task) throughout the session.
+
+
+---
+
+## File Structure
+
+```
+services/config/
+├── index.ts          # AgentConfigService class
+├── types.ts          # Profile, CC_EVENTS, types
+├── constants.ts      # API endpoints, defaults
+├── Util.ts           # parseAgentConfigs helper
+└── ai-docs/
+    ├── AGENTS.md     # Usage documentation
+    └── ARCHITECTURE.md # This file
+```
+
+---
+
+## Quick Usage
+
+```typescript
+// Config service is used internally during the registration flow.
+// Inside cc.ts → connectWebsocket(), after WebSocket connection is established:
+const agentId = data.agentId;
+const orgId = this.$webex.credentials.getOrgId();
+this.agentConfig = await this.services.config.getAgentConfig(orgId, agentId);
+
+// The returned AgentProfile contains all agent configuration:
+LoggerProxy.info(`Agent ID: ${this.agentConfig.agentId}`, {
+  module: 'cc',
+  method: 'connectWebsocket',
+});
+LoggerProxy.info(`Teams: ${this.agentConfig.teams}`, {
+  module: 'cc',
+  method: 'connectWebsocket',
+});
+```
+
+---
+
+## Key Capabilities
+
+- **AgentProfile Aggregation**: Combines data from 8+ API endpoints
+- **Aux Codes Fetching**: Gets all idle and wrapup codes with pagination
+- **Team Data**: Retrieves agent's team assignments
+- **Dial Plan**: Fetches number transformation rules
+- **Outdial ANI**: Retrieves outbound caller ID options (standalone, publicly exposed via `cc.ts`)
+- **Multimedia Profile**: Fetches channel capacity and blending config (standalone, not yet publicly exposed)
+- **Paginated Data Access**: `getListOfTeams` and `getListOfAuxCodes` support custom pagination independent of profile building
+
+---
+
+## AgentProfile Object (Key Fields)
+
+The AgentProfile is defined as the [`Profile`](../types.ts) type. This is not an exhaustive list — see [`types.ts`](../types.ts) for the full 50+ field definition. Key fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `agentId` | string | Unique agent identifier |
+| `agentName` | string | Display name |
+| `agentMailId` | string | Email address |
+| `teams` | [`TeamList[]`](../types.ts) | Assigned teams (runtime data from `getAllTeams()` — `Profile` type declares `Team[]` but actual objects are `TeamList` with `id`, `name`, `teamType`, `siteId`, etc.) |
+| `defaultDn` | string | Default dial number |
+| `idleCodes` | [`Entity[]`](../types.ts) | Available idle codes |
+| `wrapupCodes` | [`Entity[]`](../types.ts) | Available wrapup codes |
+| `webRtcEnabled` | boolean | WebRTC calling enabled |
+| `loginVoiceOptions` | [`LoginOption[]`](../types.ts) | Available login types |
+| `dialPlan` | [`DialPlan`](../types.ts) | Number transformation rules |
+| `isOutboundEnabledForAgent` | boolean | Outbound calling allowed |
+| `outDialEp` | string | Outbound entry point ID |
+
+---
+
+## Data Aggregation Flow
+
+The following diagram shows how `getAgentConfig` orchestrates multiple API calls and combines their results into the AgentProfile via `parseAgentConfigs()`:
+
+```
+getUserUsingCI ────────────┐
+                           │
+getOrgInfo ────────────────┤
+                           │
+getOrganizationSetting ────┤
+                           │
+getTenantData ─────────────┤
+                           │
+getURLMapping ─────────────┼──► parseAgentConfigs() ──► AgentProfile
+                           │
+getAllAuxCodes ─────────────┤
+                           │
+getDesktopProfileById ─────┤
+                           │
+getSiteInfo ───────────────┤  (computes multimediaProfileId)
+                           │
+getAllTeams ────────────────┤
+                           │
+getDialPlanData ───────────┘
+```
+
+---
+
+## API Methods (Internal)
+
+### `getAgentConfig(orgId, agentId)`
+
+Main method that aggregates all configuration data into the AgentProfile.
+
+**Returns**: `Promise<Profile>`
+
+**Flow**:
+1. Fetch user data (`getUserUsingCI`)
+2. Fetch org info (`getOrgInfo`), settings (`getOrganizationSetting`), tenant data (`getTenantData`) in parallel
+3. Fetch aux codes with pagination (`getAllAuxCodes`)
+4. Fetch desktop profile (`getDesktopProfileById`), site info (`getSiteInfo`)
+5. Fetch dial plan if enabled (`getDialPlanData`)
+6. Fetch teams (`getAllTeams`)
+7. Parse and combine all data (`parseAgentConfigs`)
+
+---
+
+## Standalone APIs (Not Part of AgentProfile Building)
+
+These methods exist in `AgentConfigService` but are **not** part of the `getAgentConfig()` aggregation flow. They can be used independently by applications.
+
+| Method | Status | Returns | Description |
+|--------|--------|---------|-------------|
+| `getOutdialAniEntries(orgId, params)` | **Publicly exposed** via `cc.getOutdialAniEntries()` | `OutdialAniEntriesResponse` | Fetch outbound ANI entries for caller ID selection. Supports pagination and search via [`OutdialAniParams`](../types.ts). |
+| `getMultimediaProfileById(orgId, multimediaProfileId)` | **Not exposed, never called** | `MultimediaProfileResponse` | Fetch channel capacities (chat, email, telephony, social) and blending config. Available but unused anywhere. |
+| `getListOfTeams(orgId, page, pageSize, filter)` | Used internally by `getAllTeams()` | `ListTeamsResponse` | Single-page team fetch with pagination metadata. Useful for custom pagination. |
+| `getListOfAuxCodes(orgId, page, pageSize, filter, attributes)` | Used internally by `getAllAuxCodes()` | `ListAuxCodesResponse` | Single-page aux code fetch with pagination metadata. Useful for custom pagination. |
+
+Additionally, the following endpoints are defined in `constants.ts` `endPointMap` but are consumed by separate service classes, not by `AgentConfigService`:
+
+| Endpoint | Used By | Description |
+|----------|---------|-------------|
+| `queueList` | [`Queue.ts`](../../Queue.ts) | Fetch contact service queues |
+| `entryPointList` | [`EntryPoint.ts`](../../EntryPoint.ts) | Fetch entry points |
+| `addressBookEntries` | [`AddressBook.ts`](../../AddressBook.ts) | Fetch address book entries |
+
+---
+
+## Key Types
+
+Types used by the config service, all defined in [`types.ts`](../types.ts):
+
+| Type | Description |
+|------|-------------|
+| `Profile` | Final aggregated agent config returned by `getAgentConfig()` |
+| `AgentResponse` | Raw response from `getUserUsingCI()` — agent metadata, teamIds, siteId, agentProfileId |
+| `DesktopProfileResponse` | Desktop profile settings — layout, dial plan, login options |
+| `TeamList` | Team record from API — `id`, `name`, `teamType`, `siteId`, `multiMediaProfileId` |
+| `ListTeamsResponse` | Paginated wrapper around `TeamList[]` with `meta` for pagination |
+| `OrgInfo` | Organization info — `tenantId`, timezone |
+| `OrgSettings` | Org feature flags — `webRtcEnabled`, `sensitiveDataMaskingEnabled` |
+| `TenantData` | Tenant-level config — inactivity timeout, `forceDefaultDn`, `outdialEnabled` |
+| `SiteInfo` | Site config — `id`, `name`, `multimediaProfileId` |
+| `URLMapping` | External URL mapping — `id`, `name`, `url` |
+| `MultimediaProfileResponse` | Multimedia profile — channel capacities and settings |
+| `AuxCode` | Auxiliary code record — `id`, `name`, `description`, `workTypeCode` |
+| `ListAuxCodesResponse` | Paginated wrapper around `AuxCode[]` with `meta` |
+| `DialPlanEntity` | Dial plan rule — regex pattern, prefix, strip digits |
+| `Entity` | Basic entity info — `isSystem`, `name`, `id`, `description` |
+| `WrapupData` | Wrap-up config — auto-wrapup settings, available wrapup codes |
+| `OutdialAniParams` | Parameters for `getOutdialAniEntries()` — ANI ID, pagination, filtering |
+| `Team` | Simplified team shape in `Profile` — `teamId`, `teamName`, `desktopLayoutId` |
+
+## Events (CC_EVENTS)
+
+The config service defines event constants used throughout the SDK:
+
+| Event Category | Examples |
+|----------------|----------|
+| Agent Events | WELCOME, AGENT_LOGOUT, AGENT_STATE_CHANGE |
+| Task Events | AGENT_CONTACT, AGENT_OFFER_CONTACT, CONTACT_ENDED |
+| Login Events | AGENT_STATION_LOGIN_SUCCESS, AGENT_STATION_LOGIN_FAILED |
+
+See [`types.ts`](../types.ts) for complete list.
+
+---
+
+## Types Defined
+
+Key types in `services/config/types.ts`:
+
+| Type | Description |
+|------|-------------|
+| `Profile` | Complete AgentProfile |
+| `CC_EVENTS` | All event constants |
+| `CC_AGENT_EVENTS` | Agent-specific events |
+| `CC_TASK_EVENTS` | Task-specific events |
+| `AuxCode` | Idle/wrapup code definition |
+| `Team` | Team configuration |
+| `DesktopProfileResponse` | Desktop profile settings |
+| `LoginOption` | Login types (BROWSER, EXTENSION, AGENT_DN) |
+
+---
+
+## Error Handling
+
+All API methods within the config service throw errors on failure. Since `getAgentConfig` calls multiple sub-APIs (`getUserUsingCI`, `getOrgInfo`, `getOrganizationSetting`, `getTenantData`, `getAllAuxCodes`, `getDesktopProfileById`, `getAllTeams`, `getDialPlanData`, etc.) and awaits them via `Promise.all`, **a failure in any single sub-API will cause the entire AgentProfile fetch to fail**. There is no partial profile — either all data is successfully fetched and aggregated, or the operation throws.
+
+```typescript
+try {
+  const profile = await this.services.config.getAgentConfig(orgId, agentId);
+} catch (error) {
+  LoggerProxy.error(`Config fetch failed: ${error}`, {
+    module: 'ConfigService',
+    method: 'getAgentConfig',
+  });
+  throw error;
+}
+```
+
+---
+
+## Usage in cc.ts
+
+```typescript
+// In register() -> connectWebsocket()
+const agentId = data.agentId;
+const orgId = this.$webex.credentials.getOrgId();
+this.agentConfig = await this.services.config.getAgentConfig(orgId, agentId);
+```
+
+---
+
+## Related
+
+- [Root AGENTS.md](../../../../AGENTS.md) - Orchestrator and cross-scope rules
+- [ARCHITECTURE.md](ARCHITECTURE.md) - Technical deep-dive
+- [types.ts](../types.ts) - Type definitions
+- [Util.ts](../Util.ts) - AgentProfile parsing utilities
+- [constants.ts](../constants.ts) - API endpoints

package/src/services/config/ai-docs/ARCHITECTURE.md

@@ -0,0 +1,426 @@
+# Config Service - Architecture
+
+> **Legacy/reference-only.** Canonical SDD: [`config-spec.md`](config-spec.md). Use the package [manifest](../../../../.sdd/manifest.json) and [`SPEC_INDEX.md`](../../../../ai-docs/SPEC_INDEX.md) for routing; code and tests remain the behavioral referee.
+
+> **Purpose**: Technical documentation for agent configuration aggregation.
+
+---
+
+## Component Overview
+
+| Component | File | Responsibility |
+|-----------|------|----------------|
+| `AgentConfigService` | `config/index.ts` | Main config service class |
+| `parseAgentConfigs` | `config/Util.ts` | Profile parsing/aggregation |
+| `endPointMap` | `config/constants.ts` | API endpoint definitions |
+| `types` | `config/types.ts` | Types, events, interfaces |
+
+---
+
+## Data Flow
+
+```mermaid
+sequenceDiagram
+    participant CC as ContactCenter
+    participant Cfg as AgentConfigService
+    participant WR as WebexRequest
+    participant API as Backend APIs
+
+    CC->>Cfg: getAgentConfig(orgId, agentId)
+
+    par Wave 1 — fire immediately
+        Cfg->>WR: getUserUsingCI
+        Cfg->>WR: getOrgInfo
+        Cfg->>WR: getOrganizationSetting
+        Cfg->>WR: getTenantData
+        Cfg->>WR: getURLMapping
+        Cfg->>WR: getAllAuxCodes
+    end
+
+    WR->>API: 6 parallel API calls
+    API-->>WR: Responses
+    Note over Cfg: await userConfigData (needed for wave 2)
+
+    par Wave 2 — depends on userConfigData
+        Cfg->>WR: getDesktopProfileById(agentProfileId)
+        Cfg->>WR: getSiteInfo(siteId)
+        Cfg->>WR: getAllTeams(teamIds)
+    end
+
+    Note over Cfg: getDialPlanData chained off agentProfile<br/>(fires only if dialPlanEnabled)
+
+    Note over Cfg: Single Promise.all() awaits all 9 promises<br/>(wave 1 + wave 2 + conditional dialPlan)
+
+    WR->>API: Remaining API calls
+    API-->>WR: Responses
+
+    Cfg->>Cfg: parseAgentConfigs(allData)
+    Cfg-->>CC: Profile
+```
+
+---
+
+## API Endpoints
+
+The config service uses multiple API endpoints to fetch agent configuration data. These endpoints are defined in `constants.ts` and include:
+
+- **Core user data**: User profile, agent settings, site information
+- **Team & organization**: Team memberships, organization settings, tenant configuration
+- **Auxiliary codes**: Idle codes and wrap-up codes with pagination
+- **Communication settings**: Dial plans, URL mappings, multimedia profiles
+- **Outbound features**: Queue lists, entry points, address books, outdial ANI entries
+
+### Endpoint Definitions
+
+All endpoints are relative to the WCC API Gateway base URL. Query parameters like `agentView=true` filter responses to agent-relevant data.
+
+**Example Usage:**
+```typescript
+// Fetch user data
+const resource = endPointMap.userByCI('org-123', 'agent-456');
+// Result: "organization/org-123/user/by-ci-user-id/agent-456"
+
+// Fetch teams with pagination and filtering
+const resource = endPointMap.listTeams('org-123', 0, 100, ['team-1', 'team-2']);
+// Result: "organization/org-123/v2/team?page=0&pageSize=100&filter=id=in=(team-1,team-2)"
+
+// Fetch organization settings
+const resource = endPointMap.orgSettings('org-123');
+// Result: "organization/org-123/v2/organization-setting?agentView=true"
+```
+
+**Full Endpoint Map:**
+```typescript
+export const endPointMap = {
+  userByCI: (orgId: string, agentId: string) =>
+    `organization/${orgId}/user/by-ci-user-id/${agentId}`,
+
+  desktopProfile: (orgId: string, desktopProfileId: string) =>
+    `organization/${orgId}/agent-profile/${desktopProfileId}`,
+
+  multimediaProfile: (orgId: string, multimediaProfileId: string) =>
+    `organization/${orgId}/multimedia-profile/${multimediaProfileId}`,
+
+  listTeams: (orgId: string, page: number, pageSize: number, filter: string[]) =>
+    `organization/${orgId}/v2/team?page=${page}&pageSize=${pageSize}${
+      filter && filter.length > 0 ? `&filter=id=in=(${filter})` : ''
+    }`,
+
+  listAuxCodes: (orgId: string, page: number, pageSize: number, filter: string[], attributes: string[]) =>
+    `organization/${orgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}${
+      filter && filter.length > 0 ? `&filter=id=in=(${filter})` : ''
+    }&attributes=${attributes}`,
+
+  orgInfo: (orgId: string) =>
+    `organization/${orgId}`,
+
+  orgSettings: (orgId: string) =>
+    `organization/${orgId}/v2/organization-setting?agentView=true`,
+
+  siteInfo: (orgId: string, siteId: string) =>
+    `organization/${orgId}/site/${siteId}`,
+
+  tenantData: (orgId: string) =>
+    `organization/${orgId}/v2/tenant-configuration?agentView=true`,
+
+  urlMapping: (orgId: string) =>
+    `organization/${orgId}/v2/org-url-mapping?sort=name,ASC`,
+
+  dialPlan: (orgId: string) =>
+    `organization/${orgId}/dial-plan?agentView=true`,
+
+  queueList: (orgId: string, queryParams: string) =>
+    `/organization/${orgId}/v2/contact-service-queue?${queryParams}`,
+
+  entryPointList: (orgId: string, queryParams: string) =>
+    `/organization/${orgId}/v2/entry-point?${queryParams}`,
+
+  addressBookEntries: (orgId: string, addressBookId: string, queryParams: string) =>
+    `/organization/${orgId}/v2/address-book/${addressBookId}/entry?${queryParams}`,
+
+  outdialAniEntries: (orgId: string, outdialANI: string, queryParams: string) =>
+    `organization/${orgId}/v2/outdial-ani/${outdialANI}/entry${
+      queryParams ? `?${queryParams}` : ''
+    }`,
+};
+```
+
+---
+
+## Pagination Pattern
+
+For endpoints with pagination (teams, aux codes):
+
+```typescript
+import {DEFAULT_PAGE} from './constants'; // DEFAULT_PAGE = 0
+
+public async getAllTeams(orgId, pageSize, filter): Promise<TeamList[]> {
+  let allTeams: TeamList[] = [];
+  let page = DEFAULT_PAGE;
+  
+  // First request to get totalPages
+  const firstResponse = await this.getListOfTeams(orgId, page, pageSize, filter);
+  allTeams = allTeams.concat(firstResponse.data);
+  const totalPages = firstResponse.meta.totalPages;
+  
+  // Parallel requests for remaining pages
+  const requests = [];
+  for (page = DEFAULT_PAGE + 1; page < totalPages; page += 1) {
+    requests.push(this.getListOfTeams(orgId, page, pageSize, filter));
+  }
+  
+  const responses = await Promise.all(requests);
+  for (const response of responses) {
+    allTeams = allTeams.concat(response.data);
+  }
+  
+  return allTeams;
+}
+```
+
+---
+
+## Profile Parsing
+
+`parseAgentConfigs` in Util.ts combines all data into a unified `Profile` object. See [types.ts](../types.ts) for full type definitions.
+
+### API Response Structures
+
+The service fetches data from multiple APIs with these response structures:
+
+| API Method | Response Type | Key Fields | Usage |
+|------------|---------------|------------|-------|
+| `getUserUsingCI` | `AgentResponse` | `ciUserId`, `id`, `firstName`, `lastName`, `email`, `teamIds`, `agentProfileId`, `siteId` | Primary agent identity and profile references |
+| `getDesktopProfileById` | `DesktopProfileResponse` | `dialPlanEnabled`, `autoAnswer`, `accessWrapUpCode`, `wrapUpCodes`, `accessIdleCode`, `idleCodes`, `loginVoiceOptions` | Agent desktop settings and feature enablement |
+| `getAllTeams` | `TeamList[]` | `id`, `name`, `type`, `channelMap` (+ 10 more fields) | Full team details with channel configurations |
+| `getTenantData` | `TenantData` | `outdialEnabled`, `forceDefaultDn`, `privacyShieldVisible`, `timeoutDesktopInactivityEnabled` | Tenant-level feature flags |
+| `getOrgInfo` | `OrgInfo` | `tenantId`, `timezone` | Organization metadata |
+| `getAllAuxCodes` | `AuxCode[]` | `id`, `name`, `workTypeCode`, `active`, `isSystemCode`, `defaultCode` | Auxiliary codes for idle/wrap-up states |
+| `getOrganizationSetting` | `OrgSettings` | `webRtcEnabled`, `maskSensitiveData`, `campaignManagerEnabled` | Organization-level feature flags |
+| `getDialPlanData` | `DialPlanEntity[]` | `id`, `name`, `regularExpression`, `prefix`, `strippedChars` | Dial plan rules for outbound calling |
+| `getURLMapping` | `URLMapping[]` | `name`, `url` | External service URL mappings |
+| `getSiteInfo` | `SiteInfo` | Site-specific configuration | Site details |
+
+These responses are parsed and aggregated into a single `Profile` object by the `parseAgentConfigs` function.
+
+### Profile Aggregation Function
+
+```typescript
+// See full implementation in Util.ts
+function parseAgentConfigs(profileData: {
+  userData: AgentResponse;        // See types.ts:AgentResponse
+  teamData: Team[];               // NOTE: Declared as Team[] (teamId, teamName) but receives TeamList[] (id, name, + 12 more fields) at runtime
+  tenantData: TenantData;         // See types.ts:TenantData
+  orgInfoData: OrgInfo;           // See types.ts:OrgInfo
+  auxCodes: AuxCode[];            // See types.ts:AuxCode
+  orgSettingsData: OrgSettings;   // See types.ts:OrgSettings
+  agentProfileData: DesktopProfileResponse;  // See types.ts:DesktopProfileResponse
+  dialPlanData: DialPlanEntity[]; // See types.ts:DialPlanEntity
+  urlMapping: URLMapping[];       // See types.ts:URLMapping
+  multimediaProfileId: string;
+}): Profile {                     // See types.ts:Profile
+  const { userData, teamData, tenantData, orgInfoData, auxCodes,
+          orgSettingsData, agentProfileData, dialPlanData, urlMapping } = profileData;
+
+  // Aux code filtering via getFilterAuxCodes():
+  //   - checks auxCode.active
+  //   - checks specificCodes access level (ALL → no filter, SPECIFIC → include list)
+  //   - maps to Entity {id, name, isSystem, isDefault}
+  const wrapupCodes = getFilterAuxCodes(auxCodes, WRAP_UP_CODE,
+    agentProfileData.accessWrapUpCode === 'ALL' ? [] : agentProfileData.wrapUpCodes);
+  const idleCodes = getFilterAuxCodes(auxCodes, IDLE_CODE,
+    agentProfileData.accessIdleCode === 'ALL' ? [] : agentProfileData.idleCodes);
+
+  // Hardcoded "Available" state always appended to idle codes
+  idleCodes.push({ id: '0', name: 'Available', isSystem: false, isDefault: false });
+
+  return {
+    agentId: userData.ciUserId,          // NOTE: uses ciUserId for agent identification
+    analyserUserId: userData.id,         // NOTE: userData.id is used for analytics/reporting
+    agentName: `${userData.firstName} ${userData.lastName}`,
+    teams: teamData,                     // NOTE: Raw TeamList[] passed directly without mapping
+    idleCodes,                           // NOTE: Filtered via getFilterAuxCodes() + hardcoded "Available" state
+    wrapupCodes,                         // NOTE: Filtered via getFilterAuxCodes()
+    webRtcEnabled: orgSettingsData.webRtcEnabled,
+    loginVoiceOptions: agentProfileData.loginVoiceOptions ?? [],
+    enterpriseId: orgInfoData.tenantId,
+    tenantTimezone: orgInfoData.timezone,
+    multimediaProfileId: profileData.multimediaProfileId,
+    // ... 30+ more fields — see Util.ts:184-258 for full implementation
+  };
+}
+```
+
+---
+
+## Error Handling
+
+Each method follows consistent error handling:
+
+```typescript
+public async getUserUsingCI(orgId: string, agentId: string): Promise<AgentResponse> {
+  LoggerProxy.info('Fetching user data using CI', {
+    module: CONFIG_FILE_NAME,
+    method: METHODS.GET_USER_USING_CI,
+  });
+
+  try {
+    const resource = endPointMap.userByCI(orgId, agentId);
+    const response = await this.webexReq.request({
+      service: WCC_API_GATEWAY,
+      resource,
+      method: HTTP_METHODS.GET,
+    });
+
+    if (response.statusCode !== 200) {
+      throw new Error(`API call failed with ${response.statusCode}`);
+    }
+
+    LoggerProxy.log('getUserUsingCI api success.', {
+      module: CONFIG_FILE_NAME,
+      method: METHODS.GET_USER_USING_CI,
+    });
+
+    return Promise.resolve(response.body);
+  } catch (error) {
+    LoggerProxy.error(`getUserUsingCI API call failed with ${error}`, {
+      module: CONFIG_FILE_NAME,
+      method: METHODS.GET_USER_USING_CI,
+    });
+    throw error;
+  }
+}
+```
+
+---
+
+## Troubleshooting
+
+### Common Issues and Log Patterns
+
+#### Issue: Profile incomplete or getAgentConfig fails
+
+**Cause**: One of the parallel API calls failed (network error, 401/403/404/500 response)
+
+**Log patterns to search for:**
+```typescript
+// General config failure
+"getAgentConfig call failed"
+"module": "config/index.ts", "method": "getAgentConfig"
+
+// Specific API method failures
+"getUserUsingCI API call failed"
+"getDesktopProfileById API call failed"
+"getAllTeams API call failed"
+"getAllAuxCodes API call failed"
+
+// Look for HTTP error codes
+"API call failed with 401"  // Authentication
+"API call failed with 403"  // Authorization
+"API call failed with 404"  // Not found
+"API call failed with 500"  // Server error
+```
+
+**Solution**:
+1. Check logs for specific API that failed
+2. Verify orgId and agentId are correct
+3. Ensure authentication tokens are valid
+4. Check network connectivity to WCC API Gateway
+
+#### Issue: Empty teams or aux codes
+
+**Cause**: Pagination not completing or filter parameters incorrect
+
+**Log patterns:**
+```typescript
+"getAllTeams API call failed"
+"getAllAuxCodes API call failed"
+"method": "getListOfTeams"
+"method": "getListOfAuxCodes"
+```
+
+**Solution**:
+1. Check `totalPages` in first response
+2. Verify filter array contains valid team/aux code IDs
+3. Check if pageSize is appropriate (default: 100)
+4. Ensure all pages are fetched in Promise.all()
+
+#### Issue: WebRTC or other features not enabled
+
+**Cause**: Organization or tenant settings have feature disabled
+
+**Log patterns:**
+```typescript
+"getOrganizationSetting api success"
+"getTenantData api success"
+```
+
+**Solution**:
+1. Check `orgSettingsData.webRtcEnabled` in response
+2. Check `tenantData.outdialEnabled` for outbound features
+3. Verify feature is enabled in admin portal settings
+4. Confirm agentProfileData has correct feature flags
+
+#### Issue: Missing dial plan data
+
+**Cause**: `dialPlanEnabled` is false in desktop profile
+
+**Solution**:
+1. Check `agentProfileData.dialPlanEnabled` value
+2. Verify dial plans are assigned in agent profile configuration
+3. Note: dial plan fetch only happens if `dialPlanEnabled === true`
+
+#### Issue: Incorrect auxiliary code filtering
+
+**Cause**: Access level set to 'SPECIFIC' but missing code IDs
+
+**Log patterns:**
+```typescript
+"method": "getFilterAuxCodes"
+```
+
+**Solution**:
+1. Check `agentProfileData.accessWrapUpCode` (should be 'ALL' or 'SPECIFIC')
+2. Check `agentProfileData.accessIdleCode`
+3. If 'SPECIFIC', verify `wrapUpCodes` and `idleCodes` arrays contain valid IDs
+4. Ensure aux codes have `active: true` status
+5. Note: "Available" state is always appended to idle codes
+
+---
+
+## Types and Events
+
+The config service defines comprehensive TypeScript types for all data structures. See [types.ts](../types.ts) for complete definitions.
+
+### Core Types
+
+**Configuration Types:**
+- `Profile` - Unified agent profile after aggregation
+- `AgentResponse` - User data from userByCI endpoint
+- `DesktopProfileResponse` - Agent desktop settings
+- `TeamList` - Team data with full details (id, name, type, channelMap, etc.)
+- `Team` - Simplified team reference (teamId, teamName, desktopLayoutId)
+- `AuxCode` - Auxiliary code definition
+- `Entity` - Filtered code entity (used for idle/wrapup codes in Profile)
+
+**Organization Types:**
+- `OrgInfo` - Organization metadata
+- `OrgSettings` - Organization-level feature flags
+- `TenantData` - Tenant configuration and feature enablement
+- `SiteInfo` - Site-specific configuration
+
+**Communication Types:**
+- `DialPlanEntity` - Dial plan rule definition
+- `URLMapping` - External service URL mapping
+- `MultimediaProfile` - Multimedia profile configuration
+
+**Note:** The config service itself does not emit events. For agent and task events, see the Agent and Task services. Event constants are defined in [types.ts](../types.ts) under `CC_AGENT_EVENTS` and `CC_TASK_EVENTS`.
+
+---
+
+## Related Files
+
+- [index.ts](../index.ts) - Service implementation with all API methods
+- [types.ts](../types.ts) - Complete type definitions and event constants
+- [Util.ts](../Util.ts) - Profile parsing utilities (parseAgentConfigs, getFilterAuxCodes, etc.)
+- [constants.ts](../constants.ts) - API endpoints, default values, and method names