chore(amazonq): Update /dev error classification logic

neilk-aws · neilk-aws · commit 1a4b1a850ee9 · 2025-03-11T17:55:51.000-07:00
diff --git a/packages/core/src/amazonq/errors.ts b/packages/core/src/amazonq/errors.ts
@@ -9,10 +9,37 @@
  * When thrown from common components, individual agents can catch and transform this error
  * to provide their own customized error messages.
  */
-import { ToolkitError } from '../shared/errors'
+import { ErrorInformation, ToolkitError } from '../shared/errors'
 
-export class ContentLengthError extends ToolkitError {
-    constructor(message: string) {
-        super(message, { code: 'ContentLengthError' })
+/**
+ * Errors extending this class are considered "errors" in service metrics.
+ */
+export class ClientError extends ToolkitError {
+    constructor(message: string, info: ErrorInformation = {}) {
+        super(message, info)
+    }
+}
+
+/**
+ * Errors extending this class are considered "faults" in service metrics.
+ */
+export class ServiceError extends ToolkitError {
+    constructor(message: string, info: ErrorInformation = {}) {
+        super(message, info)
+    }
+}
+
+/**
+ * Errors extending this class are considered "LLM failures" in service metrics.
+ */
+export class LlmError extends ToolkitError {
+    constructor(message: string, info: ErrorInformation = {}) {
+        super(message, info)
+    }
+}
+
+export class ContentLengthError extends ClientError {
+    constructor(message: string, info: ErrorInformation = { code: 'ContentLengthError' }) {
+        super(message, info)
     }
 }
diff --git a/packages/core/src/amazonqFeatureDev/client/featureDev.ts b/packages/core/src/amazonqFeatureDev/client/featureDev.ts
@@ -13,10 +13,12 @@ import * as FeatureDevProxyClient from './featuredevproxyclient'
 import { featureName, startTaskAssistLimitReachedMessage } from '../constants'
 import { CodeReference } from '../../amazonq/webview/ui/connector'
 import {
-    ApiError,
+    ApiServiceError,
     CodeIterationLimitError,
     ContentLengthError,
+    FeatureDevServiceError,
     MonthlyConversationLimitError,
+    throwApiError,
     UnknownApiError,
 } from '../errors'
 import { ToolkitError, isAwsError } from '../../shared/errors'
@@ -93,7 +95,7 @@ export class FeatureDevClient implements FeatureClient {
                 ) {
                     throw new MonthlyConversationLimitError(e.message)
                 }
-                throw new ApiError(e.message, 'CreateConversation', e.code, e.statusCode ?? 400)
+                throwApiError(e.message, 'CreateConversation', e.code, e.statusCode ?? 500)
             }
 
             throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'CreateConversation')
@@ -136,7 +138,7 @@ export class FeatureDevClient implements FeatureClient {
                 if (e.code === 'ValidationException' && e.message.includes('Invalid contentLength')) {
                     throw new ContentLengthError()
                 }
-                throw new ApiError(e.message, 'CreateUploadUrl', e.code, e.statusCode ?? 400)
+                throwApiError(e.message, 'CreateUploadUrl', e.code, e.statusCode ?? 500)
             }
 
             throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'CreateUploadUrl')
@@ -198,8 +200,10 @@ export class FeatureDevClient implements FeatureClient {
                 ) {
                     throw new CodeIterationLimitError()
                 }
+                throwApiError(e.message, 'StartTaskAssistCodeGeneration', e.code, e.statusCode ?? 500)
             }
-            throw new ToolkitError((e as Error).message, { code: 'StartCodeGenerationFailed' })
+
+            throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'StartTaskAssistCodeGeneration')
         }
     }
 
@@ -220,7 +224,12 @@ export class FeatureDevClient implements FeatureClient {
                     (e as any).requestId
                 }`
             )
-            throw new ToolkitError((e as Error).message, { code: 'GetCodeGenerationFailed' })
+
+            if (isAwsError(e)) {
+                throwApiError(e.message, 'GetTaskAssistCodeGeneration', e.code, e.statusCode ?? 500)
+            }
+
+            throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'GetTaskAssistCodeGeneration')
         }
     }
 
@@ -235,7 +244,12 @@ export class FeatureDevClient implements FeatureClient {
             const archiveResponse = await streamingClient.exportResultArchive(params)
             const buffer: number[] = []
             if (archiveResponse.body === undefined) {
-                throw new ToolkitError('Empty response from CodeWhisperer Streaming service.')
+                throw new ApiServiceError(
+                    'Empty response from CodeWhisperer Streaming service.',
+                    'ExportResultArchive',
+                    'EmptyResponse',
+                    500
+                )
             }
             for await (const chunk of archiveResponse.body) {
                 if (chunk.internalServerException !== undefined) {
@@ -274,7 +288,12 @@ export class FeatureDevClient implements FeatureClient {
                     (e as any).requestId
                 }`
             )
-            throw new ToolkitError((e as Error).message, { code: 'ExportResultArchiveFailed' })
+
+            if (isAwsError(e)) {
+                throwApiError(e.message, 'ExportResultArchive', e.code, e.statusCode ?? 500)
+            }
+
+            throw new FeatureDevServiceError(e instanceof Error ? e.message : 'Unknown error', 'ExportResultArchive')
         }
     }
 
diff --git a/packages/core/src/amazonqFeatureDev/controllers/chat/controller.ts b/packages/core/src/amazonqFeatureDev/controllers/chat/controller.ts
@@ -56,6 +56,7 @@ import { randomUUID } from '../../../shared/crypto'
 import { FollowUpTypes } from '../../../amazonq/commons/types'
 import { Messenger } from '../../../amazonq/commons/connector/baseMessenger'
 import { BaseChatSessionStorage } from '../../../amazonq/commons/baseChatStorage'
+import { ClientError, LlmError, ServiceError } from '../../../amazonq/errors'
 
 export interface ChatControllerEventEmitters {
     readonly processHumanChatMessage: EventEmitter<any>
@@ -551,32 +552,20 @@ export class FeatureDevController {
         } catch (err: any) {
             getLogger().error(`${featureName}: Error during code generation: ${err}`)
 
-            let result: string
-            switch (err.constructor.name) {
-                case FeatureDevServiceError.name:
-                    if (err.code === 'EmptyPatchException') {
-                        result = MetricDataResult.LlmFailure
-                    } else if (err.code === 'GuardrailsException' || err.code === 'ThrottlingException') {
-                        result = MetricDataResult.Error
-                    } else {
-                        result = MetricDataResult.Fault
-                    }
-                    break
-                case MonthlyConversationLimitError.name:
-                case CodeIterationLimitError.name:
-                case PromptRefusalException.name:
-                case NoChangeRequiredException.name:
+            let result: string = MetricDataResult.Fault
+            if (err instanceof ClientError) {
+                result = MetricDataResult.Error
+            } else if (err instanceof ServiceError) {
+                result = MetricDataResult.Fault
+            } else if (err instanceof LlmError) {
+                result = MetricDataResult.LlmFailure
+            } else {
+                if (isAPIClientError(err)) {
                     result = MetricDataResult.Error
-                    break
-                default:
-                    if (isAPIClientError(err)) {
-                        result = MetricDataResult.Error
-                    } else {
-                        result = MetricDataResult.Fault
-                    }
-                    break
+                } else {
+                    result = MetricDataResult.Fault
+                }
             }
-
             await session.sendMetricDataTelemetry(MetricDataOperationName.EndCodeGeneration, result)
             throw err
         } finally {
diff --git a/packages/core/src/amazonqFeatureDev/errors.ts b/packages/core/src/amazonqFeatureDev/errors.ts
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ToolkitError } from '../shared/errors'
 import {
     featureName,
     clientErrorMessages,
@@ -12,131 +11,151 @@ import {
 } from './constants'
 import { uploadCodeError } from './userFacingText'
 import { i18n } from '../shared/i18n-helper'
+import { ClientError, ServiceError, ContentLengthError as SharedContentLengthError } from '../amazonq/errors'
 
-export class ConversationIdNotFoundError extends ToolkitError {
+export class ConversationIdNotFoundError extends ServiceError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.conversationIdNotFoundError'), {
             code: 'ConversationIdNotFound',
         })
     }
 }
 
-export class TabIdNotFoundError extends ToolkitError {
+export class TabIdNotFoundError extends ServiceError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.tabIdNotFoundError'), {
             code: 'TabIdNotFound',
         })
     }
 }
 
-export class WorkspaceFolderNotFoundError extends ToolkitError {
+export class WorkspaceFolderNotFoundError extends ServiceError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.workspaceFolderNotFoundError'), {
             code: 'WorkspaceFolderNotFound',
         })
     }
 }
 
-export class UserMessageNotFoundError extends ToolkitError {
+export class UserMessageNotFoundError extends ServiceError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.userMessageNotFoundError'), {
             code: 'MessageNotFound',
         })
     }
 }
 
-export class SelectedFolderNotInWorkspaceFolderError extends ToolkitError {
+export class SelectedFolderNotInWorkspaceFolderError extends ClientError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.selectedFolderNotInWorkspaceFolderError'), {
             code: 'SelectedFolderNotInWorkspaceFolder',
         })
     }
 }
 
-export class PromptRefusalException extends ToolkitError {
+export class PromptRefusalException extends ClientError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.promptRefusalException'), {
             code: 'PromptRefusalException',
         })
     }
 }
 
-export class NoChangeRequiredException extends ToolkitError {
+export class NoChangeRequiredException extends ClientError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.noChangeRequiredException'), {
             code: 'NoChangeRequiredException',
         })
     }
 }
 
-export class FeatureDevServiceError extends ToolkitError {
+export class FeatureDevServiceError extends ServiceError {
     constructor(message: string, code: string) {
         super(message, { code })
     }
 }
 
-export class PrepareRepoFailedError extends ToolkitError {
+export class PrepareRepoFailedError extends ServiceError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.prepareRepoFailedError'), {
             code: 'PrepareRepoFailed',
         })
     }
 }
 
-export class UploadCodeError extends ToolkitError {
+export class UploadCodeError extends ServiceError {
     constructor(statusCode: string) {
         super(uploadCodeError, { code: `UploadCode-${statusCode}` })
     }
 }
 
-export class UploadURLExpired extends ToolkitError {
+export class UploadURLExpired extends ClientError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.uploadURLExpired'), { code: 'UploadURLExpired' })
     }
 }
 
-export class IllegalStateTransition extends ToolkitError {
+export class IllegalStateTransition extends ServiceError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.illegalStateTransition'), { code: 'IllegalStateTransition' })
     }
 }
 
-export class ContentLengthError extends ToolkitError {
+export class IllegalStateError extends ServiceError {
+    constructor(message: string) {
+        super(message, { code: 'IllegalStateTransition' })
+    }
+}
+
+export class ContentLengthError extends SharedContentLengthError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.contentLengthError'), { code: ContentLengthError.name })
     }
 }
 
-export class ZipFileError extends ToolkitError {
+export class ZipFileError extends ServiceError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.zipFileError'), { code: ZipFileError.name })
     }
 }
 
-export class CodeIterationLimitError extends ToolkitError {
+export class CodeIterationLimitError extends ClientError {
     constructor() {
         super(i18n('AWS.amazonq.featureDev.error.codeIterationLimitError'), { code: CodeIterationLimitError.name })
     }
 }
 
-export class MonthlyConversationLimitError extends ToolkitError {
+export class MonthlyConversationLimitError extends ClientError {
     constructor(message: string) {
         super(message, { code: MonthlyConversationLimitError.name })
     }
 }
 
-export class UnknownApiError extends ToolkitError {
+export class UnknownApiError extends ServiceError {
     constructor(message: string, api: string) {
         super(message, { code: `${api}-Unknown` })
     }
 }
 
-export class ApiError extends ToolkitError {
+export class ApiClientError extends ClientError {
+    constructor(message: string, api: string, errorName: string, errorCode: number) {
+        super(message, { code: `${api}-${errorName}-${errorCode}` })
+    }
+}
+
+export class ApiServiceError extends ServiceError {
     constructor(message: string, api: string, errorName: string, errorCode: number) {
         super(message, { code: `${api}-${errorName}-${errorCode}` })
     }
 }
 
+export function throwApiError(message: string, api: string, errorName: string, errorCode: number) {
+    if (errorCode >= 400 && errorCode < 500) {
+        throw new ApiClientError(message, api, errorName, errorCode)
+    }
+    throw new ApiServiceError(message, api, errorName, errorCode)
+}
+
 export const denyListedErrors: string[] = ['Deserialization error', 'Inaccessible host']
 
 export function createUserFacingErrorMessage(message: string) {
@@ -148,8 +167,6 @@ export function createUserFacingErrorMessage(message: string) {
 
 export function isAPIClientError(error: { code?: string; message: string }): boolean {
     return (
-        (error.code === 'StartCodeGenerationFailed' &&
-            startCodeGenClientErrorMessages.some((msg: string) => error.message.includes(msg))) ||
         clientErrorMessages.some((msg: string) => error.message.includes(msg)) ||
         error.message.includes(startTaskAssistLimitReachedMessage)
     )
diff --git a/packages/core/src/amazonqFeatureDev/session/session.ts b/packages/core/src/amazonqFeatureDev/session/session.ts
@@ -14,7 +14,7 @@ import {
     type SessionStateConfig,
     UpdateFilesPathsParams,
 } from '../../amazonq/commons/types'
-import { ContentLengthError, ConversationIdNotFoundError } from '../errors'
+import { ContentLengthError, ConversationIdNotFoundError, IllegalStateError, IllegalStateTransition } from '../errors'
 import { featureDevChat, referenceLogText, featureDevScheme } from '../constants'
 import fs from '../../shared/fs/fs'
 import { FeatureDevClient } from '../client/featureDev'
@@ -353,7 +353,7 @@ export class Session {
 
     get state() {
         if (!this._state) {
-            throw new Error("State should be initialized before it's read")
+            throw new IllegalStateError("State should be initialized before it's read")
         }
         return this._state
     }
@@ -364,7 +364,7 @@ export class Session {
 
     get uploadId() {
         if (!('uploadId' in this.state)) {
-            throw new Error("UploadId has to be initialized before it's read")
+            throw new IllegalStateError("UploadId has to be initialized before it's read")
         }
         return this.state.uploadId
     }
diff --git a/packages/core/src/amazonqFeatureDev/session/sessionState.ts b/packages/core/src/amazonqFeatureDev/session/sessionState.ts

Original file line number	Diff line number	Diff line change
`@@ -13,10 +13,12 @@ import * as FeatureDevProxyClient from './featuredevproxyclient'`
`13`	`13`	`import { featureName, startTaskAssistLimitReachedMessage } from '../constants'`
`14`	`14`	`import { CodeReference } from '../../amazonq/webview/ui/connector'`
`15`	`15`	`import {`
`16`		`- ApiError,`
	`16`	`+ ApiServiceError,`
`17`	`17`	`CodeIterationLimitError,`
`18`	`18`	`ContentLengthError,`
	`19`	`+ FeatureDevServiceError,`
`19`	`20`	`MonthlyConversationLimitError,`
	`21`	`+ throwApiError,`
`20`	`22`	`UnknownApiError,`
`21`	`23`	`} from '../errors'`
`22`	`24`	`import { ToolkitError, isAwsError } from '../../shared/errors'`
`@@ -93,7 +95,7 @@ export class FeatureDevClient implements FeatureClient {`
`93`	`95`	`) {`
`94`	`96`	`throw new MonthlyConversationLimitError(e.message)`
`95`	`97`	`}`
`96`		`- throw new ApiError(e.message, 'CreateConversation', e.code, e.statusCode ?? 400)`
	`98`	`+ throwApiError(e.message, 'CreateConversation', e.code, e.statusCode ?? 500)`
`97`	`99`	`}`
`98`	`100`
`99`	`101`	`throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'CreateConversation')`
`@@ -136,7 +138,7 @@ export class FeatureDevClient implements FeatureClient {`
`136`	`138`	`if (e.code === 'ValidationException' && e.message.includes('Invalid contentLength')) {`
`137`	`139`	`throw new ContentLengthError()`
`138`	`140`	`}`
`139`		`- throw new ApiError(e.message, 'CreateUploadUrl', e.code, e.statusCode ?? 400)`
	`141`	`+ throwApiError(e.message, 'CreateUploadUrl', e.code, e.statusCode ?? 500)`
`140`	`142`	`}`
`141`	`143`
`142`	`144`	`throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'CreateUploadUrl')`
`@@ -198,8 +200,10 @@ export class FeatureDevClient implements FeatureClient {`
`198`	`200`	`) {`
`199`	`201`	`throw new CodeIterationLimitError()`
`200`	`202`	`}`
	`203`	`+ throwApiError(e.message, 'StartTaskAssistCodeGeneration', e.code, e.statusCode ?? 500)`
`201`	`204`	`}`
`202`		`- throw new ToolkitError((e as Error).message, { code: 'StartCodeGenerationFailed' })`
	`205`	`+`
	`206`	`+ throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'StartTaskAssistCodeGeneration')`
`203`	`207`	`}`
`204`	`208`	`}`
`205`	`209`
`@@ -220,7 +224,12 @@ export class FeatureDevClient implements FeatureClient {`
`220`	`224`	`(e as any).requestId`
`221`	`225`	}`
`222`	`226`	`)`
`223`		`- throw new ToolkitError((e as Error).message, { code: 'GetCodeGenerationFailed' })`
	`227`	`+`
	`228`	`+ if (isAwsError(e)) {`
	`229`	`+ throwApiError(e.message, 'GetTaskAssistCodeGeneration', e.code, e.statusCode ?? 500)`
	`230`	`+ }`
	`231`	`+`
	`232`	`+ throw new UnknownApiError(e instanceof Error ? e.message : 'Unknown error', 'GetTaskAssistCodeGeneration')`
`224`	`233`	`}`
`225`	`234`	`}`
`226`	`235`
`@@ -235,7 +244,12 @@ export class FeatureDevClient implements FeatureClient {`
`235`	`244`	`const archiveResponse = await streamingClient.exportResultArchive(params)`
`236`	`245`	`const buffer: number[] = []`
`237`	`246`	`if (archiveResponse.body === undefined) {`
`238`		`- throw new ToolkitError('Empty response from CodeWhisperer Streaming service.')`
	`247`	`+ throw new ApiServiceError(`
	`248`	`+ 'Empty response from CodeWhisperer Streaming service.',`
	`249`	`+ 'ExportResultArchive',`
	`250`	`+ 'EmptyResponse',`
	`251`	`+ 500`
	`252`	`+ )`
`239`	`253`	`}`
`240`	`254`	`for await (const chunk of archiveResponse.body) {`
`241`	`255`	`if (chunk.internalServerException !== undefined) {`
`@@ -274,7 +288,12 @@ export class FeatureDevClient implements FeatureClient {`
`274`	`288`	`(e as any).requestId`
`275`	`289`	}`
`276`	`290`	`)`
`277`		`- throw new ToolkitError((e as Error).message, { code: 'ExportResultArchiveFailed' })`
	`291`	`+`
	`292`	`+ if (isAwsError(e)) {`
	`293`	`+ throwApiError(e.message, 'ExportResultArchive', e.code, e.statusCode ?? 500)`
	`294`	`+ }`
	`295`	`+`
	`296`	`+ throw new FeatureDevServiceError(e instanceof Error ? e.message : 'Unknown error', 'ExportResultArchive')`
`278`	`297`	`}`
`279`	`298`	`}`
`280`	`299`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`* SPDX-License-Identifier: Apache-2.0`
`4`	`4`	`*/`
`5`	`5`
`6`		`-import { ToolkitError } from '../shared/errors'`
`7`	`6`	`import {`
`8`	`7`	`featureName,`
`9`	`8`	`clientErrorMessages,`
`@@ -12,131 +11,151 @@ import {`
`12`	`11`	`} from './constants'`
`13`	`12`	`import { uploadCodeError } from './userFacingText'`
`14`	`13`	`import { i18n } from '../shared/i18n-helper'`
	`14`	`+import { ClientError, ServiceError, ContentLengthError as SharedContentLengthError } from '../amazonq/errors'`
`15`	`15`
`16`		`-export class ConversationIdNotFoundError extends ToolkitError {`
	`16`	`+export class ConversationIdNotFoundError extends ServiceError {`
`17`	`17`	`constructor() {`
`18`	`18`	`super(i18n('AWS.amazonq.featureDev.error.conversationIdNotFoundError'), {`
`19`	`19`	`code: 'ConversationIdNotFound',`
`20`	`20`	`})`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`		`-export class TabIdNotFoundError extends ToolkitError {`
	`24`	`+export class TabIdNotFoundError extends ServiceError {`
`25`	`25`	`constructor() {`
`26`	`26`	`super(i18n('AWS.amazonq.featureDev.error.tabIdNotFoundError'), {`
`27`	`27`	`code: 'TabIdNotFound',`
`28`	`28`	`})`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`-export class WorkspaceFolderNotFoundError extends ToolkitError {`
	`32`	`+export class WorkspaceFolderNotFoundError extends ServiceError {`
`33`	`33`	`constructor() {`
`34`	`34`	`super(i18n('AWS.amazonq.featureDev.error.workspaceFolderNotFoundError'), {`
`35`	`35`	`code: 'WorkspaceFolderNotFound',`
`36`	`36`	`})`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`-export class UserMessageNotFoundError extends ToolkitError {`
	`40`	`+export class UserMessageNotFoundError extends ServiceError {`
`41`	`41`	`constructor() {`
`42`	`42`	`super(i18n('AWS.amazonq.featureDev.error.userMessageNotFoundError'), {`
`43`	`43`	`code: 'MessageNotFound',`
`44`	`44`	`})`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`48`		`-export class SelectedFolderNotInWorkspaceFolderError extends ToolkitError {`
	`48`	`+export class SelectedFolderNotInWorkspaceFolderError extends ClientError {`
`49`	`49`	`constructor() {`
`50`	`50`	`super(i18n('AWS.amazonq.featureDev.error.selectedFolderNotInWorkspaceFolderError'), {`
`51`	`51`	`code: 'SelectedFolderNotInWorkspaceFolder',`
`52`	`52`	`})`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`-export class PromptRefusalException extends ToolkitError {`
	`56`	`+export class PromptRefusalException extends ClientError {`
`57`	`57`	`constructor() {`
`58`	`58`	`super(i18n('AWS.amazonq.featureDev.error.promptRefusalException'), {`
`59`	`59`	`code: 'PromptRefusalException',`
`60`	`60`	`})`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`-export class NoChangeRequiredException extends ToolkitError {`
	`64`	`+export class NoChangeRequiredException extends ClientError {`
`65`	`65`	`constructor() {`
`66`	`66`	`super(i18n('AWS.amazonq.featureDev.error.noChangeRequiredException'), {`
`67`	`67`	`code: 'NoChangeRequiredException',`
`68`	`68`	`})`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`-export class FeatureDevServiceError extends ToolkitError {`
	`72`	`+export class FeatureDevServiceError extends ServiceError {`
`73`	`73`	`constructor(message: string, code: string) {`
`74`	`74`	`super(message, { code })`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`78`		`-export class PrepareRepoFailedError extends ToolkitError {`
	`78`	`+export class PrepareRepoFailedError extends ServiceError {`
`79`	`79`	`constructor() {`
`80`	`80`	`super(i18n('AWS.amazonq.featureDev.error.prepareRepoFailedError'), {`
`81`	`81`	`code: 'PrepareRepoFailed',`
`82`	`82`	`})`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`		`-export class UploadCodeError extends ToolkitError {`
	`86`	`+export class UploadCodeError extends ServiceError {`
`87`	`87`	`constructor(statusCode: string) {`
`88`	`88`	super(uploadCodeError, { code: `UploadCode-${statusCode}` })
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
`92`		`-export class UploadURLExpired extends ToolkitError {`
	`92`	`+export class UploadURLExpired extends ClientError {`
`93`	`93`	`constructor() {`
`94`	`94`	`super(i18n('AWS.amazonq.featureDev.error.uploadURLExpired'), { code: 'UploadURLExpired' })`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`-export class IllegalStateTransition extends ToolkitError {`
	`98`	`+export class IllegalStateTransition extends ServiceError {`
`99`	`99`	`constructor() {`
`100`	`100`	`super(i18n('AWS.amazonq.featureDev.error.illegalStateTransition'), { code: 'IllegalStateTransition' })`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`		`-export class ContentLengthError extends ToolkitError {`
	`104`	`+export class IllegalStateError extends ServiceError {`
	`105`	`+ constructor(message: string) {`
	`106`	`+ super(message, { code: 'IllegalStateTransition' })`
	`107`	`+ }`
	`108`	`+}`
	`109`	`+`
	`110`	`+export class ContentLengthError extends SharedContentLengthError {`
`105`	`111`	`constructor() {`
`106`	`112`	`super(i18n('AWS.amazonq.featureDev.error.contentLengthError'), { code: ContentLengthError.name })`
`107`	`113`	`}`
`108`	`114`	`}`
`109`	`115`
`110`		`-export class ZipFileError extends ToolkitError {`
	`116`	`+export class ZipFileError extends ServiceError {`
`111`	`117`	`constructor() {`
`112`	`118`	`super(i18n('AWS.amazonq.featureDev.error.zipFileError'), { code: ZipFileError.name })`
`113`	`119`	`}`
`114`	`120`	`}`
`115`	`121`
`116`		`-export class CodeIterationLimitError extends ToolkitError {`
	`122`	`+export class CodeIterationLimitError extends ClientError {`
`117`	`123`	`constructor() {`
`118`	`124`	`super(i18n('AWS.amazonq.featureDev.error.codeIterationLimitError'), { code: CodeIterationLimitError.name })`
`119`	`125`	`}`
`120`	`126`	`}`
`121`	`127`
`122`		`-export class MonthlyConversationLimitError extends ToolkitError {`
	`128`	`+export class MonthlyConversationLimitError extends ClientError {`
`123`	`129`	`constructor(message: string) {`
`124`	`130`	`super(message, { code: MonthlyConversationLimitError.name })`
`125`	`131`	`}`
`126`	`132`	`}`
`127`	`133`
`128`		`-export class UnknownApiError extends ToolkitError {`
	`134`	`+export class UnknownApiError extends ServiceError {`
`129`	`135`	`constructor(message: string, api: string) {`
`130`	`136`	super(message, { code: `${api}-Unknown` })
`131`	`137`	`}`
`132`	`138`	`}`
`133`	`139`
`134`		`-export class ApiError extends ToolkitError {`
	`140`	`+export class ApiClientError extends ClientError {`
	`141`	`+ constructor(message: string, api: string, errorName: string, errorCode: number) {`
	`142`	+ super(message, { code: `${api}-${errorName}-${errorCode}` })
	`143`	`+ }`
	`144`	`+}`
	`145`	`+`
	`146`	`+export class ApiServiceError extends ServiceError {`
`135`	`147`	`constructor(message: string, api: string, errorName: string, errorCode: number) {`
`136`	`148`	super(message, { code: `${api}-${errorName}-${errorCode}` })
`137`	`149`	`}`
`138`	`150`	`}`
`139`	`151`
	`152`	`+export function throwApiError(message: string, api: string, errorName: string, errorCode: number) {`
	`153`	`+ if (errorCode >= 400 && errorCode < 500) {`
	`154`	`+ throw new ApiClientError(message, api, errorName, errorCode)`
	`155`	`+ }`
	`156`	`+ throw new ApiServiceError(message, api, errorName, errorCode)`
	`157`	`+}`
	`158`	`+`
`140`	`159`	`export const denyListedErrors: string[] = ['Deserialization error', 'Inaccessible host']`
`141`	`160`
`142`	`161`	`export function createUserFacingErrorMessage(message: string) {`
`@@ -148,8 +167,6 @@ export function createUserFacingErrorMessage(message: string) {`
`148`	`167`
`149`	`168`	`export function isAPIClientError(error: { code?: string; message: string }): boolean {`
`150`	`169`	`return (`
`151`		`- (error.code === 'StartCodeGenerationFailed' &&`
`152`		`- startCodeGenClientErrorMessages.some((msg: string) => error.message.includes(msg))) \|\|`
`153`	`170`	`clientErrorMessages.some((msg: string) => error.message.includes(msg)) \|\|`
`154`	`171`	`error.message.includes(startTaskAssistLimitReachedMessage)`
`155`	`172`	`)`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ import {`
`14`	`14`	`type SessionStateConfig,`
`15`	`15`	`UpdateFilesPathsParams,`
`16`	`16`	`} from '../../amazonq/commons/types'`
`17`		`-import { ContentLengthError, ConversationIdNotFoundError } from '../errors'`
	`17`	`+import { ContentLengthError, ConversationIdNotFoundError, IllegalStateError, IllegalStateTransition } from '../errors'`
`18`	`18`	`import { featureDevChat, referenceLogText, featureDevScheme } from '../constants'`
`19`	`19`	`import fs from '../../shared/fs/fs'`
`20`	`20`	`import { FeatureDevClient } from '../client/featureDev'`
`@@ -353,7 +353,7 @@ export class Session {`
`353`	`353`
`354`	`354`	`get state() {`
`355`	`355`	`if (!this._state) {`
`356`		`- throw new Error("State should be initialized before it's read")`
	`356`	`+ throw new IllegalStateError("State should be initialized before it's read")`
`357`	`357`	`}`
`358`	`358`	`return this._state`
`359`	`359`	`}`
`@@ -364,7 +364,7 @@ export class Session {`
`364`	`364`
`365`	`365`	`get uploadId() {`
`366`	`366`	`if (!('uploadId' in this.state)) {`
`367`		`- throw new Error("UploadId has to be initialized before it's read")`
	`367`	`+ throw new IllegalStateError("UploadId has to be initialized before it's read")`
`368`	`368`	`}`
`369`	`369`	`return this.state.uploadId`
`370`	`370`	`}`