@uipath/uipath-typescript 1.0.0 → 1.1.1

package/dist/core/index.cjs

@@ -3879,6 +3879,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);
@@ -3889,533 +3898,544 @@ function hasSecretConfig(config) {
 }
 
 /**
- * TokenManager is responsible for managing authentication tokens.
- * It provides token operations for a specific client ID.
- * - For OAuth tokens: Uses session storage with client ID-based keys
- * - For Secret tokens: Stores only in memory, allowing multiple instances
+ * Base error class for all UiPath SDK errors
+ * Extends Error for standard error handling compatibility
  */
-class TokenManager {
-    /**
-     * Creates a new TokenManager instance
-     * @param executionContext The execution context
-     * @param config The SDK configuration
-     * @param isOAuth Whether this is an OAuth-based authentication
-     */
-    constructor(executionContext, config, isOAuth = false) {
-        this.executionContext = executionContext;
-        this.config = config;
-        this.isOAuth = isOAuth;
-        this.STORAGE_KEY_PREFIX = 'uipath_sdk_user_token-';
-        this.refreshPromise = null;
-    }
-    /**
-     * Checks if a token is expired
-     * @param tokenInfo The token info to check
-     * @returns true if the token is expired, false otherwise
-     */
-    isTokenExpired(tokenInfo) {
-        // If no token info or no expiration date, token is not expired
-        if (!tokenInfo?.expiresAt) {
-            return false;
-        }
-        return new Date() >= tokenInfo.expiresAt;
-    }
-    /**
-     * Gets the storage key for this TokenManager instance
-     */
-    _getStorageKey() {
-        return `${this.STORAGE_KEY_PREFIX}${this.config.clientId}`;
-    }
-    /**
-     * Loads token from session storage if available
-     * @returns true if a valid token was loaded, false otherwise
-     */
-    loadFromStorage() {
-        // Only OAuth tokens are stored in session storage
-        if (!isBrowser || !this.isOAuth) {
-            return false;
-        }
-        try {
-            const storedToken = sessionStorage.getItem(this._getStorageKey());
-            if (!storedToken) {
-                return false;
-            }
-            const tokenInfo = this._parseTokenInfo(storedToken);
-            if (!tokenInfo) {
-                // Invalid token format, clear it
-                sessionStorage.removeItem(this._getStorageKey());
-                return false;
-            }
-            // Check if token is expired
-            if (this.isTokenExpired(tokenInfo)) {
-                // Token expired, clear it
-                sessionStorage.removeItem(this._getStorageKey());
-                return false;
-            }
-            // Valid token found, use it
-            this.currentToken = tokenInfo;
-            this._updateExecutionContext(tokenInfo);
-            return true;
-        }
-        catch (error) {
-            console.warn('Failed to load token from session storage', error);
-            return false;
+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);
         }
     }
     /**
-     * Parse and validate token info from storage
-     * @param storedToken JSON string from storage
-     * @returns Valid TokenInfo or undefined if invalid
+     * Returns a clean JSON representation of the error
      */
-    _parseTokenInfo(storedToken) {
-        try {
-            const parsed = JSON.parse(storedToken);
-            // Basic validation
-            if (typeof parsed !== 'object' || !parsed) {
-                return undefined;
-            }
-            if (typeof parsed.token !== 'string' || !parsed.token) {
-                return undefined;
-            }
-            if (parsed.type !== 'secret' && parsed.type !== 'oauth') {
-                return undefined;
-            }
-            const tokenInfo = parsed;
-            // Convert string date back to Date object
-            if (tokenInfo.expiresAt) {
-                tokenInfo.expiresAt = new Date(tokenInfo.expiresAt);
-                // Verify it's a valid date
-                if (isNaN(tokenInfo.expiresAt.getTime())) {
-                    return undefined;
-                }
-            }
-            return tokenInfo;
-        }
-        catch (error) {
-            console.warn('Failed to parse token info', error);
-            return undefined;
-        }
+    toJSON() {
+        return {
+            type: this.type,
+            message: this.message,
+            statusCode: this.statusCode,
+            requestId: this.requestId,
+            timestamp: this.timestamp
+        };
     }
     /**
-     * Sets a new token and updates all necessary contexts
+     * Returns detailed debug information including stack trace
      */
-    setToken(tokenInfo) {
-        this.currentToken = tokenInfo;
-        // Store token in execution context
-        this._updateExecutionContext(tokenInfo);
-        // Store in session storage if in browser and this is an OAuth token
-        if (isBrowser && this.isOAuth) {
-            try {
-                sessionStorage.setItem(this._getStorageKey(), JSON.stringify(tokenInfo));
-            }
-            catch (error) {
-                console.warn('Failed to store token in session storage', error);
-            }
-        }
+    getDebugInfo() {
+        return {
+            ...this.toJSON(),
+            stack: this.stack
+        };
     }
-    /**
-     * Gets the current token information
-     */
-    getTokenInfo() {
-        return this.currentToken;
+}
+
+/**
+ * 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'
+};
+/**
+ * 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'};
+
+/**
+ * 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
+        });
     }
-    /**
-     * Gets just the token string
-     */
-    getToken() {
-        return this.currentToken?.token;
+}
+
+/**
+ * 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
+        });
     }
-    /**
-     * Checks if we have a valid token
-     */
-    hasValidToken() {
-        if (!this.currentToken) {
-            return false;
-        }
-        if (this.isTokenExpired(this.currentToken)) {
-            return false;
-        }
-        return true;
+}
+
+/**
+ * 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
+        });
     }
-    /**
-     * Clears the current token
-     */
-    clearToken() {
-        this.currentToken = undefined;
-        this.executionContext.set('tokenInfo', undefined);
-        const headers = this.executionContext.getHeaders();
-        delete headers['Authorization'];
-        this.executionContext.setHeaders(headers);
-        // Remove from session storage if this is an OAuth token
-        if (isBrowser && this.isOAuth) {
-            try {
-                sessionStorage.removeItem(this._getStorageKey());
-            }
-            catch (error) {
-                console.warn('Failed to remove token from session storage', error);
-            }
-        }
+}
+
+/**
+ * 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
+        });
     }
-    /**
-     * Updates execution context with token information
-     */
-    _updateExecutionContext(tokenInfo) {
-        this.executionContext.set('tokenInfo', tokenInfo);
-        // Update authorization header
-        this.executionContext.setHeaders({
-            'Authorization': `Bearer ${tokenInfo.token}`
+}
+
+/**
+ * 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
         });
     }
-    /**
-     * Refreshes the access token using the stored refresh token.
-     * This method only works for OAuth flow.
-     * Uses a lock mechanism to prevent multiple simultaneous refreshes.
-     * @returns A promise that resolves to the new AuthToken
-     * @throws Error if not in OAuth flow, refresh token is missing, or the request fails
-     */
-    async refreshAccessToken() {
-        // If there's already a refresh in progress, return that promise
-        if (this.refreshPromise) {
-            return this.refreshPromise;
-        }
-        try {
-            // Create new refresh promise
-            this.refreshPromise = this._doRefreshToken();
-            // Wait for refresh to complete
-            const result = await this.refreshPromise;
-            return result;
-        }
-        finally {
-            // Clear the refresh promise when done (success or failure)
-            this.refreshPromise = null;
-        }
+}
+
+/**
+ * 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
+        });
     }
     /**
-     * Internal method to perform the actual token refresh
+     * Checks if this is a temporary error that might succeed on retry
      */
-    async _doRefreshToken() {
-        // Check if we're in OAuth flow
-        if (!hasOAuthConfig(this.config)) {
-            throw new Error('refreshAccessToken is only available in OAuth flow');
-        }
-        // Get current token info from token manager
-        const tokenInfo = this.getTokenInfo();
-        if (!tokenInfo?.refreshToken) {
-            throw new Error('No refresh token available. User may need to re-authenticate.');
-        }
-        const orgName = this.config.orgName;
-        const body = new URLSearchParams({
-            grant_type: 'refresh_token',
-            client_id: this.config.clientId,
-            refresh_token: tokenInfo.refreshToken
-        });
-        const response = await fetch(`${this.config.baseUrl}/${orgName}/identity_/connect/token`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded'
-            },
-            body: body.toString()
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({ message: response.statusText }));
-            console.error("Token refresh error:", errorData);
-            // Clear the invalid token to prevent further failed requests
-            this.clearToken();
-            throw new Error(`Failed to refresh access token: ${JSON.stringify(errorData)}`);
-        }
-        const token = await response.json();
-        this.setToken({
-            token: token.access_token,
-            type: 'oauth',
-            expiresAt: new Date(Date.now() + token.expires_in * 1000),
-            refreshToken: token.refresh_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
         });
-        return token;
     }
 }
 
 /**
- * API Endpoint Constants
- * Centralized location for all API endpoints used throughout the SDK
+ * Type guard to check if an error is a UiPathError
  */
+function isUiPathError(error) {
+    return error instanceof UiPathError;
+}
 /**
- * Base path constants for different services
+ * Type guard to check if an error is an AuthenticationError
  */
-const IDENTITY_BASE = 'identity_';
+function isAuthenticationError(error) {
+    return error instanceof AuthenticationError;
+}
 /**
- * Identity/Authentication Endpoints
+ * Type guard to check if an error is an AuthorizationError
  */
-const IDENTITY_ENDPOINTS = {
-    TOKEN: `${IDENTITY_BASE}/connect/token`,
-    AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`,
-};
-
-class AuthService {
-    constructor(config, executionContext) {
-        // Check if we should use stored OAuth context instead of provided config
-        const storedContext = AuthService.getStoredOAuthContext();
-        const effectiveConfig = storedContext ? AuthService._mergeConfigWithContext(config, storedContext) : config;
-        this.config = effectiveConfig;
-        const isOAuth = hasOAuthConfig(effectiveConfig);
-        this.tokenManager = new TokenManager(executionContext, effectiveConfig, isOAuth);
-        // Auto-load token from storage on initialization
-        // This ensures isAuthenticated() returns true after page refresh if a valid token exists
-        this.tokenManager.loadFromStorage();
+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
+        };
     }
-    /**
-     * Check if we're in an OAuth callback state
-     */
-    static isInOAuthCallback() {
-        if (!isBrowser)
-            return false;
-        const urlParams = new URLSearchParams(window.location.search);
-        const code = urlParams.get('code');
-        const hasCodeVerifier = sessionStorage.getItem('uipath_sdk_code_verifier');
-        return !!(code && hasCodeVerifier);
+    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.
+ * - For OAuth tokens: Uses session storage with client ID-based keys
+ * - For Secret tokens: Stores only in memory, allowing multiple instances
+ */
+class TokenManager {
     /**
-     * Get stored OAuth context
+     * Creates a new TokenManager instance
+     * @param executionContext The execution context
+     * @param config The SDK configuration
+     * @param isOAuth Whether this is an OAuth-based authentication
      */
-    static getStoredOAuthContext() {
-        if (!isBrowser) {
-            return null;
+    constructor(executionContext, config, isOAuth = false) {
+        this.executionContext = executionContext;
+        this.config = config;
+        this.isOAuth = isOAuth;
+        this.refreshPromise = null;
+    }
+    /**
+     * Checks if a token is expired
+     * @param tokenInfo The token info to check
+     * @returns true if the token is expired, false otherwise
+     */
+    isTokenExpired(tokenInfo) {
+        // If no token info or no expiration date, token is not expired
+        if (!tokenInfo?.expiresAt) {
+            return false;
         }
+        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 stored = sessionStorage.getItem('uipath_sdk_oauth_context');
-            if (!stored) {
-                return null;
-            }
-            const context = JSON.parse(stored);
-            // Validate required fields
-            if (!context.codeVerifier || !context.clientId || !context.redirectUri ||
-                !context.baseUrl || !context.orgName) {
-                sessionStorage.removeItem('uipath_sdk_oauth_context');
-                return null;
-            }
-            return context;
+            const newToken = await this.refreshAccessToken();
+            return newToken.access_token;
         }
         catch (error) {
-            sessionStorage.removeItem('uipath_sdk_oauth_context');
-            console.warn('Failed to parse stored OAuth context from session storage', error);
-            return null;
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new AuthenticationError({
+                message: `Token refresh failed: ${message}. Please re-authenticate.`,
+                statusCode: HttpStatus.UNAUTHORIZED
+            });
         }
     }
     /**
-     * Merges provided config with stored OAuth context, prioritizing stored values
-     */
-    static _mergeConfigWithContext(config, context) {
-        return {
-            ...config,
-            baseUrl: context.baseUrl,
-            orgName: context.orgName,
-            tenantName: context.tenantName,
-            clientId: context.clientId,
-            redirectUri: context.redirectUri,
-            scope: context.scope
-        };
-    }
-    /**
-     * Get the token manager instance
+     * Gets the storage key for this TokenManager instance
      */
-    getTokenManager() {
-        return this.tokenManager;
+    _getStorageKey() {
+        return `${AUTH_STORAGE_KEYS.TOKEN_PREFIX}${this.config.clientId}`;
     }
     /**
-     * Authenticates the user based on the provided SDK configuration.
-     * This method handles OAuth 2.0 authentication flow only.
-     * For secret-based authentication, see authenticateWithSecret().
-     * @param config The SDK configuration object.
-     * @returns A promise that resolves to true if authentication is successful, otherwise false.
-     * In an OAuth flow, this method will trigger a page redirect and the promise will not resolve.
+     * Loads token from session storage if available
+     * @returns true if a valid token was loaded, false otherwise
      */
-    async authenticate(config) {
-        if (!isBrowser) {
+    loadFromStorage() {
+        // Only OAuth tokens are stored in session storage
+        if (!isBrowser || !this.isOAuth) {
             return false;
         }
-        // First priority: Complete OAuth callback if we detect it
-        if (AuthService.isInOAuthCallback()) {
-            const urlParams = new URLSearchParams(window.location.search);
-            const code = urlParams.get('code');
-            if (!code) {
-                throw new Error('Authorization code missing in OAuth callback');
+        try {
+            const storedToken = sessionStorage.getItem(this._getStorageKey());
+            if (!storedToken) {
+                return false;
             }
-            // Check if token already exists (prevents duplicate processing)
-            if (this.tokenManager.hasValidToken()) {
-                return true;
+            const tokenInfo = this._parseTokenInfo(storedToken);
+            if (!tokenInfo) {
+                // Invalid token format, clear it
+                sessionStorage.removeItem(this._getStorageKey());
+                return false;
             }
-            // Ensure we have OAuth config for callback completion
-            if (!hasOAuthConfig(config)) {
-                throw new Error('OAuth configuration incomplete: clientId, redirectUri, and scope are required for OAuth callback');
+            // Check if token is expired
+            if (this.isTokenExpired(tokenInfo)) {
+                // Token expired, clear it
+                sessionStorage.removeItem(this._getStorageKey());
+                return false;
             }
-            const result = await this._authenticateWithOAuth(config.clientId, config.redirectUri, config.scope);
-            return result;
-        }
-        // Secondly: Try to load existing valid token from storage
-        const loadedFromStorage = this.tokenManager.loadFromStorage();
-        // If we have a valid token from storage, return true
-        if (loadedFromStorage && this.tokenManager.hasValidToken()) {
+            // Valid token found, use it
+            this.currentToken = tokenInfo;
+            this._updateExecutionContext(tokenInfo);
             return true;
         }
-        // Start new OAuth flow if config has OAuth fields
-        if (hasOAuthConfig(config)) {
-            return await this._authenticateWithOAuth(config.clientId, config.redirectUri, config.scope);
+        catch (error) {
+            console.warn('Failed to load token from session storage', error);
+            return false;
         }
-        return false;
     }
     /**
-     * Authenticate using OAuth flow
+     * Parse and validate token info from storage
+     * @param storedToken JSON string from storage
+     * @returns Valid TokenInfo or undefined if invalid
      */
-    async _authenticateWithOAuth(clientId, redirectUri, scope) {
-        if (!isBrowser) {
-            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 isInOAuthFlow = codeVerifier !== null;
-        const urlParams = new URLSearchParams(window.location.search);
-        const code = urlParams.get('code');
-        // If we're in an OAuth flow (server-controlled code verifier exists), handle the callback
-        if (isInOAuthFlow) {
-            // We're expecting a callback - validate parameters
-            if (!code) {
-                // Clear stored state on error
-                sessionStorage.removeItem('uipath_sdk_code_verifier');
-                throw new Error('Authorization code missing in OAuth callback');
+    _parseTokenInfo(storedToken) {
+        try {
+            const parsed = JSON.parse(storedToken);
+            // Basic validation
+            if (typeof parsed !== 'object' || !parsed) {
+                return undefined;
             }
-            // Validate the authorization code format before using it
-            // OAuth authorization codes should be alphanumeric with some special characters
-            const codePattern = /^[A-Za-z0-9\-._~+/]+=*$/;
-            if (!codePattern.test(code)) {
-                // Clear stored state on error
-                sessionStorage.removeItem('uipath_sdk_code_verifier');
-                throw new Error('Invalid authorization code format');
+            if (typeof parsed.token !== 'string' || !parsed.token) {
+                return undefined;
             }
-            // Authorization code is present and validated, so we can exchange it for a token.
-            await this._handleOAuthCallback(code, clientId, redirectUri);
-            return this.hasValidToken();
+            if (parsed.type !== 'secret' && parsed.type !== 'oauth') {
+                return undefined;
+            }
+            const tokenInfo = parsed;
+            // Convert string date back to Date object
+            if (tokenInfo.expiresAt) {
+                tokenInfo.expiresAt = new Date(tokenInfo.expiresAt);
+                // Verify it's a valid date
+                if (isNaN(tokenInfo.expiresAt.getTime())) {
+                    return undefined;
+                }
+            }
+            return tokenInfo;
         }
-        else {
-            // Not in an OAuth flow - initiate one
-            // Ignore any URL parameters that might be present
-            await this._initiateOAuthFlow(clientId, redirectUri, scope);
-            // This line is not expected to be reached due to redirect
-            return false;
+        catch (error) {
+            console.warn('Failed to parse token info', error);
+            return undefined;
         }
     }
     /**
-     * Authenticate using API secret
+     * Sets a new token and updates all necessary contexts
      */
-    authenticateWithSecret(secret) {
-        try {
-            this.updateToken({ token: secret, type: 'secret' });
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to authenticate with secret', error);
-            return false;
+    setToken(tokenInfo) {
+        this.currentToken = tokenInfo;
+        // Store token in execution context
+        this._updateExecutionContext(tokenInfo);
+        // Store in session storage if in browser and this is an OAuth token
+        if (isBrowser && this.isOAuth) {
+            try {
+                sessionStorage.setItem(this._getStorageKey(), JSON.stringify(tokenInfo));
+            }
+            catch (error) {
+                console.warn('Failed to store token in session storage', error);
+            }
         }
     }
     /**
-     * Updates the access token used for API requests
-     * @param tokenInfo The token information containing the access token, type, expiration, and refresh token
+     * Gets the current token information
      */
-    updateToken(tokenInfo) {
-        this.tokenManager.setToken(tokenInfo);
+    getTokenInfo() {
+        return this.currentToken;
     }
     /**
-     * Checks if the current token is valid
+     * Gets just the token string
      */
-    hasValidToken() {
-        return this.tokenManager.hasValidToken();
+    getToken() {
+        return this.currentToken?.token;
     }
     /**
-     * Get the current token
+     * Checks if we have a valid token
      */
-    getToken() {
-        if (!this.tokenManager.hasValidToken()) {
-            return undefined;
+    hasValidToken() {
+        if (!this.currentToken) {
+            return false;
         }
-        return this.tokenManager.getToken();
+        if (this.isTokenExpired(this.currentToken)) {
+            return false;
+        }
+        return true;
     }
     /**
-     * Generates a random code verifier for PKCE
+     * Clears the current token
      */
-    generateCodeVerifier() {
-        if (isBrowser) {
-            const array = new Uint8Array(32);
-            crypto.getRandomValues(array);
-            return this._base64URLEncode(array);
-        }
-        else {
-            // In Node.js environment
+    clearToken() {
+        this.currentToken = undefined;
+        this.executionContext.set('tokenInfo', undefined);
+        const headers = this.executionContext.getHeaders();
+        delete headers['Authorization'];
+        this.executionContext.setHeaders(headers);
+        // Remove from session storage if this is an OAuth token
+        if (isBrowser && this.isOAuth) {
             try {
-                const crypto = require('crypto');
-                return crypto.randomBytes(32)
-                    .toString('base64')
-                    .replace(/\+/g, '-')
-                    .replace(/\//g, '_')
-                    .replace(/=/g, '');
+                sessionStorage.removeItem(this._getStorageKey());
             }
-            catch {
-                throw new Error("crypto not available in browser");
+            catch (error) {
+                console.warn('Failed to remove token from session storage', error);
             }
         }
     }
     /**
-     * Generates a code challenge from the code verifier
+     * Updates execution context with token information
      */
-    async generateCodeChallenge(codeVerifier) {
-        if (isBrowser) {
-            const encoder = new TextEncoder();
-            const data = encoder.encode(codeVerifier);
-            const hash = await crypto.subtle.digest('SHA-256', data);
-            return this._base64URLEncode(new Uint8Array(hash));
-        }
-        else {
-            // In Node.js environment
-            try {
-                const crypto = require('crypto');
-                return crypto.createHash('sha256')
-                    .update(codeVerifier)
-                    .digest('base64')
-                    .replace(/\+/g, '-')
-                    .replace(/\//g, '_')
-                    .replace(/=/g, '');
-            }
-            catch {
-                throw new Error("crypto not available in browser");
-            }
-        }
+    _updateExecutionContext(tokenInfo) {
+        this.executionContext.set('tokenInfo', tokenInfo);
+        // Update authorization header
+        this.executionContext.setHeaders({
+            'Authorization': `Bearer ${tokenInfo.token}`
+        });
     }
     /**
-     * Gets the authorization URL for the OAuth flow
+     * Refreshes the access token using the stored refresh token.
+     * This method only works for OAuth flow.
+     * Uses a lock mechanism to prevent multiple simultaneous refreshes.
+     * @returns A promise that resolves to the new AuthToken
+     * @throws Error if not in OAuth flow, refresh token is missing, or the request fails
      */
-    getAuthorizationUrl(params) {
-        const orgName = this.config.orgName;
-        const queryParams = new URLSearchParams({
-            response_type: 'code',
-            client_id: params.clientId,
-            redirect_uri: params.redirectUri,
-            code_challenge: params.codeChallenge,
-            code_challenge_method: 'S256',
-            scope: params.scope + ' offline_access',
-            state: params.state || this.generateCodeVerifier().slice(0, 16)
-        });
-        return `${this.config.baseUrl}/${orgName}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
+    async refreshAccessToken() {
+        // If there's already a refresh in progress, return that promise
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+        try {
+            // Create new refresh promise
+            this.refreshPromise = this._doRefreshToken();
+            // Wait for refresh to complete
+            const result = await this.refreshPromise;
+            return result;
+        }
+        finally {
+            // Clear the refresh promise when done (success or failure)
+            this.refreshPromise = null;
+        }
     }
     /**
-     * Exchanges the authorization code for an access token and automatically updates the current token
+     * Internal method to perform the actual token refresh
      */
-    async _getAccessToken(params) {
+    async _doRefreshToken() {
+        // Check if we're in OAuth flow
+        if (!hasOAuthConfig(this.config)) {
+            throw new Error('refreshAccessToken is only available in OAuth flow');
+        }
+        // Get current token info from token manager
+        const tokenInfo = this.getTokenInfo();
+        if (!tokenInfo?.refreshToken) {
+            throw new Error('No refresh token available. User may need to re-authenticate.');
+        }
         const orgName = this.config.orgName;
         const body = new URLSearchParams({
-            grant_type: 'authorization_code',
-            client_id: params.clientId,
-            code: params.code,
-            redirect_uri: params.redirectUri,
-            code_verifier: params.codeVerifier
+            grant_type: 'refresh_token',
+            client_id: this.config.clientId,
+            refresh_token: tokenInfo.refreshToken
         });
-        const response = await fetch(`${this.config.baseUrl}/${orgName}/${IDENTITY_ENDPOINTS.TOKEN}`, {
+        const response = await fetch(`${this.config.baseUrl}/${orgName}/identity_/connect/token`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/x-www-form-urlencoded'
@@ -4424,798 +4444,913 @@ class AuthService {
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({ message: response.statusText }));
-            console.error("OAuth error:", errorData);
-            throw new Error(`Failed to get access token: ${JSON.stringify(errorData)}`);
+            console.error("Token refresh error:", errorData);
+            // Clear the invalid token to prevent further failed requests
+            this.clearToken();
+            throw new Error(`Failed to refresh access token: ${JSON.stringify(errorData)}`);
         }
         const token = await response.json();
-        this.updateToken({
+        this.setToken({
             token: token.access_token,
             type: 'oauth',
-            expiresAt: token.expires_in ? new Date(Date.now() + token.expires_in * 1000) : undefined,
+            expiresAt: new Date(Date.now() + token.expires_in * 1000),
             refreshToken: token.refresh_token
         });
         return token;
     }
-    /**
-     * Base64URL encodes an array buffer
-     */
-    _base64URLEncode(buffer) {
-        const base64 = btoa(String.fromCharCode(...buffer));
-        return base64
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=/g, '');
-    }
-    async _initiateOAuthFlow(clientId, redirectUri, scope) {
-        const codeVerifier = this.generateCodeVerifier();
-        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
-        // Store complete OAuth context for callback completion
-        const oauthContext = {
-            codeVerifier,
-            clientId,
-            redirectUri,
-            baseUrl: this.config.baseUrl,
-            orgName: this.config.orgName,
-            tenantName: this.config.tenantName,
-            scope
-        };
-        sessionStorage.setItem('uipath_sdk_oauth_context', JSON.stringify(oauthContext));
-        sessionStorage.setItem('uipath_sdk_code_verifier', codeVerifier);
-        const authUrl = this.getAuthorizationUrl({
-            clientId,
-            redirectUri,
-            codeChallenge,
-            scope
-        });
-        window.location.href = authUrl;
-    }
-    async _handleOAuthCallback(code, clientId, redirectUri) {
-        const codeVerifier = sessionStorage.getItem('uipath_sdk_code_verifier');
-        if (!codeVerifier) {
-            throw new Error('Code verifier not found in session storage. Authentication may have been interrupted.');
-        }
-        await this._getAccessToken({
-            clientId,
-            redirectUri,
-            code,
-            codeVerifier
-        });
-        // Clear OAuth context and code verifier after successful token exchange
-        sessionStorage.removeItem('uipath_sdk_oauth_context');
-        sessionStorage.removeItem('uipath_sdk_code_verifier');
-        const url = new URL(window.location.href);
-        url.searchParams.delete('code');
-        url.searchParams.delete('state');
-        window.history.replaceState({}, '', url.toString());
-    }
-}
-
-function validateConfig(config) {
-    if (!config.baseUrl || !config.orgName || !config.tenantName) {
-        throw new Error('Missing required configuration: baseUrl, orgName, and tenantName are required');
-    }
-    if (!hasSecretConfig(config) && !hasOAuthConfig(config)) {
-        throw new Error('Invalid configuration: must provide either secret or (clientId, redirectUri, and scope)');
-    }
-}
-function normalizeBaseUrl(url) {
-    return url.endsWith('/') ? url.slice(0, -1) : url;
 }
 
 /**
- * SDK Telemetry constants
+ * Base path constants for different services
  */
-// 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 VERSION = "Version";
-const SERVICE = "Service";
-const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
-const CLOUD_TENANT_NAME = "CloudTenantName";
-const CLOUD_URL = "CloudUrl";
-const CLOUD_CLIENT_ID = "CloudClientId";
-const CLOUD_REDIRECT_URI = "CloudRedirectUri";
-const APP_NAME = "ApplicationName";
-const CLOUD_ROLE_NAME = "uipath-ts-sdk";
-// Service and logger names
-const SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
-const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
-// Event names
-const SDK_RUN_EVENT = "Sdk.Run";
-// Default value for unknown/empty attributes
-const UNKNOWN = "";
+const IDENTITY_BASE = 'identity_';
 
 /**
- * Log exporter that sends ALL logs as Application Insights custom events
+ * Identity/Authentication Endpoints
  */
-class ApplicationInsightsEventExporter {
-    constructor(connectionString) {
-        this.connectionString = connectionString;
+/**
+ * Identity Service Endpoints
+ */
+const IDENTITY_ENDPOINTS = {
+    TOKEN: `${IDENTITY_BASE}/connect/token`,
+    AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`,
+};
+
+class AuthService {
+    constructor(config, executionContext) {
+        // Check if we should use stored OAuth context instead of provided config
+        const storedContext = AuthService.getStoredOAuthContext();
+        const effectiveConfig = storedContext ? AuthService._mergeConfigWithContext(config, storedContext) : config;
+        this.config = effectiveConfig;
+        const isOAuth = hasOAuthConfig(effectiveConfig);
+        this.tokenManager = new TokenManager(executionContext, effectiveConfig, isOAuth);
+        // Auto-load token from storage on initialization
+        // This ensures isAuthenticated() returns true after page refresh if a valid token exists
+        this.tokenManager.loadFromStorage();
     }
-    export(logs, resultCallback) {
+    /**
+     * Check if we're in an OAuth callback state
+     */
+    static isInOAuthCallback() {
+        if (!isBrowser)
+            return false;
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get('code');
+        const hasCodeVerifier = sessionStorage.getItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
+        return !!(code && hasCodeVerifier);
+    }
+    /**
+     * Get stored OAuth context
+     */
+    static getStoredOAuthContext() {
+        if (!isBrowser) {
+            return null;
+        }
         try {
-            logs.forEach(logRecord => {
-                this.sendAsCustomEvent(logRecord);
-            });
-            resultCallback({ code: 0 });
+            const stored = sessionStorage.getItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
+            if (!stored) {
+                return null;
+            }
+            const context = JSON.parse(stored);
+            // Validate required fields
+            if (!context.codeVerifier || !context.clientId || !context.redirectUri ||
+                !context.baseUrl || !context.orgName) {
+                sessionStorage.removeItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
+                return null;
+            }
+            return context;
         }
         catch (error) {
-            console.debug('Failed to export logs to Application Insights:', error);
-            resultCallback({ code: 2, error });
+            sessionStorage.removeItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT);
+            console.warn('Failed to parse stored OAuth context from session storage', error);
+            return null;
         }
     }
-    shutdown() {
-        return Promise.resolve();
+    /**
+     * Merges provided config with stored OAuth context, prioritizing stored values
+     */
+    static _mergeConfigWithContext(config, context) {
+        return {
+            ...config,
+            baseUrl: context.baseUrl,
+            orgName: context.orgName,
+            tenantName: context.tenantName,
+            clientId: context.clientId,
+            redirectUri: context.redirectUri,
+            scope: context.scope
+        };
     }
-    sendAsCustomEvent(logRecord) {
-        // Get event name from body or attributes
-        const eventName = logRecord.body || SDK_RUN_EVENT;
-        const payload = {
-            name: 'Microsoft.ApplicationInsights.Event',
-            time: new Date().toISOString(),
-            iKey: this.extractInstrumentationKey(),
-            data: {
-                baseType: 'EventData',
-                baseData: {
-                    ver: 2,
-                    name: eventName,
-                    properties: this.convertAttributesToProperties(logRecord.attributes || {})
-                }
-            },
-            tags: {
-                'ai.cloud.role': CLOUD_ROLE_NAME,
-                'ai.cloud.roleInstance': SDK_VERSION
-            }
-        };
-        this.sendToApplicationInsights(payload);
-    }
-    extractInstrumentationKey() {
-        const match = this.connectionString.match(/InstrumentationKey=([^;]+)/);
-        return match ? match[1] : '';
-    }
-    convertAttributesToProperties(attributes) {
-        const properties = {};
-        Object.entries(attributes || {}).forEach(([key, value]) => {
-            properties[key] = String(value);
-        });
-        return properties;
+    /**
+     * Get the token manager instance
+     */
+    getTokenManager() {
+        return this.tokenManager;
     }
-    async sendToApplicationInsights(payload) {
-        try {
-            const ingestionEndpoint = this.extractIngestionEndpoint();
-            if (!ingestionEndpoint) {
-                console.debug('No ingestion endpoint found in connection string');
-                return;
+    /**
+     * Authenticates the user based on the provided SDK configuration.
+     * This method handles OAuth 2.0 authentication flow only.
+     * For secret-based authentication, see authenticateWithSecret().
+     * @param config The SDK configuration object.
+     * @returns A promise that resolves to true if authentication is successful, otherwise false.
+     * In an OAuth flow, this method will trigger a page redirect and the promise will not resolve.
+     */
+    async authenticate(config) {
+        if (!isBrowser) {
+            return false;
+        }
+        // First priority: Complete OAuth callback if we detect it
+        if (AuthService.isInOAuthCallback()) {
+            const urlParams = new URLSearchParams(window.location.search);
+            const code = urlParams.get('code');
+            if (!code) {
+                throw new Error('Authorization code missing in OAuth callback');
             }
-            const url = `${ingestionEndpoint}/v2/track`;
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(payload)
-            });
-            if (!response.ok) {
-                console.debug(`Failed to send event telemetry: ${response.status} ${response.statusText}`);
+            // Check if token already exists (prevents duplicate processing)
+            if (this.tokenManager.hasValidToken()) {
+                return true;
+            }
+            // Ensure we have OAuth config for callback completion
+            if (!hasOAuthConfig(config)) {
+                throw new Error('OAuth configuration incomplete: clientId, redirectUri, and scope are required for OAuth callback');
             }
+            const result = await this._authenticateWithOAuth(config.clientId, config.redirectUri, config.scope);
+            return result;
         }
-        catch (error) {
-            console.debug('Error sending event telemetry to Application Insights:', error);
+        // Secondly: Try to load existing valid token from storage
+        const loadedFromStorage = this.tokenManager.loadFromStorage();
+        // If we have a valid token from storage, return true
+        if (loadedFromStorage && this.tokenManager.hasValidToken()) {
+            return true;
         }
-    }
-    extractIngestionEndpoint() {
-        const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
-        return match ? match[1] : '';
-    }
-}
-/**
- * Singleton telemetry client
- */
-class TelemetryClient {
-    constructor() {
-        this.isInitialized = false;
-    }
-    static getInstance() {
-        if (!TelemetryClient.instance) {
-            TelemetryClient.instance = new TelemetryClient();
+        // Start new OAuth flow if config has OAuth fields
+        if (hasOAuthConfig(config)) {
+            return await this._authenticateWithOAuth(config.clientId, config.redirectUri, config.scope);
         }
-        return TelemetryClient.instance;
+        return false;
     }
     /**
-     * Initialize telemetry
+     * Authenticate using OAuth flow
      */
-    initialize(config) {
-        if (this.isInitialized) {
-            return;
+    async _authenticateWithOAuth(clientId, redirectUri, scope) {
+        if (!isBrowser) {
+            throw new Error('OAuth flow is only supported in browser environments');
         }
-        this.isInitialized = true;
-        if (config) {
-            this.telemetryContext = config;
+        // Check if we have a stored code verifier indicating we're in an OAuth flow
+        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');
+        // If we're in an OAuth flow (server-controlled code verifier exists), handle the callback
+        if (isInOAuthFlow) {
+            // We're expecting a callback - validate parameters
+            if (!code) {
+                // Clear stored state on error
+                sessionStorage.removeItem(AUTH_STORAGE_KEYS.CODE_VERIFIER);
+                throw new Error('Authorization code missing in OAuth callback');
+            }
+            // Validate the authorization code format before using it
+            // OAuth authorization codes should be alphanumeric with some special characters
+            const codePattern = /^[A-Za-z0-9\-._~+/]+=*$/;
+            if (!codePattern.test(code)) {
+                // Clear stored state on error
+                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.
+            await this._handleOAuthCallback(code, clientId, redirectUri);
+            return this.hasValidToken();
+        }
+        else {
+            // Not in an OAuth flow - initiate one
+            // Ignore any URL parameters that might be present
+            await this._initiateOAuthFlow(clientId, redirectUri, scope);
+            // This line is not expected to be reached due to redirect
+            return false;
         }
+    }
+    /**
+     * Authenticate using API secret
+     */
+    authenticateWithSecret(secret) {
         try {
-            const connectionString = this.getConnectionString();
-            if (!connectionString) {
-                return;
-            }
-            this.setupTelemetryProvider(connectionString);
+            this.updateToken({ token: secret, type: 'secret' });
+            return true;
         }
         catch (error) {
-            // Silent failure - telemetry errors shouldn't break functionality
-            console.debug('Failed to initialize OpenTelemetry:', error);
+            console.error('Failed to authenticate with secret', error);
+            return false;
         }
     }
-    getConnectionString() {
-        const connectionString = CONNECTION_STRING;
-        return connectionString;
+    /**
+     * Updates the access token used for API requests
+     * @param tokenInfo The token information containing the access token, type, expiration, and refresh token
+     */
+    updateToken(tokenInfo) {
+        this.tokenManager.setToken(tokenInfo);
     }
-    setupTelemetryProvider(connectionString) {
-        const exporter = new ApplicationInsightsEventExporter(connectionString);
-        const processor = new sdkLogs.BatchLogRecordProcessor(exporter);
-        this.logProvider = new sdkLogs.LoggerProvider({
-            processors: [processor]
-        });
-        this.logger = this.logProvider.getLogger(SDK_LOGGER_NAME);
+    /**
+     * Checks if the current token is valid
+     */
+    hasValidToken() {
+        return this.tokenManager.hasValidToken();
     }
     /**
-     * Track a telemetry event
+     * Clears all authentication state including tokens and stored OAuth context.
      */
-    track(eventName, name, extraAttributes = {}) {
-        try {
-            // Skip if logger not initialized
-            if (!this.logger) {
-                return;
+    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);
             }
-            const finalDisplayName = name || eventName;
-            const attributes = this.getEnrichedAttributes(extraAttributes, eventName);
-            // Emit as log 
-            this.logger.emit({
-                body: finalDisplayName,
-                attributes: attributes,
-                timestamp: Date.now(),
-            });
-        }
-        catch (error) {
-            // Silent failure
-            console.debug('Failed to track telemetry event:', error);
         }
     }
     /**
-     * Get enriched attributes for telemetry events
+     * Get the current token
      */
-    getEnrichedAttributes(extraAttributes, eventName) {
-        const attributes = {
-            ...extraAttributes,
-            [APP_NAME]: SDK_SERVICE_NAME,
-            [VERSION]: SDK_VERSION,
-            [SERVICE]: eventName,
-            [CLOUD_URL]: this.createCloudUrl(),
-            [CLOUD_ORGANIZATION_NAME]: this.telemetryContext?.orgName || UNKNOWN,
-            [CLOUD_TENANT_NAME]: this.telemetryContext?.tenantName || UNKNOWN,
-            [CLOUD_REDIRECT_URI]: this.telemetryContext?.redirectUri || UNKNOWN,
-            [CLOUD_CLIENT_ID]: this.telemetryContext?.clientId || UNKNOWN,
-        };
-        return attributes;
+    getToken() {
+        if (!this.tokenManager.hasValidToken()) {
+            return undefined;
+        }
+        return this.tokenManager.getToken();
     }
     /**
-     * Create cloud URL from base URL, organization ID, and tenant ID
+     * Generates a random code verifier for PKCE
      */
-    createCloudUrl() {
-        const baseUrl = this.telemetryContext?.baseUrl;
-        const orgId = this.telemetryContext?.orgName;
-        const tenantId = this.telemetryContext?.tenantName;
-        if (!baseUrl || !orgId || !tenantId) {
-            return UNKNOWN;
-        }
-        return `${baseUrl}/${orgId}/${tenantId}`;
-    }
-}
-// Export singleton instance
-const telemetryClient = TelemetryClient.getInstance();
-
-/**
- * SDK Track decorator and function for telemetry
- */
-/**
- * Direct tracking function
- */
-function trackEvent(eventName, name, attributes) {
-    telemetryClient.track(eventName, name, attributes);
-}
-
-/**
- * SDK Internals Registry - Internal registry for SDK instances
- *
- * This class is NOT exported in the public API.
- * It provides a secure way to share SDK internals between
- * the UiPath class and service classes without exposing them publicly.
- *
- * @internal
- */
-// Global symbol key to ensure WeakMap is shared across module instances
-// This prevents issues when core and service modules are bundled separately
-const REGISTRY_KEY = Symbol.for('@uipath/sdk-internals-registry');
-// Get or create the global WeakMap store
-const getGlobalStore = () => {
-    const globalObj = globalThis;
-    if (!globalObj[REGISTRY_KEY]) {
-        globalObj[REGISTRY_KEY] = new WeakMap();
-    }
-    return globalObj[REGISTRY_KEY];
-};
-/**
- * Internal registry for SDK private components.
- * Uses WeakMap to prevent memory leaks - entries are automatically
- * garbage collected when the SDK instance is no longer referenced.
- *
- * Uses a global singleton pattern to ensure the same WeakMap is shared
- * across separately bundled modules (core, entities, tasks, etc.).
- *
- * @internal - Not exported in public API
- */
-class SDKInternalsRegistry {
-    // Use global store to ensure sharing across module bundles
-    static get store() {
-        return getGlobalStore();
-    }
-    /**
-     * Register SDK instance internals
-     * Called by UiPath constructor
-     */
-    static set(instance, internals) {
-        this.store.set(instance, internals);
-    }
-    /**
-     * Retrieve SDK instance internals
-     * Called by BaseService constructor
-     */
-    static get(instance) {
-        const internals = this.store.get(instance);
-        if (!internals) {
-            throw new Error('Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.');
-        }
-        return internals;
-    }
-}
-
-var _UiPath_config, _UiPath_authService, _UiPath_initialized;
-/**
- * UiPath - Core SDK class for authentication and configuration management.
- *
- * Handles authentication, configuration, and provides access to SDK internals
- * for service instantiation in the modular pattern.
- *
- * @example
- * ```typescript
- * // Modular pattern
- * import { UiPath } from '@uipath/uipath-typescript/core';
- * import { Entities } from '@uipath/uipath-typescript/entities';
- *
- * const sdk = new UiPath({
- *   baseUrl: 'https://cloud.uipath.com',
- *   orgName: 'myorg',
- *   tenantName: 'mytenant',
- *   clientId: 'xxx',
- *   redirectUri: 'http://localhost:3000/callback',
- *   scope: 'OR.Users OR.Robots'
- * });
- *
- * await sdk.initialize();
- *
- * const entitiesService = new Entities(sdk);
- * const allEntities = await entitiesService.getAll();
- * ```
- */
-class UiPath {
-    constructor(config) {
-        // Private fields - true runtime privacy, not visible via Object.keys()
-        _UiPath_config.set(this, void 0);
-        _UiPath_authService.set(this, void 0);
-        _UiPath_initialized.set(this, false);
-        // Validate and normalize the configuration
-        validateConfig(config);
-        const hasSecretAuth = hasSecretConfig(config);
-        const hasOAuthAuth = hasOAuthConfig(config);
-        // Initialize core components
-        const internalConfig = new UiPathConfig({
-            baseUrl: normalizeBaseUrl(config.baseUrl),
-            orgName: config.orgName,
-            tenantName: config.tenantName,
-            secret: hasSecretAuth ? config.secret : undefined,
-            clientId: hasOAuthAuth ? config.clientId : undefined,
-            redirectUri: hasOAuthAuth ? config.redirectUri : undefined,
-            scope: hasOAuthAuth ? config.scope : undefined
-        });
-        const executionContext = new ExecutionContext();
-        __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
-        __classPrivateFieldSet(this, _UiPath_config, internalConfig, "f");
-        // Store internals in SDKInternalsRegistry (not visible on instance)
-        SDKInternalsRegistry.set(this, {
-            config: internalConfig,
-            context: executionContext,
-            tokenManager: __classPrivateFieldGet(this, _UiPath_authService, "f").getTokenManager()
-        });
-        // Expose read-only config for user convenience
-        this.config = {
-            baseUrl: internalConfig.baseUrl,
-            orgName: internalConfig.orgName,
-            tenantName: internalConfig.tenantName
-        };
-        // Initialize telemetry with SDK configuration
-        telemetryClient.initialize({
-            baseUrl: config.baseUrl,
-            orgName: config.orgName,
-            tenantName: config.tenantName,
-            clientId: hasOAuthAuth ? config.clientId : undefined,
-            redirectUri: hasOAuthAuth ? config.redirectUri : undefined
-        });
-        // Track SDK initialization
-        trackEvent('Sdk.Auth');
-        // Auto-initialize for secret-based auth
-        if (hasSecretAuth) {
-            __classPrivateFieldGet(this, _UiPath_authService, "f").authenticateWithSecret(config.secret);
-            __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
+    generateCodeVerifier() {
+        if (isBrowser) {
+            const array = new Uint8Array(32);
+            crypto.getRandomValues(array);
+            return this._base64URLEncode(array);
+        }
+        else {
+            // In Node.js environment
+            try {
+                const crypto = require('crypto');
+                return crypto.randomBytes(32)
+                    .toString('base64')
+                    .replace(/\+/g, '-')
+                    .replace(/\//g, '_')
+                    .replace(/=/g, '');
+            }
+            catch {
+                throw new Error("crypto not available in browser");
+            }
         }
     }
     /**
-     * Initialize the SDK based on the provided configuration.
-     * This method handles both OAuth flow initiation and completion automatically.
-     * For secret-based authentication, initialization is automatic and this returns immediately.
+     * Generates a code challenge from the code verifier
      */
-    async initialize() {
-        // For secret-based auth, it's already initialized in constructor
-        if (hasSecretConfig(__classPrivateFieldGet(this, _UiPath_config, "f"))) {
-            return;
+    async generateCodeChallenge(codeVerifier) {
+        if (isBrowser) {
+            const encoder = new TextEncoder();
+            const data = encoder.encode(codeVerifier);
+            const hash = await crypto.subtle.digest('SHA-256', data);
+            return this._base64URLEncode(new Uint8Array(hash));
         }
-        try {
-            // Check for OAuth callback first
-            if (AuthService.isInOAuthCallback()) {
-                if (await this.completeOAuth()) {
-                    return;
-                }
-            }
-            // Check if already authenticated
-            if (this.isAuthenticated()) {
-                __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
-                return;
+        else {
+            // In Node.js environment
+            try {
+                const crypto = require('crypto');
+                return crypto.createHash('sha256')
+                    .update(codeVerifier)
+                    .digest('base64')
+                    .replace(/\+/g, '-')
+                    .replace(/\//g, '_')
+                    .replace(/=/g, '');
             }
-            // Start new OAuth flow
-            await __classPrivateFieldGet(this, _UiPath_authService, "f").authenticate(__classPrivateFieldGet(this, _UiPath_config, "f"));
-            if (this.isAuthenticated()) {
-                __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
+            catch {
+                throw new Error("crypto not available in browser");
             }
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
-            throw new Error(`Failed to initialize UiPath SDK: ${errorMessage}`);
-        }
     }
     /**
-     * Check if the SDK has been initialized
-     */
-    isInitialized() {
-        return __classPrivateFieldGet(this, _UiPath_initialized, "f");
-    }
-    /**
-     * Check if we're in an OAuth callback state
+     * Gets the authorization URL for the OAuth flow
      */
-    isInOAuthCallback() {
-        return AuthService.isInOAuthCallback();
+    getAuthorizationUrl(params) {
+        const orgName = this.config.orgName;
+        const queryParams = new URLSearchParams({
+            response_type: 'code',
+            client_id: params.clientId,
+            redirect_uri: params.redirectUri,
+            code_challenge: params.codeChallenge,
+            code_challenge_method: 'S256',
+            scope: params.scope + ' offline_access',
+            state: params.state || this.generateCodeVerifier().slice(0, 16)
+        });
+        return `${this.config.baseUrl}/${orgName}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
     }
     /**
-     * Complete OAuth authentication flow (only call if isInOAuthCallback() is true)
+     * Exchanges the authorization code for an access token and automatically updates the current token
      */
-    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}`);
+    async _getAccessToken(params) {
+        const orgName = this.config.orgName;
+        const body = new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: params.clientId,
+            code: params.code,
+            redirect_uri: params.redirectUri,
+            code_verifier: params.codeVerifier
+        });
+        const response = await fetch(`${this.config.baseUrl}/${orgName}/${IDENTITY_ENDPOINTS.TOKEN}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            },
+            body: body.toString()
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ message: response.statusText }));
+            console.error("OAuth error:", errorData);
+            throw new Error(`Failed to get access token: ${JSON.stringify(errorData)}`);
         }
+        const token = await response.json();
+        this.updateToken({
+            token: token.access_token,
+            type: 'oauth',
+            expiresAt: token.expires_in ? new Date(Date.now() + token.expires_in * 1000) : undefined,
+            refreshToken: token.refresh_token
+        });
+        return token;
     }
     /**
-     * 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
+     * Base64URL encodes an array buffer
      */
-    toJSON() {
-        return {
-            type: this.type,
-            message: this.message,
-            statusCode: this.statusCode,
-            requestId: this.requestId,
-            timestamp: this.timestamp
-        };
+    _base64URLEncode(buffer) {
+        const base64 = btoa(String.fromCharCode(...buffer));
+        return base64
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
     }
-    /**
-     * Returns detailed debug information including stack trace
-     */
-    getDebugInfo() {
-        return {
-            ...this.toJSON(),
-            stack: this.stack
+    async _initiateOAuthFlow(clientId, redirectUri, scope) {
+        const codeVerifier = this.generateCodeVerifier();
+        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
+        // Store complete OAuth context for callback completion
+        const oauthContext = {
+            codeVerifier,
+            clientId,
+            redirectUri,
+            baseUrl: this.config.baseUrl,
+            orgName: this.config.orgName,
+            tenantName: this.config.tenantName,
+            scope
         };
-    }
-}
-
-/**
- * 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'
-};
-/**
- * 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'};
-
-/**
- * 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
+        sessionStorage.setItem(AUTH_STORAGE_KEYS.OAUTH_CONTEXT, JSON.stringify(oauthContext));
+        sessionStorage.setItem(AUTH_STORAGE_KEYS.CODE_VERIFIER, codeVerifier);
+        const authUrl = this.getAuthorizationUrl({
+            clientId,
+            redirectUri,
+            codeChallenge,
+            scope
         });
+        window.location.href = authUrl;
     }
-}
-
-/**
- * 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
+    async _handleOAuthCallback(code, clientId, redirectUri) {
+        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.');
+        }
+        await this._getAccessToken({
+            clientId,
+            redirectUri,
+            code,
+            codeVerifier
         });
+        // Clear OAuth context and code verifier after successful token exchange
+        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');
+        window.history.replaceState({}, '', url.toString());
     }
 }
 
-/**
- * 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
-        });
+function validateConfig(config) {
+    if (!config.baseUrl || !config.orgName || !config.tenantName) {
+        throw new Error('Missing required configuration: baseUrl, orgName, and tenantName are required');
     }
-}
-
-/**
- * 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
-        });
+    if (!hasSecretConfig(config) && !hasOAuthConfig(config)) {
+        throw new Error('Invalid configuration: must provide either secret or (clientId, redirectUri, and scope)');
     }
 }
+function normalizeBaseUrl(url) {
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+}
 
 /**
- * Error thrown when rate limit is exceeded (429 errors)
- * Common scenarios:
- * - Too many requests in a time window
- * - API throttling
+ * SDK Telemetry constants
  */
-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
-        });
-    }
-}
+// 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.1.1";
+const VERSION = "Version";
+const SERVICE = "Service";
+const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
+const CLOUD_TENANT_NAME = "CloudTenantName";
+const CLOUD_URL = "CloudUrl";
+const CLOUD_CLIENT_ID = "CloudClientId";
+const CLOUD_REDIRECT_URI = "CloudRedirectUri";
+const APP_NAME = "ApplicationName";
+const CLOUD_ROLE_NAME = "uipath-ts-sdk";
+// Service and logger names
+const SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
+const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
+// Event names
+const SDK_RUN_EVENT = "Sdk.Run";
+// Default value for unknown/empty attributes
+const UNKNOWN = "";
 
 /**
- * Error thrown when server encounters an error (5xx errors)
- * Common scenarios:
- * - Internal server error
- * - Service unavailable
- * - Gateway timeout
+ * Log exporter that sends ALL logs as Application Insights custom events
  */
-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
+class ApplicationInsightsEventExporter {
+    constructor(connectionString) {
+        this.connectionString = connectionString;
+    }
+    export(logs, resultCallback) {
+        try {
+            logs.forEach(logRecord => {
+                this.sendAsCustomEvent(logRecord);
+            });
+            resultCallback({ code: 0 });
+        }
+        catch (error) {
+            console.debug('Failed to export logs to Application Insights:', error);
+            resultCallback({ code: 2, error });
+        }
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    sendAsCustomEvent(logRecord) {
+        // Get event name from body or attributes
+        const eventName = logRecord.body || SDK_RUN_EVENT;
+        const payload = {
+            name: 'Microsoft.ApplicationInsights.Event',
+            time: new Date().toISOString(),
+            iKey: this.extractInstrumentationKey(),
+            data: {
+                baseType: 'EventData',
+                baseData: {
+                    ver: 2,
+                    name: eventName,
+                    properties: this.convertAttributesToProperties(logRecord.attributes || {})
+                }
+            },
+            tags: {
+                'ai.cloud.role': CLOUD_ROLE_NAME,
+                'ai.cloud.roleInstance': SDK_VERSION
+            }
+        };
+        this.sendToApplicationInsights(payload);
+    }
+    extractInstrumentationKey() {
+        const match = this.connectionString.match(/InstrumentationKey=([^;]+)/);
+        return match ? match[1] : '';
+    }
+    convertAttributesToProperties(attributes) {
+        const properties = {};
+        Object.entries(attributes || {}).forEach(([key, value]) => {
+            properties[key] = String(value);
         });
+        return properties;
     }
-    /**
-     * 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;
+    async sendToApplicationInsights(payload) {
+        try {
+            const ingestionEndpoint = this.extractIngestionEndpoint();
+            if (!ingestionEndpoint) {
+                console.debug('No ingestion endpoint found in connection string');
+                return;
+            }
+            const url = `${ingestionEndpoint}/v2/track`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload)
+            });
+            if (!response.ok) {
+                console.debug(`Failed to send event telemetry: ${response.status} ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            console.debug('Error sending event telemetry to Application Insights:', error);
+        }
+    }
+    extractIngestionEndpoint() {
+        const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
+        return match ? match[1] : '';
     }
 }
-
 /**
- * Error thrown when network/connection issues occur
- * Common scenarios:
- * - Connection timeout
- * - DNS resolution failure
- * - Network unreachable
- * - Request aborted
+ * Singleton telemetry client
  */
-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
+class TelemetryClient {
+    constructor() {
+        this.isInitialized = false;
+    }
+    static getInstance() {
+        if (!TelemetryClient.instance) {
+            TelemetryClient.instance = new TelemetryClient();
+        }
+        return TelemetryClient.instance;
+    }
+    /**
+     * Initialize telemetry
+     */
+    initialize(config) {
+        if (this.isInitialized) {
+            return;
+        }
+        this.isInitialized = true;
+        if (config) {
+            this.telemetryContext = config;
+        }
+        try {
+            const connectionString = this.getConnectionString();
+            if (!connectionString) {
+                return;
+            }
+            this.setupTelemetryProvider(connectionString);
+        }
+        catch (error) {
+            // Silent failure - telemetry errors shouldn't break functionality
+            console.debug('Failed to initialize OpenTelemetry:', error);
+        }
+    }
+    getConnectionString() {
+        const connectionString = CONNECTION_STRING;
+        return connectionString;
+    }
+    setupTelemetryProvider(connectionString) {
+        const exporter = new ApplicationInsightsEventExporter(connectionString);
+        const processor = new sdkLogs.BatchLogRecordProcessor(exporter);
+        this.logProvider = new sdkLogs.LoggerProvider({
+            processors: [processor]
         });
+        this.logger = this.logProvider.getLogger(SDK_LOGGER_NAME);
+    }
+    /**
+     * Track a telemetry event
+     */
+    track(eventName, name, extraAttributes = {}) {
+        try {
+            // Skip if logger not initialized
+            if (!this.logger) {
+                return;
+            }
+            const finalDisplayName = name || eventName;
+            const attributes = this.getEnrichedAttributes(extraAttributes, eventName);
+            // Emit as log 
+            this.logger.emit({
+                body: finalDisplayName,
+                attributes: attributes,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            // Silent failure
+            console.debug('Failed to track telemetry event:', error);
+        }
+    }
+    /**
+     * Get enriched attributes for telemetry events
+     */
+    getEnrichedAttributes(extraAttributes, eventName) {
+        const attributes = {
+            [APP_NAME]: SDK_SERVICE_NAME,
+            [VERSION]: SDK_VERSION,
+            [SERVICE]: eventName,
+            [CLOUD_URL]: this.createCloudUrl(),
+            [CLOUD_ORGANIZATION_NAME]: this.telemetryContext?.orgName || UNKNOWN,
+            [CLOUD_TENANT_NAME]: this.telemetryContext?.tenantName || UNKNOWN,
+            [CLOUD_REDIRECT_URI]: this.telemetryContext?.redirectUri || UNKNOWN,
+            [CLOUD_CLIENT_ID]: this.telemetryContext?.clientId || UNKNOWN,
+            ...extraAttributes,
+        };
+        return attributes;
+    }
+    /**
+     * Create cloud URL from base URL, organization ID, and tenant ID
+     */
+    createCloudUrl() {
+        const baseUrl = this.telemetryContext?.baseUrl;
+        const orgId = this.telemetryContext?.orgName;
+        const tenantId = this.telemetryContext?.tenantName;
+        if (!baseUrl || !orgId || !tenantId) {
+            return UNKNOWN;
+        }
+        return `${baseUrl}/${orgId}/${tenantId}`;
     }
 }
+// Export singleton instance
+const telemetryClient = TelemetryClient.getInstance();
 
 /**
- * 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
+ * SDK Track decorator and function for telemetry
  */
-function isAuthorizationError(error) {
-    return error instanceof AuthorizationError;
-}
 /**
- * Type guard to check if an error is a ValidationError
+ * Common tracking logic shared between method and function decorators
  */
-function isValidationError(error) {
-    return error instanceof ValidationError;
+function createTrackedFunction(originalFunction, nameOrOptions, fallbackName, opts) {
+    return function (...args) {
+        // Determine if we should track this call
+        let shouldTrack = true;
+        if (opts.condition !== undefined) {
+            if (typeof opts.condition === 'function') {
+                shouldTrack = opts.condition.apply(this, args);
+            }
+            else {
+                shouldTrack = opts.condition;
+            }
+        }
+        // Track the event if enabled
+        if (shouldTrack) {
+            // Use the full name provided in the decorator (e.g., "Queue.GetAll")
+            const serviceMethod = typeof nameOrOptions === 'string'
+                ? nameOrOptions
+                : fallbackName;
+            // Use 'Sdk.Run' as the name and serviceMethod as the service
+            telemetryClient.track(serviceMethod, SDK_RUN_EVENT, opts.attributes);
+        }
+        // Execute the original function
+        return originalFunction.apply(this, args);
+    };
 }
 /**
- * Type guard to check if an error is a NotFoundError
+ * Track decorator that can be used to automatically track function calls
+ *
+ * Usage:
+ * @track("Service.Method")
+ * function myFunction() { ... }
+ *
+ * @track("Queue.GetAll")
+ * async getAll() { ... }
+ *
+ * @track("Tasks.Create")
+ * async create() { ... }
+ *
+ * @track("Assets.Update", { condition: false })
+ * function myFunction() { ... }
+ *
+ * @track("Processes.Start", { attributes: { customProp: "value" } })
+ * function myFunction() { ... }
  */
-function isNotFoundError(error) {
-    return error instanceof NotFoundError;
+function track(nameOrOptions, options) {
+    return function decorator(_target, propertyKey, descriptor) {
+        const opts = typeof nameOrOptions === 'object' ? nameOrOptions : options || {};
+        if (descriptor && typeof descriptor.value === 'function') {
+            // Method decorator
+            descriptor.value = createTrackedFunction(descriptor.value, nameOrOptions, propertyKey || 'unknown_method', opts);
+            return descriptor;
+        }
+        // Function decorator
+        return (originalFunction) => createTrackedFunction(originalFunction, nameOrOptions, originalFunction.name || 'unknown_function', opts);
+    };
 }
 /**
- * Type guard to check if an error is a RateLimitError
+ * Direct tracking function
  */
-function isRateLimitError(error) {
-    return error instanceof RateLimitError;
+function trackEvent(eventName, name, attributes) {
+    telemetryClient.track(eventName, name, attributes);
 }
+
 /**
- * Type guard to check if an error is a ServerError
+ * SDK Internals Registry - Internal registry for SDK instances
+ *
+ * This class is NOT exported in the public API.
+ * It provides a secure way to share SDK internals between
+ * the UiPath class and service classes without exposing them publicly.
+ *
+ * @internal
  */
-function isServerError(error) {
-    return error instanceof ServerError;
-}
+// Global symbol key to ensure WeakMap is shared across module instances
+// This prevents issues when core and service modules are bundled separately
+const REGISTRY_KEY = Symbol.for('@uipath/sdk-internals-registry');
+// Get or create the global WeakMap store
+const getGlobalStore = () => {
+    const globalObj = globalThis;
+    if (!globalObj[REGISTRY_KEY]) {
+        globalObj[REGISTRY_KEY] = new WeakMap();
+    }
+    return globalObj[REGISTRY_KEY];
+};
 /**
- * Type guard to check if an error is a NetworkError
+ * Internal registry for SDK private components.
+ * Uses WeakMap to prevent memory leaks - entries are automatically
+ * garbage collected when the SDK instance is no longer referenced.
+ *
+ * Uses a global singleton pattern to ensure the same WeakMap is shared
+ * across separately bundled modules (core, entities, tasks, etc.).
+ *
+ * @internal - Not exported in public API
  */
-function isNetworkError(error) {
-    return error instanceof NetworkError;
+class SDKInternalsRegistry {
+    // Use global store to ensure sharing across module bundles
+    static get store() {
+        return getGlobalStore();
+    }
+    /**
+     * Register SDK instance internals
+     * Called by UiPath constructor
+     */
+    static set(instance, internals) {
+        this.store.set(instance, internals);
+    }
+    /**
+     * Retrieve SDK instance internals
+     * Called by BaseService constructor
+     */
+    static get(instance) {
+        const internals = this.store.get(instance);
+        if (!internals) {
+            throw new Error('Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.');
+        }
+        return internals;
+    }
 }
+
+var _UiPath_config, _UiPath_authService, _UiPath_initialized;
 /**
- * Helper to get error details in a safe way
+ * UiPath - Core SDK class for authentication and configuration management.
+ *
+ * Handles authentication, configuration, and provides access to SDK internals
+ * for service instantiation in the modular pattern.
+ *
+ * @example
+ * ```typescript
+ * // Modular pattern
+ * import { UiPath } from '@uipath/uipath-typescript/core';
+ * import { Entities } from '@uipath/uipath-typescript/entities';
+ *
+ * const sdk = new UiPath({
+ *   baseUrl: 'https://cloud.uipath.com',
+ *   orgName: 'myorg',
+ *   tenantName: 'mytenant',
+ *   clientId: 'xxx',
+ *   redirectUri: 'http://localhost:3000/callback',
+ *   scope: 'OR.Users OR.Robots'
+ * });
+ *
+ * await sdk.initialize();
+ *
+ * const entitiesService = new Entities(sdk);
+ * const allEntities = await entitiesService.getAll();
+ * ```
  */
-function getErrorDetails(error) {
-    if (isUiPathError(error)) {
-        return {
-            message: error.message,
-            statusCode: error.statusCode
+class UiPath {
+    constructor(config) {
+        // Private fields - true runtime privacy, not visible via Object.keys()
+        _UiPath_config.set(this, void 0);
+        _UiPath_authService.set(this, void 0);
+        _UiPath_initialized.set(this, false);
+        // Validate and normalize the configuration
+        validateConfig(config);
+        const hasSecretAuth = hasSecretConfig(config);
+        const hasOAuthAuth = hasOAuthConfig(config);
+        // Initialize core components
+        const internalConfig = new UiPathConfig({
+            baseUrl: normalizeBaseUrl(config.baseUrl),
+            orgName: config.orgName,
+            tenantName: config.tenantName,
+            secret: hasSecretAuth ? config.secret : undefined,
+            clientId: hasOAuthAuth ? config.clientId : undefined,
+            redirectUri: hasOAuthAuth ? config.redirectUri : undefined,
+            scope: hasOAuthAuth ? config.scope : undefined
+        });
+        const executionContext = new ExecutionContext();
+        __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
+        __classPrivateFieldSet(this, _UiPath_config, internalConfig, "f");
+        // Store internals in SDKInternalsRegistry (not visible on instance)
+        SDKInternalsRegistry.set(this, {
+            config: internalConfig,
+            context: executionContext,
+            tokenManager: __classPrivateFieldGet(this, _UiPath_authService, "f").getTokenManager()
+        });
+        // Expose read-only config for user convenience
+        this.config = {
+            baseUrl: internalConfig.baseUrl,
+            orgName: internalConfig.orgName,
+            tenantName: internalConfig.tenantName
         };
+        // Initialize telemetry with SDK configuration
+        telemetryClient.initialize({
+            baseUrl: config.baseUrl,
+            orgName: config.orgName,
+            tenantName: config.tenantName,
+            clientId: hasOAuthAuth ? config.clientId : undefined,
+            redirectUri: hasOAuthAuth ? config.redirectUri : undefined
+        });
+        // Track SDK initialization
+        trackEvent('Sdk.Auth');
+        // Auto-initialize for secret-based auth
+        if (hasSecretAuth) {
+            __classPrivateFieldGet(this, _UiPath_authService, "f").authenticateWithSecret(config.secret);
+            __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
+        }
     }
-    if (error instanceof Error) {
-        return {
-            message: error.message
-        };
+    /**
+     * Initialize the SDK based on the provided configuration.
+     * This method handles both OAuth flow initiation and completion automatically.
+     * For secret-based authentication, initialization is automatic and this returns immediately.
+     */
+    async initialize() {
+        // For secret-based auth, it's already initialized in constructor
+        if (hasSecretConfig(__classPrivateFieldGet(this, _UiPath_config, "f"))) {
+            return;
+        }
+        try {
+            // Check for OAuth callback first
+            if (AuthService.isInOAuthCallback()) {
+                if (await this.completeOAuth()) {
+                    return;
+                }
+            }
+            // Check if already authenticated
+            if (this.isAuthenticated()) {
+                __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
+                return;
+            }
+            // Start new OAuth flow
+            await __classPrivateFieldGet(this, _UiPath_authService, "f").authenticate(__classPrivateFieldGet(this, _UiPath_config, "f"));
+            if (this.isAuthenticated()) {
+                __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+            throw new Error(`Failed to initialize UiPath SDK: ${errorMessage}`);
+        }
+    }
+    /**
+     * Check if the SDK has been initialized
+     */
+    isInitialized() {
+        return __classPrivateFieldGet(this, _UiPath_initialized, "f");
+    }
+    /**
+     * Check if we're in an OAuth callback state
+     */
+    isInOAuthCallback() {
+        return AuthService.isInOAuthCallback();
+    }
+    /**
+     * Complete OAuth authentication flow (only call if isInOAuthCallback() is true)
+     */
+    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();
+    }
+    /**
+     * 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();
 
 /**
  * Constants used throughout the pagination system
@@ -5240,8 +5375,16 @@ function getLimitedPageSize(pageSize) {
     return Math.max(1, Math.min(pageSize, MAX_PAGE_SIZE));
 }
 
+exports.APP_NAME = APP_NAME;
 exports.AuthenticationError = AuthenticationError;
 exports.AuthorizationError = AuthorizationError;
+exports.CLOUD_CLIENT_ID = CLOUD_CLIENT_ID;
+exports.CLOUD_ORGANIZATION_NAME = CLOUD_ORGANIZATION_NAME;
+exports.CLOUD_REDIRECT_URI = CLOUD_REDIRECT_URI;
+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.DEFAULT_ITEMS_FIELD = DEFAULT_ITEMS_FIELD;
 exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
 exports.DEFAULT_TOTAL_COUNT_FIELD = DEFAULT_TOTAL_COUNT_FIELD;
@@ -5251,9 +5394,16 @@ exports.MAX_PAGE_SIZE = MAX_PAGE_SIZE;
 exports.NetworkError = NetworkError;
 exports.NotFoundError = NotFoundError;
 exports.RateLimitError = RateLimitError;
+exports.SDK_LOGGER_NAME = SDK_LOGGER_NAME;
+exports.SDK_RUN_EVENT = SDK_RUN_EVENT;
+exports.SDK_SERVICE_NAME = SDK_SERVICE_NAME;
+exports.SDK_VERSION = SDK_VERSION;
+exports.SERVICE = SERVICE;
 exports.ServerError = ServerError;
+exports.UNKNOWN = UNKNOWN;
 exports.UiPath = UiPath;
 exports.UiPathError = UiPathError;
+exports.VERSION = VERSION;
 exports.ValidationError = ValidationError;
 exports.getErrorDetails = getErrorDetails;
 exports.getLimitedPageSize = getLimitedPageSize;
@@ -5265,3 +5415,6 @@ exports.isRateLimitError = isRateLimitError;
 exports.isServerError = isServerError;
 exports.isUiPathError = isUiPathError;
 exports.isValidationError = isValidationError;
+exports.telemetryClient = telemetryClient;
+exports.track = track;
+exports.trackEvent = trackEvent;