diff --git a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.test.ts b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.test.ts
index 64c2efa168..104fd729f3 100644
--- a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.test.ts
+++ b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.test.ts
@@ -7,9 +7,10 @@ import { CredentialsType } from '@aws/language-server-runtimes/server-interface'
 import { AWSError, ConfigurationOptions } from 'aws-sdk'
 import * as sinon from 'sinon'
 import * as assert from 'assert'
-import { CodeWhispererServiceBase, GenerateSuggestionsResponse } from './codeWhispererServiceBase'
 import { PromiseResult } from 'aws-sdk/lib/request'
 import {
+    CodeWhispererServiceBase,
+    GenerateSuggestionsResponse,
     CreateUploadUrlRequest,
     CreateUploadUrlResponse,
     StartTransformationRequest,
@@ -39,7 +40,9 @@ import {
     DeleteWorkspaceResponse,
     ListFeatureEvaluationsRequest,
     ListFeatureEvaluationsResponse,
-} from '../../client/token/codewhispererbearertokenclient'
+    CreateSubscriptionTokenRequest,
+    CreateSubscriptionTokenResponse,
+} from './codeWhispererServiceBase'
 
 describe('CodeWhispererServiceBase', function () {
     // Create the environment
@@ -81,6 +84,90 @@ describe('CodeWhispererServiceBase', function () {
             }
 
             clearCachedSuggestions(): void {}
+
+            override codeModernizerCreateUploadUrl(request: CreateUploadUrlRequest): Promise<CreateUploadUrlResponse> {
+                throw new Error('Method not implemented.')
+            }
+            override codeModernizerStartCodeTransformation(
+                request: StartTransformationRequest
+            ): Promise<PromiseResult<StartTransformationResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override codeModernizerStopCodeTransformation(
+                request: StopTransformationRequest
+            ): Promise<PromiseResult<StopTransformationResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override codeModernizerGetCodeTransformation(
+                request: GetTransformationRequest
+            ): Promise<PromiseResult<GetTransformationResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override codeModernizerGetCodeTransformationPlan(
+                request: GetTransformationPlanRequest
+            ): Promise<PromiseResult<GetTransformationPlanResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override createUploadUrl(
+                request: CreateUploadUrlRequest
+            ): Promise<PromiseResult<CreateUploadUrlResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override startCodeAnalysis(
+                request: StartCodeAnalysisRequest
+            ): Promise<PromiseResult<StartCodeAnalysisResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override getCodeAnalysis(
+                request: GetCodeAnalysisRequest
+            ): Promise<PromiseResult<GetCodeAnalysisResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override listCodeAnalysisFindings(
+                request: ListCodeAnalysisFindingsRequest
+            ): Promise<PromiseResult<ListCodeAnalysisFindingsResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override listAvailableCustomizations(
+                request: ListAvailableCustomizationsRequest
+            ): Promise<PromiseResult<ListAvailableCustomizationsResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override listAvailableProfiles(
+                request: ListAvailableProfilesRequest
+            ): Promise<PromiseResult<ListAvailableProfilesRequest, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override sendTelemetryEvent(
+                request: SendTelemetryEventRequest
+            ): Promise<PromiseResult<SendTelemetryEventResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override createWorkspace(
+                request: CreateWorkspaceRequest
+            ): Promise<PromiseResult<CreateWorkspaceResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override listWorkspaceMetadata(
+                request: ListWorkspaceMetadataRequest
+            ): Promise<PromiseResult<ListWorkspaceMetadataResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override deleteWorkspace(
+                request: DeleteWorkspaceRequest
+            ): Promise<PromiseResult<DeleteWorkspaceResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override listFeatureEvaluations(
+                request: ListFeatureEvaluationsRequest
+            ): Promise<PromiseResult<ListFeatureEvaluationsResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
+            override createSubscriptionToken(
+                request: CreateSubscriptionTokenRequest
+            ): Promise<PromiseResult<CreateSubscriptionTokenResponse, AWSError>> {
+                throw new Error('Method not implemented.')
+            }
         }
 
         service = new TestCodeWhispererService('us-east-1', 'https://codewhisperer.us-east-1.amazonaws.com')
diff --git a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.ts b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.ts
index 7c8d5b200a..f5ac56c87b 100644
--- a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.ts
+++ b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceBase.ts
@@ -35,6 +35,57 @@ export interface GenerateSuggestionsResponse {
     responseContext: ResponseContext
 }
 
+// TODO: CodeWhispererSigv4Client requests and responses do not exist yet and should be added in the future
+export interface CreateUploadUrlRequest extends CodeWhispererTokenClient.CreateUploadUrlRequest {}
+export interface CreateUploadUrlResponse extends CodeWhispererTokenClient.CreateUploadUrlResponse {}
+
+export interface StartTransformationRequest extends CodeWhispererTokenClient.StartTransformationRequest {}
+export interface StartTransformationResponse extends CodeWhispererTokenClient.StartTransformationResponse {}
+
+export interface StopTransformationRequest extends CodeWhispererTokenClient.StopTransformationRequest {}
+export interface StopTransformationResponse extends CodeWhispererTokenClient.StopTransformationResponse {}
+
+export interface GetTransformationRequest extends CodeWhispererTokenClient.GetTransformationRequest {}
+export interface GetTransformationResponse extends CodeWhispererTokenClient.GetTransformationResponse {}
+
+export interface GetTransformationPlanRequest extends CodeWhispererTokenClient.GetTransformationPlanRequest {}
+export interface GetTransformationPlanResponse extends CodeWhispererTokenClient.GetTransformationPlanResponse {}
+
+export interface StartCodeAnalysisRequest extends CodeWhispererTokenClient.StartCodeAnalysisRequest {}
+export interface StartCodeAnalysisResponse extends CodeWhispererTokenClient.StartCodeAnalysisResponse {}
+
+export interface GetCodeAnalysisRequest extends CodeWhispererTokenClient.GetCodeAnalysisRequest {}
+export interface GetCodeAnalysisResponse extends CodeWhispererTokenClient.GetCodeAnalysisResponse {}
+
+export interface ListCodeAnalysisFindingsRequest extends CodeWhispererTokenClient.ListCodeAnalysisFindingsRequest {}
+export interface ListCodeAnalysisFindingsResponse extends CodeWhispererTokenClient.ListCodeAnalysisFindingsResponse {}
+
+export interface ListAvailableCustomizationsRequest
+    extends CodeWhispererTokenClient.ListAvailableCustomizationsRequest {}
+export interface ListAvailableCustomizationsResponse
+    extends CodeWhispererTokenClient.ListAvailableCustomizationsResponse {}
+
+export interface ListAvailableProfilesRequest extends CodeWhispererTokenClient.ListAvailableProfilesRequest {}
+export interface ListAvailableProfilesResponse extends CodeWhispererTokenClient.ListAvailableProfilesResponse {}
+
+export interface SendTelemetryEventRequest extends CodeWhispererTokenClient.SendTelemetryEventRequest {}
+export interface SendTelemetryEventResponse extends CodeWhispererTokenClient.SendTelemetryEventResponse {}
+
+export interface CreateWorkspaceRequest extends CodeWhispererTokenClient.CreateWorkspaceRequest {}
+export interface CreateWorkspaceResponse extends CodeWhispererTokenClient.CreateWorkspaceResponse {}
+
+export interface ListWorkspaceMetadataRequest extends CodeWhispererTokenClient.ListWorkspaceMetadataRequest {}
+export interface ListWorkspaceMetadataResponse extends CodeWhispererTokenClient.ListWorkspaceMetadataResponse {}
+
+export interface DeleteWorkspaceRequest extends CodeWhispererTokenClient.DeleteWorkspaceRequest {}
+export interface DeleteWorkspaceResponse extends CodeWhispererTokenClient.DeleteWorkspaceResponse {}
+
+export interface ListFeatureEvaluationsRequest extends CodeWhispererTokenClient.ListFeatureEvaluationsRequest {}
+export interface ListFeatureEvaluationsResponse extends CodeWhispererTokenClient.ListFeatureEvaluationsResponse {}
+
+export interface CreateSubscriptionTokenRequest extends CodeWhispererTokenClient.CreateSubscriptionTokenRequest {}
+export interface CreateSubscriptionTokenResponse extends CodeWhispererTokenClient.CreateSubscriptionTokenResponse {}
+
 type CodeWhispererClient = CodeWhispererSigv4Client | CodeWhispererTokenClient
 
 // Right now the only difference between the token client and the IAM client for codewhsiperer is the difference in function name
@@ -45,7 +96,7 @@ export abstract class CodeWhispererServiceBase {
     public shareCodeWhispererContentWithAWS = false
     public customizationArn?: string
     public profileArn?: string
-    abstract client: CodeWhispererSigv4Client | CodeWhispererTokenClient
+    abstract client: CodeWhispererClient
 
     inflightRequests: Set<AWS.Request<any, AWSError> & RequestExtras> = new Set()
 
@@ -64,10 +115,6 @@ export abstract class CodeWhispererServiceBase {
         this.inflightRequests.delete(request)
     }
 
-    abstract getCredentialsType(): CredentialsType
-
-    abstract generateSuggestions(request: GenerateSuggestionsRequest): Promise<GenerateSuggestionsResponse>
-
     constructor(codeWhispererRegion: string, codeWhispererEndpoint: string) {
         this.codeWhispererRegion = codeWhispererRegion
         this.codeWhispererEndpoint = codeWhispererEndpoint
@@ -95,4 +142,64 @@ export abstract class CodeWhispererServiceBase {
         // No-op: base class doesn't support subscription polling
         return false
     }
+
+    abstract getCredentialsType(): CredentialsType
+
+    abstract generateSuggestions(request: GenerateSuggestionsRequest): Promise<GenerateSuggestionsResponse>
+
+    abstract codeModernizerCreateUploadUrl(request: CreateUploadUrlRequest): Promise<CreateUploadUrlResponse>
+
+    abstract codeModernizerStartCodeTransformation(
+        request: StartTransformationRequest
+    ): Promise<PromiseResult<StartTransformationResponse, AWSError>>
+
+    abstract codeModernizerStopCodeTransformation(
+        request: StopTransformationRequest
+    ): Promise<PromiseResult<StopTransformationResponse, AWSError>>
+
+    abstract codeModernizerGetCodeTransformation(
+        request: GetTransformationRequest
+    ): Promise<PromiseResult<GetTransformationResponse, AWSError>>
+
+    abstract codeModernizerGetCodeTransformationPlan(
+        request: GetTransformationPlanRequest
+    ): Promise<PromiseResult<GetTransformationPlanResponse, AWSError>>
+
+    abstract createUploadUrl(request: CreateUploadUrlRequest): Promise<PromiseResult<CreateUploadUrlResponse, AWSError>>
+
+    abstract startCodeAnalysis(
+        request: StartCodeAnalysisRequest
+    ): Promise<PromiseResult<StartCodeAnalysisResponse, AWSError>>
+
+    abstract getCodeAnalysis(request: GetCodeAnalysisRequest): Promise<PromiseResult<GetCodeAnalysisResponse, AWSError>>
+
+    abstract listCodeAnalysisFindings(
+        request: ListCodeAnalysisFindingsRequest
+    ): Promise<PromiseResult<ListCodeAnalysisFindingsResponse, AWSError>>
+
+    abstract listAvailableCustomizations(
+        request: ListAvailableCustomizationsRequest
+    ): Promise<PromiseResult<ListAvailableCustomizationsResponse, AWSError>>
+
+    abstract listAvailableProfiles(
+        request: ListAvailableProfilesRequest
+    ): Promise<PromiseResult<ListAvailableProfilesRequest, AWSError>>
+
+    abstract sendTelemetryEvent(
+        request: SendTelemetryEventRequest
+    ): Promise<PromiseResult<SendTelemetryEventResponse, AWSError>>
+
+    abstract createWorkspace(request: CreateWorkspaceRequest): Promise<PromiseResult<CreateWorkspaceResponse, AWSError>>
+
+    abstract listWorkspaceMetadata(
+        request: ListWorkspaceMetadataRequest
+    ): Promise<PromiseResult<ListWorkspaceMetadataResponse, AWSError>>
+
+    abstract deleteWorkspace(request: DeleteWorkspaceRequest): Promise<PromiseResult<DeleteWorkspaceResponse, AWSError>>
+
+    abstract listFeatureEvaluations(
+        request: ListFeatureEvaluationsRequest
+    ): Promise<PromiseResult<ListFeatureEvaluationsResponse, AWSError>>
+
+    abstract createSubscriptionToken(request: CreateSubscriptionTokenRequest): Promise<CreateSubscriptionTokenResponse>
 }
diff --git a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceIAM.ts b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceIAM.ts
index 08289b1546..1c3b9188bf 100644
--- a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceIAM.ts
+++ b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceIAM.ts
@@ -12,13 +12,47 @@ import {
     createCodeWhispererSigv4Client,
 } from '../../client/sigv4/codewhisperer'
 import CodeWhispererSigv4Client = require('../../client/sigv4/codewhisperersigv4client')
+import CodeWhispererTokenClient = require('../../client/token/codewhispererbearertokenclient')
 import {
     CodeWhispererServiceBase,
+    CreateSubscriptionTokenRequest,
+    CreateSubscriptionTokenResponse,
+    CreateUploadUrlRequest,
+    CreateUploadUrlResponse,
+    CreateWorkspaceRequest,
+    CreateWorkspaceResponse,
+    DeleteWorkspaceRequest,
+    DeleteWorkspaceResponse,
     GenerateSuggestionsRequest,
     GenerateSuggestionsResponse,
+    GetCodeAnalysisRequest,
+    GetCodeAnalysisResponse,
+    GetTransformationPlanRequest,
+    GetTransformationPlanResponse,
+    GetTransformationRequest,
+    GetTransformationResponse,
+    ListAvailableCustomizationsRequest,
+    ListAvailableCustomizationsResponse,
+    ListAvailableProfilesRequest,
+    ListAvailableProfilesResponse,
+    ListCodeAnalysisFindingsRequest,
+    ListCodeAnalysisFindingsResponse,
+    ListFeatureEvaluationsRequest,
+    ListFeatureEvaluationsResponse,
+    ListWorkspaceMetadataRequest,
+    ListWorkspaceMetadataResponse,
+    SendTelemetryEventRequest,
+    SendTelemetryEventResponse,
+    StartCodeAnalysisRequest,
+    StartCodeAnalysisResponse,
+    StartTransformationRequest,
+    StartTransformationResponse,
+    StopTransformationRequest,
+    StopTransformationResponse,
     Suggestion,
     SuggestionType,
 } from './codeWhispererServiceBase'
+import { PromiseResult } from 'aws-sdk/lib/request'
 
 export class CodeWhispererServiceIAM extends CodeWhispererServiceBase {
     client: CodeWhispererSigv4Client
@@ -74,4 +108,94 @@ export class CodeWhispererServiceIAM extends CodeWhispererServiceBase {
             responseContext,
         }
     }
+
+    async codeModernizerCreateUploadUrl(request: CreateUploadUrlRequest): Promise<CreateUploadUrlResponse> {
+        throw new Error('Method not implemented.')
+    }
+
+    async codeModernizerStartCodeTransformation(
+        request: StartTransformationRequest
+    ): Promise<PromiseResult<StartTransformationResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async codeModernizerStopCodeTransformation(
+        request: StopTransformationRequest
+    ): Promise<PromiseResult<StopTransformationResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async codeModernizerGetCodeTransformation(
+        request: GetTransformationRequest
+    ): Promise<PromiseResult<GetTransformationResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async codeModernizerGetCodeTransformationPlan(
+        request: GetTransformationPlanRequest
+    ): Promise<PromiseResult<GetTransformationPlanResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async createUploadUrl(request: CreateUploadUrlRequest): Promise<PromiseResult<CreateUploadUrlResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async startCodeAnalysis(
+        request: StartCodeAnalysisRequest
+    ): Promise<PromiseResult<StartCodeAnalysisResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async getCodeAnalysis(request: GetCodeAnalysisRequest): Promise<PromiseResult<GetCodeAnalysisResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async listCodeAnalysisFindings(
+        request: ListCodeAnalysisFindingsRequest
+    ): Promise<PromiseResult<ListCodeAnalysisFindingsResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async listAvailableCustomizations(
+        request: ListAvailableCustomizationsRequest
+    ): Promise<PromiseResult<ListAvailableCustomizationsResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async listAvailableProfiles(
+        request: ListAvailableProfilesRequest
+    ): Promise<PromiseResult<ListAvailableProfilesResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async sendTelemetryEvent(
+        request: SendTelemetryEventRequest
+    ): Promise<PromiseResult<SendTelemetryEventResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async createWorkspace(request: CreateWorkspaceRequest): Promise<PromiseResult<CreateWorkspaceResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async listWorkspaceMetadata(
+        request: ListWorkspaceMetadataRequest
+    ): Promise<PromiseResult<ListWorkspaceMetadataResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async deleteWorkspace(request: DeleteWorkspaceRequest): Promise<PromiseResult<DeleteWorkspaceResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async listFeatureEvaluations(
+        request: ListFeatureEvaluationsRequest
+    ): Promise<PromiseResult<ListFeatureEvaluationsResponse, AWSError>> {
+        throw new Error('Method not implemented.')
+    }
+
+    async createSubscriptionToken(request: CreateSubscriptionTokenRequest): Promise<CreateSubscriptionTokenResponse> {
+        throw new Error('Method not implemented.')
+    }
 }
diff --git a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceToken.ts b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceToken.ts
index ab35fc0bfa..648ac26b58 100644
--- a/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceToken.ts
+++ b/server/aws-lsp-codewhisperer/src/shared/codeWhispererService/codeWhispererServiceToken.ts
@@ -20,9 +20,34 @@ import { getErrorId } from '../utils'
 import { GenerateCompletionsResponse } from '../../client/token/codewhispererbearertokenclient'
 import {
     CodeWhispererServiceBase,
+    CreateSubscriptionTokenRequest,
+    CreateSubscriptionTokenResponse,
+    CreateUploadUrlRequest,
+    CreateUploadUrlResponse,
+    CreateWorkspaceRequest,
+    DeleteWorkspaceRequest,
     GenerateSuggestionsRequest,
     GenerateSuggestionsResponse,
+    GetCodeAnalysisRequest,
+    GetCodeAnalysisResponse,
+    GetTransformationPlanRequest,
+    GetTransformationPlanResponse,
+    GetTransformationRequest,
+    GetTransformationResponse,
+    ListAvailableCustomizationsRequest,
+    ListAvailableProfilesRequest,
+    ListCodeAnalysisFindingsRequest,
+    ListCodeAnalysisFindingsResponse,
+    ListFeatureEvaluationsRequest,
+    ListWorkspaceMetadataRequest,
     ResponseContext,
+    SendTelemetryEventRequest,
+    StartCodeAnalysisRequest,
+    StartCodeAnalysisResponse,
+    StartTransformationRequest,
+    StartTransformationResponse,
+    StopTransformationRequest,
+    StopTransformationResponse,
     Suggestion,
     SuggestionType,
 } from './codeWhispererServiceBase'
@@ -33,7 +58,7 @@ import {
 export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
     client: CodeWhispererTokenClient
     /** Debounce createSubscriptionToken by storing the current, pending promise (if any). */
-    #createSubscriptionTokenPromise?: Promise<CodeWhispererTokenClient.CreateSubscriptionTokenResponse>
+    #createSubscriptionTokenPromise?: Promise<CreateSubscriptionTokenResponse>
     /** If user clicks "Upgrade" multiple times, cancel the previous wait-promise. */
     #waitUntilSubscriptionCancelSource?: CancellationTokenSource
 
@@ -163,9 +188,7 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
         }
     }
 
-    public async codeModernizerCreateUploadUrl(
-        request: CodeWhispererTokenClient.CreateUploadUrlRequest
-    ): Promise<CodeWhispererTokenClient.CreateUploadUrlResponse> {
+    public async codeModernizerCreateUploadUrl(request: CreateUploadUrlRequest): Promise<CreateUploadUrlResponse> {
         return this.client.createUploadUrl(this.withProfileArn(request)).promise()
     }
     /**
@@ -175,8 +198,8 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
      */
 
     public async codeModernizerStartCodeTransformation(
-        request: CodeWhispererTokenClient.StartTransformationRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.StartTransformationResponse, AWSError>> {
+        request: StartTransformationRequest
+    ): Promise<PromiseResult<StartTransformationResponse, AWSError>> {
         return await this.client.startTransformation(this.withProfileArn(request)).promise()
     }
 
@@ -186,8 +209,8 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
      * @returns transformationJobId - String id for the Job
      */
     public async codeModernizerStopCodeTransformation(
-        request: CodeWhispererTokenClient.StopTransformationRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.StopTransformationResponse, AWSError>> {
+        request: StopTransformationRequest
+    ): Promise<PromiseResult<StopTransformationResponse, AWSError>> {
         return await this.client.stopTransformation(this.withProfileArn(request)).promise()
     }
 
@@ -197,8 +220,8 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
      * returns COMPLETED we know the transformation is done.
      */
     public async codeModernizerGetCodeTransformation(
-        request: CodeWhispererTokenClient.GetTransformationRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.GetTransformationResponse, AWSError>> {
+        request: GetTransformationRequest
+    ): Promise<PromiseResult<GetTransformationResponse, AWSError>> {
         return await this.client.getTransformation(this.withProfileArn(request)).promise()
     }
 
@@ -208,17 +231,15 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
      * @params tranformationJobId - String id returned from StartCodeTransformationResponse
      */
     public async codeModernizerGetCodeTransformationPlan(
-        request: CodeWhispererTokenClient.GetTransformationPlanRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.GetTransformationPlanResponse, AWSError>> {
+        request: GetTransformationPlanRequest
+    ): Promise<PromiseResult<GetTransformationPlanResponse, AWSError>> {
         return this.client.getTransformationPlan(this.withProfileArn(request)).promise()
     }
 
     /**
      * @description get a pre-signed url to upload source code into S3 bucket
      */
-    async createUploadUrl(
-        request: CodeWhispererTokenClient.CreateUploadUrlRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.CreateUploadUrlResponse, AWSError>> {
+    async createUploadUrl(request: CreateUploadUrlRequest): Promise<PromiseResult<CreateUploadUrlResponse, AWSError>> {
         return this.client.createUploadUrl(this.withProfileArn(request)).promise()
     }
 
@@ -226,17 +247,15 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
      * @description Once source code uploaded to S3, send a request to run security scan on uploaded source code.
      */
     async startCodeAnalysis(
-        request: CodeWhispererTokenClient.StartCodeAnalysisRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.StartCodeAnalysisResponse, AWSError>> {
+        request: StartCodeAnalysisRequest
+    ): Promise<PromiseResult<StartCodeAnalysisResponse, AWSError>> {
         return this.client.startCodeAnalysis(this.withProfileArn(request)).promise()
     }
 
     /**
      * @description Send a request to get the code scan status detail.
      */
-    async getCodeAnalysis(
-        request: CodeWhispererTokenClient.GetCodeAnalysisRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.GetCodeAnalysisResponse, AWSError>> {
+    async getCodeAnalysis(request: GetCodeAnalysisRequest): Promise<PromiseResult<GetCodeAnalysisResponse, AWSError>> {
         return this.client.getCodeAnalysis(this.withProfileArn(request)).promise()
     }
 
@@ -244,57 +263,57 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
      * @description Once scan completed successfully, send a request to get list of all the findings for the given scan.
      */
     async listCodeAnalysisFindings(
-        request: CodeWhispererTokenClient.ListCodeAnalysisFindingsRequest
-    ): Promise<PromiseResult<CodeWhispererTokenClient.ListCodeAnalysisFindingsResponse, AWSError>> {
+        request: ListCodeAnalysisFindingsRequest
+    ): Promise<PromiseResult<ListCodeAnalysisFindingsResponse, AWSError>> {
         return this.client.listCodeAnalysisFindings(this.withProfileArn(request)).promise()
     }
 
     /**
      * @description Get list of available customizations
      */
-    async listAvailableCustomizations(request: CodeWhispererTokenClient.ListAvailableCustomizationsRequest) {
+    async listAvailableCustomizations(request: ListAvailableCustomizationsRequest) {
         return this.client.listAvailableCustomizations(this.withProfileArn(request)).promise()
     }
 
     /**
      * @description Get list of available profiles
      */
-    async listAvailableProfiles(request: CodeWhispererTokenClient.ListAvailableProfilesRequest) {
+    async listAvailableProfiles(request: ListAvailableProfilesRequest) {
         return this.client.listAvailableProfiles(request).promise()
     }
 
     /**
      * @description send telemetry event to code whisperer data warehouse
      */
-    async sendTelemetryEvent(request: CodeWhispererTokenClient.SendTelemetryEventRequest) {
+    async sendTelemetryEvent(request: SendTelemetryEventRequest) {
         return this.client.sendTelemetryEvent(this.withProfileArn(request)).promise()
     }
 
     /**
      * @description create a remote workspace
      */
-    async createWorkspace(request: CodeWhispererTokenClient.CreateWorkspaceRequest) {
+    async createWorkspace(request: CreateWorkspaceRequest) {
         return this.client.createWorkspace(this.withProfileArn(request)).promise()
     }
 
     /**
      * @description get list of workspace metadata
      */
-    async listWorkspaceMetadata(request: CodeWhispererTokenClient.ListWorkspaceMetadataRequest) {
+    async listWorkspaceMetadata(request: ListWorkspaceMetadataRequest) {
         return this.client.listWorkspaceMetadata(this.withProfileArn(request)).promise()
     }
 
     /**
      * @description delete the remote workspace
      */
-    async deleteWorkspace(request: CodeWhispererTokenClient.DeleteWorkspaceRequest) {
+    async deleteWorkspace(request: DeleteWorkspaceRequest) {
         return this.client.deleteWorkspace(this.withProfileArn(request)).promise()
     }
 
     /*
      * @description get the list of feature evaluations
      */
-    async listFeatureEvaluations(request: CodeWhispererTokenClient.ListFeatureEvaluationsRequest) {
+    async listFeatureEvaluations(request: ListFeatureEvaluationsRequest) {
         return this.client.listFeatureEvaluations(this.withProfileArn(request)).promise()
     }
 
@@ -303,7 +322,7 @@ export class CodeWhispererServiceToken extends CodeWhispererServiceBase {
      *
      * cool api you have there 🥹
      */
-    async createSubscriptionToken(request: CodeWhispererTokenClient.CreateSubscriptionTokenRequest) {
+    async createSubscriptionToken(request: CreateSubscriptionTokenRequest) {
         // Debounce.
         if (this.#createSubscriptionTokenPromise) {
             return this.#createSubscriptionTokenPromise
diff --git a/server/aws-lsp-codewhisperer/src/shared/streamingClientService.ts b/server/aws-lsp-codewhisperer/src/shared/streamingClientService.ts
index cc0ec57070..7105e192fa 100644
--- a/server/aws-lsp-codewhisperer/src/shared/streamingClientService.ts
+++ b/server/aws-lsp-codewhisperer/src/shared/streamingClientService.ts
@@ -34,6 +34,7 @@ export type ChatCommandOutput = SendMessageCommandOutput | GenerateAssistantResp
 export abstract class StreamingClientServiceBase {
     protected readonly region
     protected readonly endpoint
+    public profileArn?: string
 
     inflightRequests: Set<AbortController> = new Set()
 
@@ -49,6 +50,16 @@ export abstract class StreamingClientServiceBase {
         abortController?: AbortController
     ): Promise<SendMessageCommandOutput>
 
+    abstract generateAssistantResponse(
+        request: GenerateAssistantResponseCommandInputCodeWhispererStreaming,
+        abortController?: AbortController
+    ): Promise<GenerateAssistantResponseCommandOutputCodeWhispererStreaming>
+
+    abstract exportResultArchive(
+        request: ExportResultArchiveCommandInputCodeWhispererStreaming,
+        abortController?: AbortController
+    ): Promise<ExportResultArchiveCommandOutputCodeWhispererStreaming>
+
     public abortInflightRequests() {
         this.inflightRequests.forEach(abortController => {
             abortController.abort()
@@ -59,7 +70,6 @@ export abstract class StreamingClientServiceBase {
 
 export class StreamingClientServiceToken extends StreamingClientServiceBase {
     client: CodeWhispererStreaming
-    public profileArn?: string
     constructor(
         credentialsProvider: CredentialsProvider,
         sdkInitializator: SDKInitializator,
@@ -209,4 +219,17 @@ export class StreamingClientServiceIAM extends StreamingClientServiceBase {
 
         return response
     }
+
+    public async generateAssistantResponse(
+        request: GenerateAssistantResponseCommandInputCodeWhispererStreaming,
+        abortController?: AbortController
+    ): Promise<GenerateAssistantResponseCommandOutputCodeWhispererStreaming> {
+        throw new Error('Method not implemented.')
+    }
+    public async exportResultArchive(
+        request: ExportResultArchiveCommandInputCodeWhispererStreaming,
+        abortController?: AbortController
+    ): Promise<ExportResultArchiveCommandOutputCodeWhispererStreaming> {
+        throw new Error('Method not implemented.')
+    }
 }