@uipath/uipath-typescript 1.0.0 → 1.1.1

package/dist/index.cjs

@@ -3886,6 +3886,15 @@ class ExecutionContext {
  */
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 
+/**
+ * Session storage keys used by the auth module
+ */
+const AUTH_STORAGE_KEYS = {
+    TOKEN_PREFIX: 'uipath_sdk_user_token-',
+    OAUTH_CONTEXT: 'uipath_sdk_oauth_context',
+    CODE_VERIFIER: 'uipath_sdk_code_verifier',
+};
+
 // Type guard to check if config has OAuth credentials
 function hasOAuthConfig(config) {
     return Boolean(config.clientId && config.redirectUri && config.scope);
@@ -3895,6 +3904,303 @@ function hasSecretConfig(config) {
     return Boolean(config.secret);
 }
 
+/**
+ * Base error class for all UiPath SDK errors
+ * Extends Error for standard error handling compatibility
+ */
+class UiPathError extends Error {
+    constructor(type, params) {
+        super(params.message);
+        this.name = type;
+        this.type = type;
+        this.statusCode = params.statusCode;
+        this.requestId = params.requestId;
+        this.timestamp = new Date();
+        // Maintains proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Returns a clean JSON representation of the error
+     */
+    toJSON() {
+        return {
+            type: this.type,
+            message: this.message,
+            statusCode: this.statusCode,
+            requestId: this.requestId,
+            timestamp: this.timestamp
+        };
+    }
+    /**
+     * Returns detailed debug information including stack trace
+     */
+    getDebugInfo() {
+        return {
+            ...this.toJSON(),
+            stack: this.stack
+        };
+    }
+}
+
+/**
+ * HTTP status code constants for error handling
+ */
+const HttpStatus = {
+    // Client errors (4xx)
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    TOO_MANY_REQUESTS: 429,
+    // Server errors (5xx)
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504
+};
+/**
+ * Error type constants for consistent error identification
+ */
+const ErrorType = {
+    AUTHENTICATION: 'AuthenticationError',
+    AUTHORIZATION: 'AuthorizationError',
+    VALIDATION: 'ValidationError',
+    NOT_FOUND: 'NotFoundError',
+    RATE_LIMIT: 'RateLimitError',
+    SERVER: 'ServerError',
+    NETWORK: 'NetworkError'
+};
+/**
+ * HTTP header constants for error handling
+ */
+const HttpHeaders = {
+    X_REQUEST_ID: 'x-request-id'
+};
+/**
+ * Standard error message constants
+ */
+const ErrorMessages = {
+    // Authentication errors
+    AUTHENTICATION_FAILED: 'Authentication failed',
+    // Authorization errors  
+    ACCESS_DENIED: 'Access denied',
+    // Validation errors
+    VALIDATION_FAILED: 'Validation failed',
+    // Not found errors
+    RESOURCE_NOT_FOUND: 'Resource not found',
+    // Rate limit errors
+    RATE_LIMIT_EXCEEDED: 'Rate limit exceeded',
+    // Server errors
+    INTERNAL_SERVER_ERROR: 'Internal Server error occurred',
+    // Network errors
+    NETWORK_ERROR: 'Network error occurred',
+    REQUEST_TIMEOUT: 'Request timed out',
+    REQUEST_ABORTED: 'Request was aborted',
+};
+/**
+ * Error name constants for network error identification
+ */
+const ErrorNames = {
+    ABORT_ERROR: 'AbortError'};
+
+/**
+ * Error thrown when authentication fails (401 errors)
+ * Common scenarios:
+ * - Invalid credentials
+ * - Expired token
+ * - Missing authentication
+ */
+class AuthenticationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHENTICATION, {
+            message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when authorization fails (403 errors)
+ * Common scenarios:
+ * - Insufficient permissions
+ * - Access denied to resource
+ * - Invalid scope
+ */
+class AuthorizationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHORIZATION, {
+            message: params.message || ErrorMessages.ACCESS_DENIED,
+            statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when validation fails (400 errors or client-side validation)
+ * Common scenarios:
+ * - Invalid input parameters
+ * - Missing required fields
+ * - Invalid data format
+ */
+class ValidationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.VALIDATION, {
+            message: params.message || ErrorMessages.VALIDATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when a resource is not found (404 errors)
+ * Common scenarios:
+ * - Resource doesn't exist
+ * - Invalid ID provided
+ * - Resource deleted
+ */
+class NotFoundError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NOT_FOUND, {
+            message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
+            statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when rate limit is exceeded (429 errors)
+ * Common scenarios:
+ * - Too many requests in a time window
+ * - API throttling
+ */
+class RateLimitError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.RATE_LIMIT, {
+            message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
+            statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when server encounters an error (5xx errors)
+ * Common scenarios:
+ * - Internal server error
+ * - Service unavailable
+ * - Gateway timeout
+ */
+class ServerError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.SERVER, {
+            message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
+            statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
+            requestId: params.requestId
+        });
+    }
+    /**
+     * Checks if this is a temporary error that might succeed on retry
+     */
+    get isRetryable() {
+        return this.statusCode === HttpStatus.BAD_GATEWAY ||
+            this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
+            this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
+    }
+}
+
+/**
+ * Error thrown when network/connection issues occur
+ * Common scenarios:
+ * - Connection timeout
+ * - DNS resolution failure
+ * - Network unreachable
+ * - Request aborted
+ */
+class NetworkError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NETWORK, {
+            message: params.message || ErrorMessages.NETWORK_ERROR,
+            statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Type guard to check if an error is a UiPathError
+ */
+function isUiPathError(error) {
+    return error instanceof UiPathError;
+}
+/**
+ * Type guard to check if an error is an AuthenticationError
+ */
+function isAuthenticationError(error) {
+    return error instanceof AuthenticationError;
+}
+/**
+ * Type guard to check if an error is an AuthorizationError
+ */
+function isAuthorizationError(error) {
+    return error instanceof AuthorizationError;
+}
+/**
+ * Type guard to check if an error is a ValidationError
+ */
+function isValidationError(error) {
+    return error instanceof ValidationError;
+}
+/**
+ * Type guard to check if an error is a NotFoundError
+ */
+function isNotFoundError(error) {
+    return error instanceof NotFoundError;
+}
+/**
+ * Type guard to check if an error is a RateLimitError
+ */
+function isRateLimitError(error) {
+    return error instanceof RateLimitError;
+}
+/**
+ * Type guard to check if an error is a ServerError
+ */
+function isServerError(error) {
+    return error instanceof ServerError;
+}
+/**
+ * Type guard to check if an error is a NetworkError
+ */
+function isNetworkError(error) {
+    return error instanceof NetworkError;
+}
+/**
+ * Helper to get error details in a safe way
+ */
+function getErrorDetails(error) {
+    if (isUiPathError(error)) {
+        return {
+            message: error.message,
+            statusCode: error.statusCode
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            message: error.message
+        };
+    }
+    return {
+        message: String(error)
+    };
+}
+
 /**
  * TokenManager is responsible for managing authentication tokens.
  * It provides token operations for a specific client ID.
@@ -3912,7 +4218,6 @@ class TokenManager {
         this.executionContext = executionContext;
         this.config = config;
         this.isOAuth = isOAuth;
-        this.STORAGE_KEY_PREFIX = 'uipath_sdk_user_token-';
         this.refreshPromise = null;
     }
     /**
@@ -3927,11 +4232,46 @@ class TokenManager {
         }
         return new Date() >= tokenInfo.expiresAt;
     }
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * This is the single source of truth for token validation and refresh logic.
+     *
+     * @returns The valid token string
+     * @throws AuthenticationError if no token available or refresh fails
+     */
+    async getValidToken() {
+        const tokenInfo = this.executionContext.get('tokenInfo');
+        if (!tokenInfo) {
+            throw new AuthenticationError({
+                message: 'No authentication token available. Make sure to initialize the SDK first.'
+            });
+        }
+        // For secret-based tokens, they never expire
+        if (tokenInfo.type === 'secret') {
+            return tokenInfo.token;
+        }
+        // If token is not expired, return it
+        if (!this.isTokenExpired(tokenInfo)) {
+            return tokenInfo.token;
+        }
+        // Token is expired, refresh it
+        try {
+            const newToken = await this.refreshAccessToken();
+            return newToken.access_token;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new AuthenticationError({
+                message: `Token refresh failed: ${message}. Please re-authenticate.`,
+                statusCode: HttpStatus.UNAUTHORIZED
+            });
+        }
+    }
     /**
      * Gets the storage key for this TokenManager instance
      */
     _getStorageKey() {
-        return `${this.STORAGE_KEY_PREFIX}${this.config.clientId}`;
+        return `${AUTH_STORAGE_KEYS.TOKEN_PREFIX}${this.config.clientId}`;
     }
     /**
      * Loads token from session storage if available
@@ -4141,10 +4481,6 @@ class TokenManager {
     }
 }
 
-/**
- * API Endpoint Constants
- * Centralized location for all API endpoints used throughout the SDK
- */
 /**
  * Base path constants for different services
  */
@@ -4152,6 +4488,66 @@ const ORCHESTRATOR_BASE = 'orchestrator_';
 const PIMS_BASE = 'pims_';
 const DATAFABRIC_BASE = 'datafabric_';
 const IDENTITY_BASE = 'identity_';
+
+/**
+ * Orchestrator Service Endpoints
+ */
+/**
+ * Task Service (Action Center) Endpoints
+ */
+const TASK_ENDPOINTS = {
+    CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
+    GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
+    GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
+    GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
+    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
+    ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
+    REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
+    UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
+    COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
+    COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
+    COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
+    GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
+};
+/**
+ * Orchestrator Bucket Endpoints
+ */
+const BUCKET_ENDPOINTS = {
+    GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Buckets`,
+    GET_ALL: `${ORCHESTRATOR_BASE}/odata/Buckets/UiPath.Server.Configuration.OData.GetBucketsAcrossFolders`,
+    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})`,
+    GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
+    GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
+    GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
+};
+/**
+ * Orchestrator Process Service Endpoints
+ */
+const PROCESS_ENDPOINTS = {
+    GET_ALL: `${ORCHESTRATOR_BASE}/odata/Releases`,
+    START_PROCESS: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs`,
+    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Releases(${id})`,
+};
+/**
+ * Orchestrator Queue Service Endpoints
+ */
+const QUEUE_ENDPOINTS = {
+    GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions`,
+    GET_ALL: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions/UiPath.Server.Configuration.OData.GetQueuesAcrossFolders`,
+    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`,
+};
+/**
+ * Orchestrator Asset Service Endpoints
+ */
+const ASSET_ENDPOINTS = {
+    GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered`,
+    GET_ALL: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetAssetsAcrossFolders`,
+    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Assets(${id})`,
+};
+
+/**
+ * Maestro Service Endpoints
+ */
 /**
  * Maestro Process Service Endpoints
  */
@@ -4181,25 +4577,12 @@ const MAESTRO_ENDPOINTS = {
         REOPEN: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/reopen`,
     },
 };
+
 /**
- * Task Service (Action Center) Endpoints
+ * Data Fabric Service Endpoints
  */
-const TASK_ENDPOINTS = {
-    CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CreateTask`,
-    GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
-    GET_TASKS_ACROSS_FOLDERS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFolders`,
-    GET_TASKS_ACROSS_FOLDERS_ADMIN: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.GetTasksAcrossFoldersForAdmin`,
-    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Tasks(${id})`,
-    ASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.AssignTasks`,
-    REASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.ReassignTasks`,
-    UNASSIGN_TASKS: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.UnassignTasks`,
-    COMPLETE_FORM_TASK: `${ORCHESTRATOR_BASE}/forms/TaskForms/CompleteTask`,
-    COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
-    COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
-    GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
-};
 /**
- * Data Fabric Service Endpoints
+ * Data Fabric Entity Service Endpoints
  */
 const DATA_FABRIC_ENDPOINTS = {
     ENTITY: {
@@ -4210,55 +4593,24 @@ const DATA_FABRIC_ENDPOINTS = {
         INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert`,
         BATCH_INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert-batch`,
         UPDATE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update-batch`,
-        DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
-        DOWNLOAD_ATTACHMENT: (entityName, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/${entityName}/${recordId}/${fieldName}`,
-    },
-    CHOICESETS: {
-        GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
-        GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
-    },
-};
-/**
- * Orchestrator Bucket Endpoints
- */
-const BUCKET_ENDPOINTS = {
-    GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Buckets`,
-    GET_ALL: `${ORCHESTRATOR_BASE}/odata/Buckets/UiPath.Server.Configuration.OData.GetBucketsAcrossFolders`,
-    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})`,
-    GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
-    GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
-    GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
-};
-/**
- * Identity/Authentication Endpoints
- */
-const IDENTITY_ENDPOINTS = {
-    TOKEN: `${IDENTITY_BASE}/connect/token`,
-    AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`,
-};
-/**
- * Orchestrator Process Service Endpoints
- */
-const PROCESS_ENDPOINTS = {
-    GET_ALL: `${ORCHESTRATOR_BASE}/odata/Releases`,
-    START_PROCESS: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs`,
-    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Releases(${id})`,
+        DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
+        DOWNLOAD_ATTACHMENT: (entityName, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/${entityName}/${recordId}/${fieldName}`,
+    },
+    CHOICESETS: {
+        GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
+        GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
+    },
 };
+
 /**
- * Orchestrator Queue Service Endpoints
+ * Identity/Authentication Endpoints
  */
-const QUEUE_ENDPOINTS = {
-    GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions`,
-    GET_ALL: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions/UiPath.Server.Configuration.OData.GetQueuesAcrossFolders`,
-    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`,
-};
 /**
- * Orchestrator Asset Service Endpoints
+ * Identity Service Endpoints
  */
-const ASSET_ENDPOINTS = {
-    GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered`,
-    GET_ALL: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetAssetsAcrossFolders`,
-    GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Assets(${id})`,
+const IDENTITY_ENDPOINTS = {
+    TOKEN: `${IDENTITY_BASE}/connect/token`,
+    AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`,
 };
 
 class AuthService {
@@ -4281,7 +4633,7 @@ class AuthService {
             return false;
         const urlParams = new URLSearchParams(window.location.search);
         const code = urlParams.get('code');
-        const hasCodeVerifier = sessionStorage.getItem('uipath_sdk_code_verifier');
+        const hasCodeVerifier = sessionStorage.getItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
         return !!(code && hasCodeVerifier);
     }
     /**
@@ -4292,7 +4644,7 @@ class AuthService {
             return null;
         }
         try {
-            const stored = sessionStorage.getItem('uipath_sdk_oauth_context');
+            const stored = sessionStorage.getItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
             if (!stored) {
                 return null;
             }
@@ -4300,13 +4652,13 @@ class AuthService {
             // Validate required fields
             if (!context.codeVerifier || !context.clientId || !context.redirectUri ||
                 !context.baseUrl || !context.orgName) {
-                sessionStorage.removeItem('uipath_sdk_oauth_context');
+                sessionStorage.removeItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
                 return null;
             }
             return context;
         }
         catch (error) {
-            sessionStorage.removeItem('uipath_sdk_oauth_context');
+            sessionStorage.removeItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
             console.warn('Failed to parse stored OAuth context from session storage', error);
             return null;
         }
@@ -4381,7 +4733,7 @@ class AuthService {
             throw new Error('OAuth flow is only supported in browser environments');
         }
         // Check if we have a stored code verifier indicating we're in an OAuth flow
-        const codeVerifier = sessionStorage.getItem('uipath_sdk_code_verifier');
+        const codeVerifier = sessionStorage.getItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
         const isInOAuthFlow = codeVerifier !== null;
         const urlParams = new URLSearchParams(window.location.search);
         const code = urlParams.get('code');
@@ -4390,7 +4742,7 @@ class AuthService {
             // We're expecting a callback - validate parameters
             if (!code) {
                 // Clear stored state on error
-                sessionStorage.removeItem('uipath_sdk_code_verifier');
+                sessionStorage.removeItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
                 throw new Error('Authorization code missing in OAuth callback');
             }
             // Validate the authorization code format before using it
@@ -4398,7 +4750,7 @@ class AuthService {
             const codePattern = /^[A-Za-z0-9\-._~+/]+=*$/;
             if (!codePattern.test(code)) {
                 // Clear stored state on error
-                sessionStorage.removeItem('uipath_sdk_code_verifier');
+                sessionStorage.removeItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
                 throw new Error('Invalid authorization code format');
             }
             // Authorization code is present and validated, so we can exchange it for a token.
@@ -4439,6 +4791,24 @@ class AuthService {
     hasValidToken() {
         return this.tokenManager.hasValidToken();
     }
+    /**
+     * Clears all authentication state including tokens and stored OAuth context.
+     */
+    logout() {
+        this.tokenManager.clearToken();
+        // Clear OAuth context from session storage. These are normally cleaned up in _handleOAuthCallback after a successful
+        // token exchange, but if a user calls logout() while an OAuth flow is
+        // mid-redirect (before callback completes), they'd be left behind.
+        if (isBrowser) {
+            try {
+                sessionStorage.removeItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
+                sessionStorage.removeItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
+            }
+            catch (error) {
+                console.warn('Failed to clear OAuth context from session storage', error);
+            }
+        }
+    }
     /**
      * Get the current token
      */
@@ -4570,8 +4940,8 @@ class AuthService {
             tenantName: this.config.tenantName,
             scope
         };
-        sessionStorage.setItem('uipath_sdk_oauth_context', JSON.stringify(oauthContext));
-        sessionStorage.setItem('uipath_sdk_code_verifier', codeVerifier);
+        sessionStorage.setItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT, JSON.stringify(oauthContext));
+        sessionStorage.setItem(AUTH_STORAGE_KEYS.CODE_VERIFIER, codeVerifier);
         const authUrl = this.getAuthorizationUrl({
             clientId,
             redirectUri,
@@ -4581,7 +4951,7 @@ class AuthService {
         window.location.href = authUrl;
     }
     async _handleOAuthCallback(code, clientId, redirectUri) {
-        const codeVerifier = sessionStorage.getItem('uipath_sdk_code_verifier');
+        const codeVerifier = sessionStorage.getItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
         if (!codeVerifier) {
             throw new Error('Code verifier not found in session storage. Authentication may have been interrupted.');
         }
@@ -4592,8 +4962,8 @@ class AuthService {
             codeVerifier
         });
         // Clear OAuth context and code verifier after successful token exchange
-        sessionStorage.removeItem('uipath_sdk_oauth_context');
-        sessionStorage.removeItem('uipath_sdk_code_verifier');
+        sessionStorage.removeItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
+        sessionStorage.removeItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
         const url = new URL(window.location.href);
         url.searchParams.delete('code');
         url.searchParams.delete('state');
@@ -4619,7 +4989,7 @@ function normalizeBaseUrl(url) {
 // Connection string placeholder that will be replaced during build
 const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
 // SDK Version placeholder 
-const SDK_VERSION = "1.0.0";
+const SDK_VERSION = "1.1.1";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -4796,7 +5166,6 @@ class TelemetryClient {
      */
     getEnrichedAttributes(extraAttributes, eventName) {
         const attributes = {
-            ...extraAttributes,
             [APP_NAME]: SDK_SERVICE_NAME,
             [VERSION]: SDK_VERSION,
             [SERVICE]: eventName,
@@ -4805,6 +5174,7 @@ class TelemetryClient {
             [CLOUD_TENANT_NAME]: this.telemetryContext?.tenantName || UNKNOWN$1,
             [CLOUD_REDIRECT_URI]: this.telemetryContext?.redirectUri || UNKNOWN$1,
             [CLOUD_CLIENT_ID]: this.telemetryContext?.clientId || UNKNOWN$1,
+            ...extraAttributes,
         };
         return attributes;
     }
@@ -5077,329 +5447,47 @@ let UiPath$1 = class UiPath {
      */
     async completeOAuth() {
         if (!AuthService.isInOAuthCallback()) {
-            throw new Error('Not in OAuth callback state. Call initialize() first to start OAuth flow.');
-        }
-        try {
-            const success = await __classPrivateFieldGet(this, _UiPath_authService, "f").authenticate(__classPrivateFieldGet(this, _UiPath_config, "f"));
-            if (success && this.isAuthenticated()) {
-                __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
-            throw new Error(`Failed to complete OAuth: ${errorMessage}`);
-        }
-    }
-    /**
-     * Check if the user is authenticated (has valid token)
-     */
-    isAuthenticated() {
-        return __classPrivateFieldGet(this, _UiPath_authService, "f").hasValidToken();
-    }
-    /**
-     * Get the current authentication token
-     */
-    getToken() {
-        return __classPrivateFieldGet(this, _UiPath_authService, "f").getToken();
-    }
-};
-_UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap();
-
-/**
- * Base error class for all UiPath SDK errors
- * Pure TypeScript class with clean interface
- */
-class UiPathError {
-    constructor(type, params) {
-        this.type = type;
-        this.message = params.message;
-        this.statusCode = params.statusCode;
-        this.requestId = params.requestId;
-        this.timestamp = new Date();
-        // Capture stack trace for debugging
-        this.stack = (new Error()).stack;
-    }
-    /**
-     * Returns a clean JSON representation of the error
-     */
-    toJSON() {
-        return {
-            type: this.type,
-            message: this.message,
-            statusCode: this.statusCode,
-            requestId: this.requestId,
-            timestamp: this.timestamp
-        };
-    }
-    /**
-     * Returns detailed debug information including stack trace
-     */
-    getDebugInfo() {
-        return {
-            ...this.toJSON(),
-            stack: this.stack
-        };
-    }
-}
-
-/**
- * HTTP status code constants for error handling
- */
-const HttpStatus = {
-    // Client errors (4xx)
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    FORBIDDEN: 403,
-    NOT_FOUND: 404,
-    TOO_MANY_REQUESTS: 429,
-    // Server errors (5xx)
-    INTERNAL_SERVER_ERROR: 500,
-    NOT_IMPLEMENTED: 501,
-    BAD_GATEWAY: 502,
-    SERVICE_UNAVAILABLE: 503,
-    GATEWAY_TIMEOUT: 504
-};
-/**
- * Error type constants for consistent error identification
- */
-const ErrorType = {
-    AUTHENTICATION: 'AuthenticationError',
-    AUTHORIZATION: 'AuthorizationError',
-    VALIDATION: 'ValidationError',
-    NOT_FOUND: 'NotFoundError',
-    RATE_LIMIT: 'RateLimitError',
-    SERVER: 'ServerError',
-    NETWORK: 'NetworkError'
-};
-/**
- * HTTP header constants for error handling
- */
-const HttpHeaders = {
-    X_REQUEST_ID: 'x-request-id'
-};
-/**
- * Standard error message constants
- */
-const ErrorMessages = {
-    // Authentication errors
-    AUTHENTICATION_FAILED: 'Authentication failed',
-    // Authorization errors  
-    ACCESS_DENIED: 'Access denied',
-    // Validation errors
-    VALIDATION_FAILED: 'Validation failed',
-    // Not found errors
-    RESOURCE_NOT_FOUND: 'Resource not found',
-    // Rate limit errors
-    RATE_LIMIT_EXCEEDED: 'Rate limit exceeded',
-    // Server errors
-    INTERNAL_SERVER_ERROR: 'Internal Server error occurred',
-    // Network errors
-    NETWORK_ERROR: 'Network error occurred',
-    REQUEST_TIMEOUT: 'Request timed out',
-    REQUEST_ABORTED: 'Request was aborted',
-};
-/**
- * Error name constants for network error identification
- */
-const ErrorNames = {
-    ABORT_ERROR: 'AbortError'};
-
-/**
- * Error thrown when authentication fails (401 errors)
- * Common scenarios:
- * - Invalid credentials
- * - Expired token
- * - Missing authentication
- */
-class AuthenticationError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.AUTHENTICATION, {
-            message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
-            statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when authorization fails (403 errors)
- * Common scenarios:
- * - Insufficient permissions
- * - Access denied to resource
- * - Invalid scope
- */
-class AuthorizationError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.AUTHORIZATION, {
-            message: params.message || ErrorMessages.ACCESS_DENIED,
-            statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when validation fails (400 errors or client-side validation)
- * Common scenarios:
- * - Invalid input parameters
- * - Missing required fields
- * - Invalid data format
- */
-class ValidationError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.VALIDATION, {
-            message: params.message || ErrorMessages.VALIDATION_FAILED,
-            statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when a resource is not found (404 errors)
- * Common scenarios:
- * - Resource doesn't exist
- * - Invalid ID provided
- * - Resource deleted
- */
-class NotFoundError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.NOT_FOUND, {
-            message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
-            statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when rate limit is exceeded (429 errors)
- * Common scenarios:
- * - Too many requests in a time window
- * - API throttling
- */
-class RateLimitError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.RATE_LIMIT, {
-            message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
-            statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when server encounters an error (5xx errors)
- * Common scenarios:
- * - Internal server error
- * - Service unavailable
- * - Gateway timeout
- */
-class ServerError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.SERVER, {
-            message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
-            statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
-            requestId: params.requestId
-        });
+            throw new Error('Not in OAuth callback state. Call initialize() first to start OAuth flow.');
+        }
+        try {
+            const success = await __classPrivateFieldGet(this, _UiPath_authService, "f").authenticate(__classPrivateFieldGet(this, _UiPath_config, "f"));
+            if (success && this.isAuthenticated()) {
+                __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+            throw new Error(`Failed to complete OAuth: ${errorMessage}`);
+        }
     }
     /**
-     * Checks if this is a temporary error that might succeed on retry
+     * Check if the user is authenticated (has valid token)
      */
-    get isRetryable() {
-        return this.statusCode === HttpStatus.BAD_GATEWAY ||
-            this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
-            this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
-    }
-}
-
-/**
- * Error thrown when network/connection issues occur
- * Common scenarios:
- * - Connection timeout
- * - DNS resolution failure
- * - Network unreachable
- * - Request aborted
- */
-class NetworkError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.NETWORK, {
-            message: params.message || ErrorMessages.NETWORK_ERROR,
-            statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
-            requestId: params.requestId
-        });
+    isAuthenticated() {
+        return __classPrivateFieldGet(this, _UiPath_authService, "f").hasValidToken();
     }
-}
-
-/**
- * Type guard to check if an error is a UiPathError
- */
-function isUiPathError(error) {
-    return error instanceof UiPathError;
-}
-/**
- * Type guard to check if an error is an AuthenticationError
- */
-function isAuthenticationError(error) {
-    return error instanceof AuthenticationError;
-}
-/**
- * Type guard to check if an error is an AuthorizationError
- */
-function isAuthorizationError(error) {
-    return error instanceof AuthorizationError;
-}
-/**
- * Type guard to check if an error is a ValidationError
- */
-function isValidationError(error) {
-    return error instanceof ValidationError;
-}
-/**
- * Type guard to check if an error is a NotFoundError
- */
-function isNotFoundError(error) {
-    return error instanceof NotFoundError;
-}
-/**
- * Type guard to check if an error is a RateLimitError
- */
-function isRateLimitError(error) {
-    return error instanceof RateLimitError;
-}
-/**
- * Type guard to check if an error is a ServerError
- */
-function isServerError(error) {
-    return error instanceof ServerError;
-}
-/**
- * Type guard to check if an error is a NetworkError
- */
-function isNetworkError(error) {
-    return error instanceof NetworkError;
-}
-/**
- * Helper to get error details in a safe way
- */
-function getErrorDetails(error) {
-    if (isUiPathError(error)) {
-        return {
-            message: error.message,
-            statusCode: error.statusCode
-        };
+    /**
+     * Get the current authentication token
+     */
+    getToken() {
+        return __classPrivateFieldGet(this, _UiPath_authService, "f").getToken();
     }
-    if (error instanceof Error) {
-        return {
-            message: error.message
-        };
+    /**
+     * Logout from the SDK, clearing all authentication state.
+     * After calling this method, the user will need to re-initialize to authenticate again.
+     */
+    logout() {
+        // Secret-based auth has no session to end — skip silently
+        if (hasSecretConfig(__classPrivateFieldGet(this, _UiPath_config, "f"))) {
+            return;
+        }
+        __classPrivateFieldGet(this, _UiPath_authService, "f").logout();
+        __classPrivateFieldSet(this, _UiPath_initialized, false, "f");
     }
-    return {
-        message: String(error)
-    };
-}
+};
+_UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap();
 
 /**
  * Type guards for error response types
@@ -5673,29 +5761,7 @@ class ApiClient {
      * @throws AuthenticationError if no token available or refresh fails
      */
     async getValidToken() {
-        // Try to get token info from context
-        const tokenInfo = this.executionContext.get('tokenInfo');
-        if (!tokenInfo) {
-            throw new AuthenticationError({ message: 'No authentication token available. Make sure to initialize the SDK first.' });
-        }
-        // For secret-based tokens, they never expire
-        if (tokenInfo.type === 'secret') {
-            return tokenInfo.token;
-        }
-        // If token is not expired, return it
-        if (!this.tokenManager.isTokenExpired(tokenInfo)) {
-            return tokenInfo.token;
-        }
-        try {
-            const newToken = await this.tokenManager.refreshAccessToken();
-            return newToken.access_token;
-        }
-        catch (error) {
-            throw new AuthenticationError({
-                message: `Token refresh failed: ${error.message}. Please re-authenticate.`,
-                statusCode: HttpStatus.UNAUTHORIZED
-            });
-        }
+        return this.tokenManager.getValidToken();
     }
     async getDefaultHeaders() {
         // Get headers from execution context first
@@ -6380,6 +6446,51 @@ function reverseMap(map) {
         return acc;
     }, {});
 }
+/**
+ * Transforms request data from SDK field names to API field names.
+ *
+ * This is the inverse of `transformData` - while `transformData` converts
+ * API responses to SDK format (API → SDK), this function converts SDK
+ * requests to API format (SDK → API).
+ *
+ * @param data The request data with SDK field names
+ * @param responseMap The response mapping (API → SDK) - will be automatically reversed
+ * @returns A new object with API field names
+ *
+ * @example
+ * ```typescript
+ * // Response map: API field → SDK field
+ * const ProcessMap = { releaseKey: 'processKey', releaseName: 'processName' };
+ *
+ * // SDK request with SDK field names
+ * const sdkRequest = { processKey: 'abc-123', processName: 'MyProcess' };
+ *
+ * // Transform to API format
+ * const apiRequest = transformRequest(sdkRequest, ProcessMap);
+ * // Result: { releaseKey: 'abc-123', releaseName: 'MyProcess' }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Conversation example
+ * const ConversationMap = { agentReleaseId: 'agentId' };
+ *
+ * const sdkOptions = { agentId: 123, folderId: 456, label: 'My Chat' };
+ * const apiPayload = transformRequest(sdkOptions, ConversationMap);
+ * // Result: { agentReleaseId: 123, folderId: 456, label: 'My Chat' }
+ * ```
+ */
+function transformRequest(data, responseMap) {
+    const result = { ...data };
+    const requestMap = reverseMap(responseMap);
+    for (const [sdkField, apiField] of Object.entries(requestMap)) {
+        if (sdkField in result) {
+            result[apiField] = result[sdkField];
+            delete result[sdkField];
+        }
+    }
+    return result;
+}
 /**
  * Transforms an array-based dictionary with separate keys and values arrays
  * into a standard JavaScript object/record
@@ -6637,10 +6748,7 @@ class PaginationHelpers {
      */
     static async getAll(config, options) {
         const optionsWithDefaults = options || {};
-        const { folderId, ...restOptions } = optionsWithDefaults;
-        const cursor = options?.cursor;
-        const pageSize = options?.pageSize;
-        const jumpToPage = options?.jumpToPage;
+        const { folderId, pageSize, cursor, jumpToPage, ...restOptions } = optionsWithDefaults;
         // Determine if pagination is requested
         const isPaginationRequested = PaginationHelpers.hasPaginationParameters(options || {});
         // Process parameters (custom processing if provided, otherwise default)
@@ -10343,17 +10451,8 @@ class ProcessService extends BaseService {
      */
     async start(request, folderId, options = {}) {
         const headers = createHeaders({ [FOLDER_ID]: folderId });
-        // Transform processKey/processName to releaseKey/releaseName for API compatibility
-        const apiRequest = { ...request };
-        // Create a reverse mapping using ProcessMap
-        const reversedPropertiesMap = reverseMap(ProcessMap);
-        // Apply transformations for any client properties found in the request
-        Object.entries(reversedPropertiesMap).forEach(([clientKey, apiKey]) => {
-            if (clientKey in apiRequest) {
-                apiRequest[apiKey] = apiRequest[clientKey];
-                delete apiRequest[clientKey];
-            }
-        });
+        // Transform SDK field names to API field names (e.g., processKey → releaseKey)
+        const apiRequest = transformRequest(request, ProcessMap);
         // Create the request object according to API spec
         const requestBody = {
             startInfo: apiRequest
@@ -10761,7 +10860,266 @@ exports.JobState = void 0;
     JobState["Resumed"] = "Resumed";
 })(exports.JobState || (exports.JobState = {}));
 
+/**
+ * Common Constants for Conversational Agent
+ */
+/**
+ * Common field mappings shared across all conversational agent entities.
+ * Maps API response fields to SDK-consistent naming conventions.
+ */
+const CommonFieldMap = {
+    createdAt: 'createdTime',
+    updatedAt: 'updatedTime'
+};
+
+/**
+ * Constants for Conversational Agent
+ */
+/**
+ * Maps API response fields to SDK field names (API → SDK)
+ * Used when transforming API responses for SDK consumers.
+ * For request transformation (SDK → API), use `transformRequest(data, ConversationMap)`.
+ */
+const ConversationMap = {
+    ...CommonFieldMap,
+    conversationId: 'id',
+    lastActivityAt: 'lastActivityTime',
+    agentReleaseId: 'agentId'
+};
+/**
+ * Maps fields for Exchange entity to ensure consistent SDK naming
+ */
+const ExchangeMap = {
+    ...CommonFieldMap
+};
+/**
+ * Maps fields for Message entity to ensure consistent SDK naming
+ */
+const MessageMap = {
+    ...CommonFieldMap
+};
+
+/**
+ * Common types for Conversational Agent
+ * Contains IDs, primitives, and utility types used across conversation types.
+ */
+/**
+ * Identifies the origin of a message in the conversation.
+ */
+exports.MessageRole = void 0;
+(function (MessageRole) {
+    MessageRole["System"] = "system";
+    MessageRole["User"] = "user";
+    MessageRole["Assistant"] = "assistant";
+})(exports.MessageRole || (exports.MessageRole = {}));
+/**
+ * Identifies the type of an interrupt.
+ */
+exports.InterruptType = void 0;
+(function (InterruptType) {
+    InterruptType["ToolCallConfirmation"] = "uipath_cas_tool_call_confirmation";
+})(exports.InterruptType || (exports.InterruptType = {}));
+
+/**
+ * Core data model types for Conversational Agent REST endpoints
+ * Contains: Conversation, Exchange, Message, ContentPart, ToolCall, etc.
+ */
+/**
+ * Represents the order in which items should be sorted.
+ */
+exports.SortOrder = void 0;
+(function (SortOrder) {
+    SortOrder["Ascending"] = "ascending";
+    SortOrder["Descending"] = "descending";
+})(exports.SortOrder || (exports.SortOrder = {}));
+/**
+ * Feedback rating type.
+ */
+exports.FeedbackRating = void 0;
+(function (FeedbackRating) {
+    FeedbackRating["Positive"] = "positive";
+    FeedbackRating["Negative"] = "negative";
+})(exports.FeedbackRating || (exports.FeedbackRating = {}));
+
+/**
+ * Event types for Conversational Agent WebSocket protocol
+ */
+/**
+ * Identifies how sensitive the LLM should be when detecting the start or end of speech.
+ *
+ *     * UNSPECIFIED - the default is HIGH
+ *     * HIGH - Will detect the start/end of speech more often.
+ *     * LOW - Will detect the start/end of speech less often.
+ */
+exports.InputStreamSpeechSensitivity = void 0;
+(function (InputStreamSpeechSensitivity) {
+    InputStreamSpeechSensitivity["Unspecified"] = "UNSPECIFIED";
+    InputStreamSpeechSensitivity["High"] = "HIGH";
+    InputStreamSpeechSensitivity["Low"] = "LOW";
+})(exports.InputStreamSpeechSensitivity || (exports.InputStreamSpeechSensitivity = {}));
+
+/**
+ * Content Part Stream Types
+ *
+ * Defines the public API for interacting with streaming content parts
+ * within a message. Content parts represent text, audio, images, etc.
+ */
+/**
+ * Types of citation processing errors
+ */
+exports.CitationErrorType = void 0;
+(function (CitationErrorType) {
+    CitationErrorType["CitationNotEnded"] = "CitationNotEnded";
+    CitationErrorType["CitationNotStarted"] = "CitationNotStarted";
+})(exports.CitationErrorType || (exports.CitationErrorType = {}));
+
+/**
+ * Conversation Service Model
+ *
+ * This interface defines the HTTP CRUD operations for conversations
+ * and real-time WebSocket session management.
+ */
+/**
+ * Creates methods for a conversation
+ *
+ * @param conversationData - The conversation data (response from API)
+ * @param service - The conversation service instance
+ * @param sessionMethods - Optional session methods for WebSocket session operations
+ * @param exchangeService - Optional exchange service for scoped exchange methods
+ * @returns Object containing conversation methods
+ */
+function createConversationMethods(conversationData, service, sessionMethods, exchangeService) {
+    return {
+        exchanges: {
+            getAll(options) {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                if (!exchangeService)
+                    throw new Error('Exchange methods are not available.');
+                return exchangeService.getAll(conversationData.id, options);
+            },
+            getById(exchangeId, options) {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                if (!exchangeService)
+                    throw new Error('Exchange methods are not available.');
+                return exchangeService.getById(conversationData.id, exchangeId, options);
+            },
+            createFeedback(exchangeId, options) {
+                if (!conversationData.id)
+                    throw new Error('Conversation ID is undefined');
+                if (!exchangeService)
+                    throw new Error('Exchange methods are not available.');
+                return exchangeService.createFeedback(conversationData.id, exchangeId, options);
+            }
+        },
+        async update(options) {
+            if (!conversationData.id)
+                throw new Error('Conversation ID is undefined');
+            return service.updateById(conversationData.id, options);
+        },
+        async delete() {
+            if (!conversationData.id)
+                throw new Error('Conversation ID is undefined');
+            return service.deleteById(conversationData.id);
+        },
+        startSession(options) {
+            if (!conversationData.id)
+                throw new Error('Conversation ID is undefined');
+            if (!sessionMethods) {
+                throw new Error('Session methods are not available. Use ConversationService to create conversations with session support.');
+            }
+            return sessionMethods.startSession(conversationData.id, options);
+        },
+        getSession() {
+            if (!conversationData.id)
+                throw new Error('Conversation ID is undefined');
+            if (!sessionMethods) {
+                throw new Error('Session methods are not available. Use ConversationService to create conversations with session support.');
+            }
+            return sessionMethods.getSession(conversationData.id);
+        },
+        endSession() {
+            if (!conversationData.id)
+                throw new Error('Conversation ID is undefined');
+            if (!sessionMethods) {
+                throw new Error('Session methods are not available. Use ConversationService to create conversations with session support.');
+            }
+            sessionMethods.endSession(conversationData.id);
+        },
+        async uploadAttachment(file) {
+            if (!conversationData.id)
+                throw new Error('Conversation ID is undefined');
+            return service.uploadAttachment(conversationData.id, file);
+        }
+    };
+}
+/**
+ * Creates an actionable conversation by combining API conversation data with operational methods.
+ *
+ * @param conversationData - The conversation data from API
+ * @param service - The conversation service instance
+ * @param sessionMethods - Optional session methods for WebSocket session operations
+ * @param exchangeService - Optional exchange service for scoped exchange methods
+ * @returns A conversation object with added methods
+ */
+function createConversationWithMethods(conversationData, service, sessionMethods, exchangeService) {
+    const methods = createConversationMethods(conversationData, service, sessionMethods, exchangeService);
+    return Object.assign({}, conversationData, methods);
+}
+
+/**
+ * Agent Service Models
+ *
+ * Provides fluent API for agent objects returned from getAll() and getById().
+ */
+/**
+ * Creates methods for an agent
+ *
+ * @param agentData - The agent data from API
+ * @param conversationService - The conversation service instance for delegation
+ * @returns Object containing agent methods
+ */
+function createAgentMethods(agentData, conversationService) {
+    const agentConversations = {
+        async create(options = {}) {
+            return conversationService.create(agentData.id, agentData.folderId, options);
+        }
+    };
+    return {
+        conversations: agentConversations,
+        get connectionStatus() { return conversationService.connectionStatus; },
+        get isConnected() { return conversationService.isConnected; },
+        get connectionError() { return conversationService.connectionError; }
+    };
+}
+function createAgentWithMethods(agentData, conversationService) {
+    const methods = createAgentMethods(agentData, conversationService);
+    return Object.defineProperties(Object.assign({}, agentData), Object.getOwnPropertyDescriptors(methods));
+}
+
+/**
+ * Constants for Agent Service
+ */
+/**
+ * Maps fields for Agent entities to ensure consistent SDK naming
+ */
+const AgentMap = {
+    ...CommonFieldMap
+};
+
+/**
+ * Constants for User Service
+ */
+/**
+ * Maps fields for User Settings entities to ensure consistent SDK naming
+ */
+const UserSettingsMap = {
+    ...CommonFieldMap
+};
+
 exports.APP_NAME = APP_NAME;
+exports.AgentMap = AgentMap;
 exports.AuthenticationError = AuthenticationError;
 exports.AuthorizationError = AuthorizationError;
 exports.CLOUD_CLIENT_ID = CLOUD_CLIENT_ID;
@@ -10771,12 +11129,15 @@ exports.CLOUD_ROLE_NAME = CLOUD_ROLE_NAME;
 exports.CLOUD_TENANT_NAME = CLOUD_TENANT_NAME;
 exports.CLOUD_URL = CLOUD_URL;
 exports.CONNECTION_STRING = CONNECTION_STRING;
+exports.ConversationMap = ConversationMap;
 exports.DEFAULT_ITEMS_FIELD = DEFAULT_ITEMS_FIELD;
 exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
 exports.DEFAULT_TOTAL_COUNT_FIELD = DEFAULT_TOTAL_COUNT_FIELD;
 exports.ErrorType = ErrorType;
+exports.ExchangeMap = ExchangeMap;
 exports.HttpStatus = HttpStatus;
 exports.MAX_PAGE_SIZE = MAX_PAGE_SIZE;
+exports.MessageMap = MessageMap;
 exports.NetworkError = NetworkError;
 exports.NotFoundError = NotFoundError;
 exports.RateLimitError = RateLimitError;
@@ -10789,9 +11150,12 @@ exports.ServerError = ServerError;
 exports.UNKNOWN = UNKNOWN$1;
 exports.UiPath = UiPath;
 exports.UiPathError = UiPathError;
+exports.UserSettingsMap = UserSettingsMap;
 exports.VERSION = VERSION;
 exports.ValidationError = ValidationError;
+exports.createAgentWithMethods = createAgentWithMethods;
 exports.createCaseInstanceWithMethods = createCaseInstanceWithMethods;
+exports.createConversationWithMethods = createConversationWithMethods;
 exports.createEntityWithMethods = createEntityWithMethods;
 exports.createProcessInstanceWithMethods = createProcessInstanceWithMethods;
 exports.createProcessWithMethods = createProcessWithMethods;