@aws/lsp-codewhisperer 0.0.28 → 0.0.29

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [0.0.29](https://github.com/aws/language-servers/compare/lsp-codewhisperer/v0.0.28...lsp-codewhisperer/v0.0.29) (2025-03-26)
+
+
+### Features
+
+* abort all inflight requests when resetCodewhispererService is invoked ([#848](https://github.com/aws/language-servers/issues/848)) ([681889b](https://github.com/aws/language-servers/commit/681889bd40a0fb84ea624f177b07ef579864303a))
+* added auth listener to reset the service manager state in case of bearer token signout ([#842](https://github.com/aws/language-servers/issues/842)) ([780be3f](https://github.com/aws/language-servers/commit/780be3fdb92917e58524472ea5967f405f802db5))
+* **amazonq:** accept extra context for Q Inline Suggestions ([4a508df](https://github.com/aws/language-servers/commit/4a508dfcba714301145089263bdce8b8f18ec03b))
+* **amazonq:** add eu-central-1 endpoint ([83133d6](https://github.com/aws/language-servers/commit/83133d61815c5acfba7ead1c87d0aaef206e72d4))
+* **amazonq:** add regionalization support to security scan server ([#859](https://github.com/aws/language-servers/issues/859)) ([9945398](https://github.com/aws/language-servers/commit/99453989934849eddf1029763c22208cdb13be74))
+* **amazonq:** add regionalization support to Telemetry service ([6937c7f](https://github.com/aws/language-servers/commit/6937c7fa53c94f23dab323d0cd92970edafd4452))
+* **amazonq:** add support for setting profile to null ([b02906d](https://github.com/aws/language-servers/commit/b02906d04fad42f09e32d44120c4dd32cb2a649c))
+* **amazonq:** attach profileArn to API calls when available ([00fe7e2](https://github.com/aws/language-servers/commit/00fe7e2d1327b519042480b8216d663a48dced54))
+* **amazonq:** Cancel inflight updateProfile requests ([#861](https://github.com/aws/language-servers/issues/861)) ([a4a4309](https://github.com/aws/language-servers/commit/a4a4309ef1f7c0978aa44a4063d1e8160ad53bb6))
+* **amazonq:** centralize access to Q Service SDK instance and add support for Q Developer profiles ([#814](https://github.com/aws/language-servers/issues/814)) ([5f11549](https://github.com/aws/language-servers/commit/5f11549bb37acf3788c991a4ceeb38a7b17f1324))
+* **amazonq:** integrate q service manager with configuration server ([#852](https://github.com/aws/language-servers/issues/852)) ([c0e3290](https://github.com/aws/language-servers/commit/c0e32905e5940a79f59b19913aac9f989e85f8fe))
+* **amazonq:** intergrate regionalization support into Q Chat server ([#853](https://github.com/aws/language-servers/issues/853)) ([394104c](https://github.com/aws/language-servers/commit/394104c3702055f55ababbbfb056bf7904f5115e))
+
+
+### Bug Fixes
+
+* **amazonq:** await for recordMetric in CodeDiff tracker ([ee04afc](https://github.com/aws/language-servers/commit/ee04afc7775e83bfa3868b4b661cf59ff3c7f949))
+* **amazonq:** handle exceptions in TelemetryService ([e8f6375](https://github.com/aws/language-servers/commit/e8f637524fe878c26c72f506de4abea86b481fde))
+* **amazonq:** specify code analysis scope and scan name when running scans ([#858](https://github.com/aws/language-servers/issues/858)) ([a925297](https://github.com/aws/language-servers/commit/a925297aabc89334f4f9eed6c13146f4fd20b164))
+* update @aws/language-server-runtimes to 0.2.48 ([e1f620a](https://github.com/aws/language-servers/commit/e1f620ac2b59b4f61daff842a9f29ded1b8fa04e))
+
 ## [0.0.28](https://github.com/aws/language-servers/compare/lsp-codewhisperer/v0.0.27...lsp-codewhisperer/v0.0.28) (2025-03-18)
 
 

package/README.md

@@ -91,3 +91,6 @@ const params: InitializeParams = {
   }
 }
 ```
+
+### Extra context for Q Inline Suggestions
+In cases when the client runs in a specific environment that requires customized suggestions, the server supports a `aws.q.inlineSuggestions.extraContext` workspace configuration. This extra context will be passed to the left file content of the request in the beginning of the file.

package/out/client/token/codewhisperer.d.ts

@@ -2,7 +2,7 @@ import { AWSError } from 'aws-sdk';
 import { ServiceConfigurationOptions } from 'aws-sdk/lib/service';
 import CodeWhispererClient = require('./codewhispererbearertokenclient');
 import { SDKInitializator } from '@aws/language-server-runtimes/server-interface';
-interface RequestExtras {
+export interface RequestExtras {
     readonly service: AWS.Service;
     readonly operation: string;
     readonly params?: any;

package/out/constants.d.ts

@@ -2,4 +2,7 @@ export declare const DEFAULT_AWS_Q_ENDPOINT_URL = "https://codewhisperer.us-east
 export declare const DEFAULT_AWS_Q_REGION = "us-east-1";
 export declare const AWS_Q_ENDPOINTS: {
     "us-east-1": string;
+    'eu-central-1': string;
 };
+export declare const AWS_Q_REGION_ENV_VAR = "AWS_Q_REGION";
+export declare const AWS_Q_ENDPOINT_URL_ENV_VAR = "AWS_Q_ENDPOINT_URL";

package/out/constants.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AWS_Q_ENDPOINTS = exports.DEFAULT_AWS_Q_REGION = exports.DEFAULT_AWS_Q_ENDPOINT_URL = void 0;
+exports.AWS_Q_ENDPOINT_URL_ENV_VAR = exports.AWS_Q_REGION_ENV_VAR = exports.AWS_Q_ENDPOINTS = exports.DEFAULT_AWS_Q_REGION = exports.DEFAULT_AWS_Q_ENDPOINT_URL = void 0;
 exports.DEFAULT_AWS_Q_ENDPOINT_URL = 'https://codewhisperer.us-east-1.amazonaws.com/';
 exports.DEFAULT_AWS_Q_REGION = 'us-east-1';
 exports.AWS_Q_ENDPOINTS = {
     [exports.DEFAULT_AWS_Q_REGION]: exports.DEFAULT_AWS_Q_ENDPOINT_URL,
+    'eu-central-1': 'https://q.eu-central-1.amazonaws.com/',
 };
+exports.AWS_Q_REGION_ENV_VAR = 'AWS_Q_REGION';
+exports.AWS_Q_ENDPOINT_URL_ENV_VAR = 'AWS_Q_ENDPOINT_URL';
 //# sourceMappingURL=constants.js.map

package/out/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,0BAA0B,GAAG,gDAAgD,CAAA;AAC7E,QAAA,oBAAoB,GAAG,WAAW,CAAA;AAElC,QAAA,eAAe,GAAG;IAC3B,CAAC,4BAAoB,CAAC,EAAE,kCAA0B;CACrD,CAAA"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,0BAA0B,GAAG,gDAAgD,CAAA;AAC7E,QAAA,oBAAoB,GAAG,WAAW,CAAA;AAElC,QAAA,eAAe,GAAG;IAC3B,CAAC,4BAAoB,CAAC,EAAE,kCAA0B;IAClD,cAAc,EAAE,uCAAuC;CAC1D,CAAA;AAEY,QAAA,oBAAoB,GAAG,cAAc,CAAA;AACrC,QAAA,0BAA0B,GAAG,oBAAoB,CAAA"}

package/out/language-server/amazonQServiceManager/AmazonQTokenServiceManager.d.ts

@@ -0,0 +1,90 @@
+import { Logging, Lsp, CredentialsProvider, SDKInitializator, Runtime, Workspace, SsoConnectionType } from '@aws/language-server-runtimes/server-interface';
+import { CodeWhispererServiceToken } from '../codeWhispererService';
+import { BaseAmazonQServiceManager } from './BaseAmazonQServiceManager';
+import { CodeWhispererStreaming } from '@amzn/codewhisperer-streaming';
+export interface Features {
+    lsp: Lsp;
+    logging: Logging;
+    runtime: Runtime;
+    credentialsProvider: CredentialsProvider;
+    sdkInitializator: SDKInitializator;
+    workspace: Workspace;
+}
+/**
+ * AmazonQTokenServiceManager manages state and provides centralized access to
+ * instance of CodeWhispererServiceToken SDK client to any consuming code.
+ * It ensures that CodeWhispererServiceToken is configured to always access correct regionalized Amazon Q Developer API endpoint.
+ * Regional endppoint is selected based on:
+ * 1) current SSO auth connection type (BuilderId or IDC).
+ * 2) selected Amazon Q Developer profile (only for IDC connection type).
+ *
+ * @states
+ * - PENDING_CONNECTION: Initial state when no bearer token is set
+ * - PENDING_Q_PROFILE: When using Identity Center and waiting for profile selection
+ * - PENDING_Q_PROFILE_UPDATE: During profile update operation
+ * - INITIALIZED: Service is ready to handle requests
+ *
+ * @connectionTypes
+ * - none: No active connection
+ * - builderId: Connected via Builder ID
+ * - identityCenter: Connected via Identity Center
+ *
+ * AmazonQTokenServiceManager is a singleton class, which must be instantiated with Language Server runtimes [Features](https://github.com/aws/language-server-runtimes/blob/21d5d1dc7c73499475b7c88c98d2ce760e5d26c8/runtimes/server-interface/server.ts#L31-L42)
+ * To get access to current CodeWhispererServiceToken client object, call `getCodewhispererService()` mathod:
+ *
+ * @example
+ * const AmazonQServiceManager = AmazonQTokenServiceManager.getInstance(features);
+ * const codewhispererService = AmazonQServiceManager.getCodewhispererService();
+ */
+export declare class AmazonQTokenServiceManager implements BaseAmazonQServiceManager {
+    private static instance;
+    private features;
+    private logging;
+    private cachedCodewhispererService?;
+    private enableDeveloperProfileSupport?;
+    private configurationCache;
+    private activeIdcProfile?;
+    private connectionType?;
+    private profileChangeTokenSource;
+    private region?;
+    private endpoint?;
+    /**
+     * Internal state of Service connection, based on status of bearer token and Amazon Q Developer profile selection.
+     * Supported states:
+     * PENDING_CONNECTION - Waiting for Bearer Token and StartURL to be passed
+     * PENDING_Q_PROFILE - (only for identityCenter connection) waiting for setting Developer Profile
+     * PENDING_Q_PROFILE_UPDATE (only for identityCenter connection) waiting for Developer Profile to complete
+     * INITIALIZED - Service is initialized
+     */
+    private state;
+    private constructor();
+    static getInstance(features: Features): AmazonQTokenServiceManager;
+    private initialize;
+    private setupAuthListener;
+    private setupConfigurationListeners;
+    /**
+     * Validate if Bearer Token Connection type has changed mid-session.
+     * When connection type change is detected: reinitialize CodeWhispererService class with current connection type.
+     */
+    private handleSsoConnectionChange;
+    handleDidChangeConfiguration(): Promise<void>;
+    private cancelActiveProfileChangeToken;
+    private handleTokenCancellationRequest;
+    private handleProfileChange;
+    getCodewhispererService(): CodeWhispererServiceToken;
+    getStreamingClient(): CodeWhispererStreaming;
+    private resetCodewhispererService;
+    private createCodewhispererServiceInstances;
+    private getCustomUserAgent;
+    private serviceFactory;
+    private streamingClientFactory;
+    private log;
+    private logServiceState;
+    static resetInstance(): void;
+    getState(): "PENDING_CONNECTION" | "PENDING_Q_PROFILE" | "PENDING_Q_PROFILE_UPDATE" | "INITIALIZED";
+    getConnectionType(): SsoConnectionType | undefined;
+    getActiveProfileArn(): string | undefined;
+    setServiceFactory(factory: (region: string, endpoint: string) => CodeWhispererServiceToken): void;
+    getServiceFactory(): (region: string, endpoint: string) => CodeWhispererServiceToken;
+    getEnableDeveloperProfileSupport(): boolean;
+}

package/out/language-server/amazonQServiceManager/AmazonQTokenServiceManager.js

@@ -0,0 +1,466 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmazonQTokenServiceManager = void 0;
+const server_interface_1 = require("@aws/language-server-runtimes/server-interface");
+const constants_1 = require("../../constants");
+const codeWhispererService_1 = require("../codeWhispererService");
+const errors_1 = require("./errors");
+const qConfigurationServer_1 = require("../configuration/qConfigurationServer");
+const lsp_core_1 = require("@aws/lsp-core");
+const codewhisperer_streaming_1 = require("@amzn/codewhisperer-streaming");
+const util_retry_1 = require("@aws-sdk/util-retry");
+const qDeveloperProfiles_1 = require("./qDeveloperProfiles");
+const telemetryUtils_1 = require("../utilities/telemetryUtils");
+const utils_1 = require("../utils");
+/**
+ * AmazonQTokenServiceManager manages state and provides centralized access to
+ * instance of CodeWhispererServiceToken SDK client to any consuming code.
+ * It ensures that CodeWhispererServiceToken is configured to always access correct regionalized Amazon Q Developer API endpoint.
+ * Regional endppoint is selected based on:
+ * 1) current SSO auth connection type (BuilderId or IDC).
+ * 2) selected Amazon Q Developer profile (only for IDC connection type).
+ *
+ * @states
+ * - PENDING_CONNECTION: Initial state when no bearer token is set
+ * - PENDING_Q_PROFILE: When using Identity Center and waiting for profile selection
+ * - PENDING_Q_PROFILE_UPDATE: During profile update operation
+ * - INITIALIZED: Service is ready to handle requests
+ *
+ * @connectionTypes
+ * - none: No active connection
+ * - builderId: Connected via Builder ID
+ * - identityCenter: Connected via Identity Center
+ *
+ * AmazonQTokenServiceManager is a singleton class, which must be instantiated with Language Server runtimes [Features](https://github.com/aws/language-server-runtimes/blob/21d5d1dc7c73499475b7c88c98d2ce760e5d26c8/runtimes/server-interface/server.ts#L31-L42)
+ * To get access to current CodeWhispererServiceToken client object, call `getCodewhispererService()` mathod:
+ *
+ * @example
+ * const AmazonQServiceManager = AmazonQTokenServiceManager.getInstance(features);
+ * const codewhispererService = AmazonQServiceManager.getCodewhispererService();
+ */
+class AmazonQTokenServiceManager {
+    static instance = null;
+    features;
+    logging;
+    cachedCodewhispererService;
+    enableDeveloperProfileSupport;
+    configurationCache = new Map();
+    activeIdcProfile;
+    connectionType;
+    profileChangeTokenSource;
+    region;
+    endpoint;
+    /**
+     * Internal state of Service connection, based on status of bearer token and Amazon Q Developer profile selection.
+     * Supported states:
+     * PENDING_CONNECTION - Waiting for Bearer Token and StartURL to be passed
+     * PENDING_Q_PROFILE - (only for identityCenter connection) waiting for setting Developer Profile
+     * PENDING_Q_PROFILE_UPDATE (only for identityCenter connection) waiting for Developer Profile to complete
+     * INITIALIZED - Service is initialized
+     */
+    state = 'PENDING_CONNECTION';
+    constructor() { }
+    static getInstance(features) {
+        if (!AmazonQTokenServiceManager.instance) {
+            AmazonQTokenServiceManager.instance = new AmazonQTokenServiceManager();
+            AmazonQTokenServiceManager.instance.initialize(features);
+        }
+        return AmazonQTokenServiceManager.instance;
+    }
+    initialize(features) {
+        if (!features || !features.logging || !features.lsp) {
+            throw new errors_1.AmazonQServiceInitializationError('Service features not initialized. Please ensure proper initialization.');
+        }
+        this.features = features;
+        this.logging = features.logging;
+        if (!this.features.lsp.getClientInitializeParams()) {
+            this.log('AmazonQTokenServiceManager initialized before LSP connection was initialized.');
+            throw new errors_1.AmazonQServiceInitializationError('AmazonQTokenServiceManager initialized before LSP connection was initialized.');
+        }
+        // Bind methods that are passed by reference to some handlers to maintain proper scope.
+        this.serviceFactory = this.serviceFactory.bind(this);
+        this.handleDidChangeConfiguration = this.handleDidChangeConfiguration.bind(this);
+        this.log('Reading enableDeveloperProfileSupport setting from AWSInitializationOptions');
+        if (this.features.lsp.getClientInitializeParams()?.initializationOptions?.aws) {
+            const awsOptions = this.features.lsp.getClientInitializeParams()?.initializationOptions?.aws || {};
+            this.enableDeveloperProfileSupport = (0, qDeveloperProfiles_1.signalsAWSQDeveloperProfilesEnabled)(awsOptions);
+            this.log(`Enabled Q Developer Profile support: ${this.enableDeveloperProfileSupport}`);
+        }
+        this.connectionType = 'none';
+        this.state = 'PENDING_CONNECTION';
+        this.setupAuthListener();
+        this.setupConfigurationListeners();
+        this.log('Manager instance is initialize');
+    }
+    setupAuthListener() {
+        this.features.credentialsProvider.onCredentialsDeleted((type) => {
+            this.log(`Received credentials delete event for type: ${type}`);
+            if (type === 'iam') {
+                return;
+            }
+            this.cancelActiveProfileChangeToken();
+            this.resetCodewhispererService();
+            this.connectionType = 'none';
+            this.state = 'PENDING_CONNECTION';
+        });
+    }
+    setupConfigurationListeners() {
+        // TODO: refactor how handleDidChangeConfiguration can be hooked to lsp Feature.
+        // Currently can't do this, as it overrides handler set by Server, using ServiceManager.
+        // this.features.lsp.onInitialized(this.handleDidChangeConfiguration)
+        // this.features.lsp.didChangeConfiguration(this.handleDidChangeConfiguration)
+        this.features.lsp.workspace.onUpdateConfiguration(async (params, _token) => {
+            try {
+                if (params.section === qConfigurationServer_1.Q_CONFIGURATION_SECTION && params.settings.profileArn !== undefined) {
+                    const profileArn = params.settings.profileArn;
+                    if (!(0, utils_1.isStringOrNull)(profileArn)) {
+                        throw new Error('Expected params.settings.profileArn to be of either type string or null');
+                    }
+                    this.log(`Profile update is requested for profile ${profileArn}`);
+                    this.cancelActiveProfileChangeToken();
+                    this.profileChangeTokenSource = new server_interface_1.CancellationTokenSource();
+                    await this.handleProfileChange(profileArn, this.profileChangeTokenSource.token);
+                }
+            }
+            catch (error) {
+                this.log('Error updating profiles: ' + error);
+                if (error instanceof errors_1.AmazonQServiceProfileUpdateCancelled) {
+                    throw new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.ServerCancelled, error.message, {
+                        awsErrorCode: error.code,
+                    });
+                }
+                if (error instanceof errors_1.AmazonQError) {
+                    throw new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, error.message, {
+                        awsErrorCode: error.code,
+                    });
+                }
+                throw new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, 'Failed to update configuration');
+            }
+            finally {
+                if (this.profileChangeTokenSource) {
+                    this.profileChangeTokenSource.dispose();
+                    this.profileChangeTokenSource = undefined;
+                }
+            }
+        });
+    }
+    /**
+     * Validate if Bearer Token Connection type has changed mid-session.
+     * When connection type change is detected: reinitialize CodeWhispererService class with current connection type.
+     */
+    handleSsoConnectionChange() {
+        const newConnectionType = this.features.credentialsProvider.getConnectionType();
+        this.logServiceState('Validate State of SSO Connection');
+        if (newConnectionType === 'none' || !this.features.credentialsProvider.hasCredentials('bearer')) {
+            // Connection was reset, wait for SSO connection token from client
+            this.log('No active SSO connection is detected, resetting the client');
+            this.resetCodewhispererService();
+            this.connectionType = 'none';
+            this.state = 'PENDING_CONNECTION';
+            return;
+        }
+        // Connection type hasn't change.
+        if (newConnectionType === this.connectionType) {
+            this.log('Connection type did not change.');
+            return;
+        }
+        // Connection type changed to 'builderId'
+        if (newConnectionType === 'builderId') {
+            this.log('Detected New connection type: builderId');
+            this.resetCodewhispererService();
+            // For the builderId connection type regional endpoint discovery chain is:
+            // region set by client -> runtime region -> default region
+            const clientParams = this.features.lsp.getClientInitializeParams();
+            this.createCodewhispererServiceInstances('builderId', clientParams?.initializationOptions?.aws?.region);
+            this.state = 'INITIALIZED';
+            this.log('Initialized Amazon Q service with builderId connection');
+            return;
+        }
+        // Connection type changed to 'identityCenter'
+        if (newConnectionType === 'identityCenter') {
+            this.log('Detected New connection type: identityCenter');
+            this.resetCodewhispererService();
+            if (this.enableDeveloperProfileSupport) {
+                this.connectionType = 'identityCenter';
+                this.state = 'PENDING_Q_PROFILE';
+                this.logServiceState('Pending profile selection for IDC connection');
+                return;
+            }
+            this.createCodewhispererServiceInstances('identityCenter');
+            this.state = 'INITIALIZED';
+            this.log('Initialized Amazon Q service with identityCenter connection');
+            return;
+        }
+        this.logServiceState('Unknown Connection state');
+    }
+    async handleDidChangeConfiguration() {
+        try {
+            const qConfig = await this.features.lsp.workspace.getConfiguration(qConfigurationServer_1.Q_CONFIGURATION_SECTION);
+            if (qConfig) {
+                // aws.q.customizationArn - selected customization
+                const customizationArn = lsp_core_1.textUtils.undefinedIfEmpty(qConfig.customization);
+                this.log(`Read configuration customizationArn=${customizationArn}`);
+                this.configurationCache.set('customizationArn', customizationArn);
+                // aws.q.optOutTelemetry - telemetry optout option
+                const optOutTelemetryPreference = qConfig['optOutTelemetry'] === true ? 'OPTOUT' : 'OPTIN';
+                this.log(`Read configuration optOutTelemetryPreference=${optOutTelemetryPreference}`);
+                this.configurationCache.set('optOutTelemetryPreference', optOutTelemetryPreference);
+                if (this.cachedCodewhispererService) {
+                    this.log(`Using customization=${customizationArn}`);
+                    this.cachedCodewhispererService.customizationArn = customizationArn;
+                }
+            }
+            const codeWhispererConfig = await this.features.lsp.workspace.getConfiguration('aws.codeWhisperer');
+            if (codeWhispererConfig) {
+                // aws.codeWhisperer.includeSuggestionsWithCodeReferences - return suggestions with code references
+                const includeSuggestionsWithCodeReferences = codeWhispererConfig['includeSuggestionsWithCodeReferences'] === true;
+                this.log(`Read сonfiguration includeSuggestionsWithCodeReferences=${includeSuggestionsWithCodeReferences}`);
+                this.configurationCache.set('includeSuggestionsWithCodeReferences', includeSuggestionsWithCodeReferences);
+                // aws.codeWhisperershareCodeWhispererContentWithAWS - share content with AWS
+                const shareCodeWhispererContentWithAWS = codeWhispererConfig['shareCodeWhispererContentWithAWS'] === true;
+                this.log(`Read configuration shareCodeWhispererContentWithAWS=${shareCodeWhispererContentWithAWS}`);
+                this.configurationCache.set('shareCodeWhispererContentWithAWS', shareCodeWhispererContentWithAWS);
+                if (this.cachedCodewhispererService) {
+                    this.log('Update shareCodeWhispererContentWithAWS setting on cachedCodewhispererService to ' +
+                        shareCodeWhispererContentWithAWS);
+                    this.cachedCodewhispererService.shareCodeWhispererContentWithAWS = shareCodeWhispererContentWithAWS;
+                }
+            }
+        }
+        catch (error) {
+            this.log(`Error in GetConfiguration: ${error}`);
+        }
+    }
+    cancelActiveProfileChangeToken() {
+        this.profileChangeTokenSource?.cancel();
+        this.profileChangeTokenSource?.dispose();
+        this.profileChangeTokenSource = undefined;
+    }
+    handleTokenCancellationRequest(token) {
+        if (token.isCancellationRequested) {
+            this.logServiceState('Handling CancellationToken cancellation request');
+            throw new errors_1.AmazonQServiceProfileUpdateCancelled('Requested profile update got cancelled');
+        }
+    }
+    async handleProfileChange(newProfileArn, token) {
+        if (!this.enableDeveloperProfileSupport) {
+            this.log('Developer Profiles Support is not enabled');
+            return;
+        }
+        if (typeof newProfileArn === 'string' && newProfileArn.length === 0) {
+            throw new Error('Received invalid Profile ARN (empty string)');
+        }
+        this.logServiceState('UpdateProfile is requested');
+        // Test if connection type changed
+        this.handleSsoConnectionChange();
+        if (this.connectionType === 'none') {
+            throw new errors_1.AmazonQServicePendingSigninError();
+        }
+        if (this.connectionType !== 'identityCenter') {
+            this.logServiceState('Q Profile can not be set');
+            throw new errors_1.AmazonQServiceNoProfileSupportError(`Connection type ${this.connectionType} does not support Developer Profiles feature.`);
+        }
+        if ((this.state === 'INITIALIZED' && this.activeIdcProfile) || this.state === 'PENDING_Q_PROFILE') {
+            // Change status to pending to prevent API calls until profile is updated.
+            // Because `listAvailableProfiles` below can take few seconds to complete,
+            // there is possibility that client could send requests while profile is changing.
+            this.state = 'PENDING_Q_PROFILE_UPDATE';
+        }
+        // Client sent an explicit null, indicating they want to reset the assigned profile (if any)
+        if (newProfileArn === null) {
+            this.logServiceState('Received null profile, resetting to PENDING_Q_PROFILE state');
+            this.resetCodewhispererService();
+            this.state = 'PENDING_Q_PROFILE';
+            return;
+        }
+        const profiles = await (0, qDeveloperProfiles_1.getListAllAvailableProfilesHandler)(this.serviceFactory)({
+            connectionType: 'identityCenter',
+            logging: this.logging,
+        });
+        this.handleTokenCancellationRequest(token);
+        const newProfile = profiles.find(el => el.arn === newProfileArn);
+        if (!newProfile || !newProfile.identityDetails?.region) {
+            this.log(`Amazon Q Profile ${newProfileArn} is not valid`);
+            this.resetCodewhispererService();
+            this.state = 'PENDING_Q_PROFILE';
+            throw new errors_1.AmazonQServiceInvalidProfileError('Requested Amazon Q Profile does not exist');
+        }
+        this.handleTokenCancellationRequest(token);
+        if (!this.activeIdcProfile) {
+            this.activeIdcProfile = newProfile;
+            this.createCodewhispererServiceInstances('identityCenter', newProfile.identityDetails.region);
+            this.state = 'INITIALIZED';
+            this.log(`Initialized identityCenter connection to region ${newProfile.identityDetails.region} for profile ${newProfile.arn}`);
+            return;
+        }
+        // Profile didn't change
+        if (this.activeIdcProfile && this.activeIdcProfile.arn === newProfile.arn) {
+            // Update cached profile fields, keep existing client
+            this.log(`Profile selection did not change, active profile is ${this.activeIdcProfile.arn}`);
+            this.activeIdcProfile = newProfile;
+            this.state = 'INITIALIZED';
+            return;
+        }
+        this.handleTokenCancellationRequest(token);
+        // At this point new valid profile is selected.
+        const oldRegion = this.activeIdcProfile.identityDetails?.region;
+        const newRegion = newProfile.identityDetails.region;
+        if (oldRegion === newRegion) {
+            this.log(`New profile is in the same region as old one, keeping exising service.`);
+            this.log(`New active profile is ${this.activeIdcProfile.arn}, region ${oldRegion}`);
+            this.activeIdcProfile = newProfile;
+            this.state = 'INITIALIZED';
+            if (this.cachedCodewhispererService) {
+                this.cachedCodewhispererService.profileArn = newProfile.arn;
+            }
+            return;
+        }
+        this.log(`Switching service client region from ${oldRegion} to ${newRegion}`);
+        this.handleTokenCancellationRequest(token);
+        // Selected new profile is in different region. Re-initialize service
+        this.resetCodewhispererService();
+        this.activeIdcProfile = newProfile;
+        this.createCodewhispererServiceInstances('identityCenter', newProfile.identityDetails.region);
+        this.state = 'INITIALIZED';
+        return;
+    }
+    getCodewhispererService() {
+        // Prevent initiating requests while profile change is in progress.
+        if (this.state === 'PENDING_Q_PROFILE_UPDATE') {
+            throw new errors_1.AmazonQServicePendingProfileUpdateError();
+        }
+        this.handleSsoConnectionChange();
+        if (this.state === 'INITIALIZED' && this.cachedCodewhispererService) {
+            return this.cachedCodewhispererService;
+        }
+        if (this.state === 'PENDING_CONNECTION') {
+            throw new errors_1.AmazonQServicePendingSigninError();
+        }
+        if (this.state === 'PENDING_Q_PROFILE') {
+            throw new errors_1.AmazonQServicePendingProfileError();
+        }
+        throw new errors_1.AmazonQServiceNotInitializedError();
+    }
+    getStreamingClient() {
+        this.log('Getting instance of CodeWhispererStreaming client');
+        // Trigger checks in token service
+        const tokenService = this.getCodewhispererService();
+        if (!tokenService || !this.region || !this.endpoint) {
+            throw new errors_1.AmazonQServiceNotInitializedError();
+        }
+        return this.streamingClientFactory(this.region, this.endpoint);
+    }
+    resetCodewhispererService() {
+        this.cachedCodewhispererService?.abortInflightRequests();
+        this.cachedCodewhispererService = undefined;
+        this.activeIdcProfile = undefined;
+    }
+    createCodewhispererServiceInstances(connectionType, region) {
+        this.logServiceState('Initializing CodewhispererService');
+        let awsQRegion;
+        let awsQEndpoint;
+        if (region) {
+            this.log(`Selecting region (found: ${region}) provided by ${connectionType === 'builderId' ? 'client' : 'profile'}`);
+            awsQRegion = region;
+            // @ts-ignore
+            awsQEndpoint = constants_1.AWS_Q_ENDPOINTS[awsQRegion];
+        }
+        else {
+            const runtimeRegion = this.features.runtime.getConfiguration(constants_1.AWS_Q_REGION_ENV_VAR);
+            if (runtimeRegion) {
+                this.log(`Selecting region (found: ${runtimeRegion}) provided by runtime`);
+                awsQRegion = runtimeRegion;
+                // prettier-ignore
+                awsQEndpoint = // @ts-ignore
+                    this.features.runtime.getConfiguration(constants_1.AWS_Q_ENDPOINT_URL_ENV_VAR) ?? constants_1.AWS_Q_ENDPOINTS[awsQRegion];
+            }
+            else {
+                this.log('Region not provided by caller or runtime, falling back to default region and endpoint');
+                awsQRegion = constants_1.DEFAULT_AWS_Q_REGION;
+                awsQEndpoint = constants_1.DEFAULT_AWS_Q_ENDPOINT_URL;
+            }
+        }
+        if (!awsQEndpoint) {
+            this.log(`Unable to determine endpoint (found: ${awsQEndpoint}) for region: ${awsQRegion}, falling back to default region and endpoint`);
+            awsQRegion = constants_1.DEFAULT_AWS_Q_REGION;
+            awsQEndpoint = constants_1.DEFAULT_AWS_Q_ENDPOINT_URL;
+        }
+        // Cache active region and endpoint selection
+        this.connectionType = connectionType;
+        this.region = awsQRegion;
+        this.endpoint = awsQEndpoint;
+        this.cachedCodewhispererService = this.serviceFactory(awsQRegion, awsQEndpoint);
+        this.log(`CodeWhispererToken service for connection type ${connectionType} was initialized, region=${awsQRegion}`);
+        this.logServiceState('CodewhispererService Initialization finished');
+    }
+    getCustomUserAgent() {
+        const initializeParams = this.features.lsp.getClientInitializeParams() || {};
+        return (0, telemetryUtils_1.getUserAgent)(initializeParams, this.features.runtime.serverInfo);
+    }
+    serviceFactory(region, endpoint) {
+        const service = new codeWhispererService_1.CodeWhispererServiceToken(this.features.credentialsProvider, this.features.workspace, region, endpoint, this.features.sdkInitializator);
+        const customUserAgent = this.getCustomUserAgent();
+        service.updateClientConfig({
+            customUserAgent: customUserAgent,
+        });
+        service.customizationArn = lsp_core_1.textUtils.undefinedIfEmpty(this.configurationCache.get('customizationArn'));
+        service.profileArn = this.activeIdcProfile?.arn;
+        service.shareCodeWhispererContentWithAWS =
+            this.configurationCache.get('shareCodeWhispererContentWithAWS') === true;
+        this.log('Configured CodeWhispererServiceToken instance settings:');
+        this.log(`customUserAgent=${customUserAgent}, customizationArn=${service.customizationArn}, shareCodeWhispererContentWithAWS=${service.shareCodeWhispererContentWithAWS}`);
+        return service;
+    }
+    streamingClientFactory(region, endpoint) {
+        const token = (0, utils_1.getBearerTokenFromProvider)(this.features.credentialsProvider);
+        // TODO: Follow-up with creating CodeWhispererStreaming client which supports inplace access to CredentialsProvider instead of caching static value.
+        // Without this, we need more complex mechanism for managing token change state when caching streaming client.
+        const streamingClient = this.features.sdkInitializator(codewhisperer_streaming_1.CodeWhispererStreaming, {
+            region,
+            endpoint,
+            token: { token: token },
+            retryStrategy: new util_retry_1.ConfiguredRetryStrategy(0, (attempt) => 500 + attempt ** 10),
+            customUserAgent: this.getCustomUserAgent(),
+        });
+        this.logging.debug(`Created streaming client instance region=${region}, endpoint=${endpoint}`);
+        return streamingClient;
+    }
+    log(message) {
+        const prefix = 'Amazon Q Token Service Manager';
+        this.logging?.log(`${prefix}: ${message}`);
+    }
+    logServiceState(context) {
+        this.logging?.debug(JSON.stringify({
+            context,
+            state: {
+                serviceStatus: this.state,
+                connectionType: this.connectionType,
+                activeIdcProfile: this.activeIdcProfile,
+            },
+        }));
+    }
+    // For Unit Tests
+    static resetInstance() {
+        AmazonQTokenServiceManager.instance = null;
+    }
+    getState() {
+        return this.state;
+    }
+    getConnectionType() {
+        return this.connectionType;
+    }
+    getActiveProfileArn() {
+        return this.activeIdcProfile?.arn;
+    }
+    setServiceFactory(factory) {
+        this.serviceFactory = factory.bind(this);
+    }
+    getServiceFactory() {
+        return this.serviceFactory;
+    }
+    getEnableDeveloperProfileSupport() {
+        return this.enableDeveloperProfileSupport === undefined ? false : this.enableDeveloperProfileSupport;
+    }
+}
+exports.AmazonQTokenServiceManager = AmazonQTokenServiceManager;
+//# sourceMappingURL=AmazonQTokenServiceManager.js.map