feat(amazonq): Port in chat message error handling (#7121)

## Problem

During the agentic loop, if there are multiple iterations and then it
eventually fails, the partial results would not be posted and the user
would not be able to continue chat (it wouldn't allow them to type)

## Solution

Port in the VSC client related change from:
aws/language-servers#1012

Now if there are errors during the agentic loop, we will display all the
partial responses we have gathered and then break out of the generating
state, allowing the user to continue.

## How I tested

Between the previous and new changes I ran the same test suite

- Ask agentic chat to make 101 files (since [a recent
change](aws/language-servers#1022) increased the
loop limit to 100) in a test folder, adding in some random text
- Ask agentic chat to "read every single file, not skipping any of them,
and then display the text of each one".
- W/ the old changes it would error part way and the UI would show
"generating" and the user could not do anything
- W/ the new changes it will show partial results (the text of the files
it could resolve) and then allow the user to continue with another
prompt.

---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.

Signed-off-by: nkomonen-amazon <[email protected]>

Author: nkomonen-amazon

packages/amazonq/src/lsp/chat/messages.ts

@@ -182,10 +182,24 @@ export function registerMessageListeners(
                 break
             }
             case chatRequestType.method: {
-                const chatParams = { ...message.params } as ChatParams
+                const chatParams: ChatParams = { ...message.params }
                 const partialResultToken = uuidv4()
-                const chatDisposable = languageClient.onProgress(chatRequestType, partialResultToken, (partialResult) =>
-                    handlePartialResult<ChatResult>(partialResult, encryptionKey, provider, chatParams.tabId)
+                let lastPartialResult: ChatResult | undefined
+                const chatDisposable = languageClient.onProgress(
+                    chatRequestType,
+                    partialResultToken,
+                    (partialResult) => {
+                        // Store the latest partial result
+                        if (typeof partialResult === 'string' && encryptionKey) {
+                            void decodeRequest<ChatResult>(partialResult, encryptionKey).then(
+                                (decoded) => (lastPartialResult = decoded)
+                            )
+                        } else {
+                            lastPartialResult = partialResult as ChatResult
+                        }
+
+                        void handlePartialResult<ChatResult>(partialResult, encryptionKey, provider, chatParams.tabId)
+                    }
                 )
 
                 const editor =
@@ -197,17 +211,36 @@ export function registerMessageListeners(
                 }
 
                 const chatRequest = await encryptRequest<ChatParams>(chatParams, encryptionKey)
-                const chatResult = (await languageClient.sendRequest(chatRequestType.method, {
-                    ...chatRequest,
-                    partialResultToken,
-                })) as string | ChatResult
-                void handleCompleteResult<ChatResult>(
-                    chatResult,
-                    encryptionKey,
-                    provider,
-                    chatParams.tabId,
-                    chatDisposable
-                )
+                try {
+                    const chatResult = await languageClient.sendRequest<string | ChatResult>(chatRequestType.method, {
+                        ...chatRequest,
+                        partialResultToken,
+                    })
+                    await handleCompleteResult<ChatResult>(
+                        chatResult,
+                        encryptionKey,
+                        provider,
+                        chatParams.tabId,
+                        chatDisposable
+                    )
+                } catch (e) {
+                    languageClient.info(`Error occurred during chat request: ${e}`)
+                    // Use the last partial result if available, append error message
+                    const errorResult: ChatResult = {
+                        ...lastPartialResult,
+                        body: lastPartialResult?.body
+                            ? `${lastPartialResult.body}\n\n ❌ Error: Request failed to complete`
+                            : '❌ An error occurred while processing your request',
+                    }
+
+                    await handleCompleteResult<ChatResult>(
+                        errorResult,
+                        encryptionKey,
+                        provider,
+                        chatParams.tabId,
+                        chatDisposable
+                    )
+                }
                 break
             }
             case quickActionRequestType.method: {