Merge branch 'feature/agentic-chat' into my-feature-agentic

Author: Randall-Jiang

packages/core/src/codewhispererChat/controllers/chat/chatRequest/converter.ts

@@ -175,7 +175,6 @@ export function triggerPayloadToChatRequest(triggerPayload: TriggerPayload): { c
             },
             chatTriggerType,
             customizationArn: customizationArn,
-            history: triggerPayload.chatHistory,
         },
     }
 }

packages/core/src/codewhispererChat/controllers/chat/controller.ts

@@ -82,7 +82,6 @@ import {
     createSavedPromptCommandId,
     aditionalContentNameLimit,
     additionalContentInnerContextLimit,
-    tools,
     workspaceChunkMaxSize,
     defaultContextLengths,
 } from '../../constants'
@@ -368,6 +367,7 @@ export class ChatController {
     private async processStopResponseMessage(message: StopResponseMessage) {
         const session = this.sessionStorage.getSession(message.tabID)
         session.tokenSource.cancel()
+        this.chatHistoryStorage.getTabHistory(message.tabID).clearRecentHistory()
     }
 
     private async processTriggerTabIDReceived(message: TriggerTabIDReceived) {
@@ -650,6 +650,8 @@ export class ChatController {
                 const session = this.sessionStorage.getSession(tabID)
                 const toolUse = session.toolUse
                 if (!toolUse || !toolUse.input) {
+                    // Turn off AgentLoop flag if there's no tool use
+                    this.sessionStorage.setAgentLoopInProgress(tabID, false)
                     return
                 }
                 session.setToolUse(undefined)
@@ -723,7 +725,6 @@ export class ChatController {
                         customization: getSelectedCustomization(),
                         toolResults: toolResults,
                         origin: Origin.IDE,
-                        chatHistory: this.chatHistoryStorage.getTabHistory(tabID).getHistory(),
                         context: session.context ?? [],
                         relevantTextDocuments: [],
                         additionalContents: [],
@@ -899,10 +900,16 @@ export class ChatController {
             errorMessage = e.message
         }
 
+        // Turn off AgentLoop flag in case of exception
+        if (tabID) {
+            this.sessionStorage.setAgentLoopInProgress(tabID, false)
+        }
+
         this.messenger.sendErrorMessage(errorMessage, tabID, requestID)
         getLogger().error(`error: ${errorMessage} tabID: ${tabID} requestID: ${requestID}`)
 
         this.sessionStorage.deleteSession(tabID)
+        this.chatHistoryStorage.getTabHistory(tabID).clearRecentHistory()
     }
 
     private async processContextMenuCommand(command: EditorContextCommand) {
@@ -1062,7 +1069,6 @@ export class ChatController {
                     codeQuery: lastTriggerEvent.context?.focusAreaContext?.names,
                     userIntent: message.userIntent,
                     customization: getSelectedCustomization(),
-                    chatHistory: this.chatHistoryStorage.getTabHistory(message.tabID).getHistory(),
                     contextLengths: {
                         ...defaultContextLengths,
                     },
@@ -1111,7 +1117,6 @@ export class ChatController {
                         codeQuery: context?.focusAreaContext?.names,
                         userIntent: undefined,
                         customization: getSelectedCustomization(),
-                        chatHistory: this.chatHistoryStorage.getTabHistory(message.tabID).getHistory(),
                         origin: Origin.IDE,
                         context: message.context ?? [],
                         relevantTextDocuments: [],
@@ -1293,6 +1298,16 @@ export class ChatController {
         }
 
         const tabID = triggerEvent.tabID
+        if (this.sessionStorage.isAgentLoopInProgress(tabID)) {
+            // If a response is already in progress, stop it first
+            const stopResponseMessage: StopResponseMessage = {
+                tabID: tabID,
+            }
+            await this.processStopResponseMessage(stopResponseMessage)
+        }
+
+        // Ensure AgentLoop flag is set to true during response generation
+        this.sessionStorage.setAgentLoopInProgress(tabID, true)
 
         const credentialsState = await AuthUtil.instance.getChatAuthState()
 
@@ -1339,23 +1354,15 @@ export class ChatController {
         triggerPayload.contextLengths.userInputContextLength = triggerPayload.message.length
         triggerPayload.contextLengths.focusFileContextLength = triggerPayload.fileText.length
 
+        const request = triggerPayloadToChatRequest(triggerPayload)
+
         const chatHistory = this.chatHistoryStorage.getTabHistory(tabID)
-        const newUserMessage = {
-            userInputMessage: {
-                content: triggerPayload.message,
-                userIntent: triggerPayload.userIntent,
-                ...(triggerPayload.origin && { origin: triggerPayload.origin }),
-                userInputMessageContext: {
-                    tools: tools,
-                    ...(triggerPayload.toolResults && { toolResults: triggerPayload.toolResults }),
-                },
-            },
+        const currentMessage = request.conversationState.currentMessage
+        if (currentMessage) {
+            chatHistory.fixHistory(currentMessage)
         }
-        const fixedHistoryMessage = chatHistory.fixHistory(newUserMessage)
-        if (fixedHistoryMessage.userInputMessage?.userInputMessageContext) {
-            triggerPayload.toolResults = fixedHistoryMessage.userInputMessage.userInputMessageContext.toolResults
-        }
-        const request = triggerPayloadToChatRequest(triggerPayload)
+        request.conversationState.history = chatHistory.getHistory()
+
         const conversationId = chatHistory.getConversationId() || randomUUID()
         chatHistory.setConversationId(conversationId)
         request.conversationState.conversationId = conversationId
@@ -1409,16 +1416,23 @@ export class ChatController {
             }
             this.telemetryHelper.recordEnterFocusConversation(triggerEvent.tabID)
             this.telemetryHelper.recordStartConversation(triggerEvent, triggerPayload)
-            chatHistory.appendUserMessage(fixedHistoryMessage)
+            if (currentMessage) {
+                chatHistory.appendUserMessage(currentMessage)
+            }
 
             getLogger().info(
                 `response to tab: ${tabID} conversationID: ${session.sessionIdentifier} requestID: ${
                     response.$metadata.requestId
                 } metadata: ${inspect(response.$metadata, { depth: 12 })}`
             )
             await this.messenger.sendAIResponse(response, session, tabID, triggerID, triggerPayload, chatHistory)
+
+            // Turn off AgentLoop flag after sending the AI response
+            this.sessionStorage.setAgentLoopInProgress(tabID, false)
         } catch (e: any) {
             this.telemetryHelper.recordMessageResponseError(triggerPayload, tabID, getHttpStatusCode(e) ?? 0)
+            // Turn off AgentLoop flag in case of exception
+            this.sessionStorage.setAgentLoopInProgress(tabID, false)
             // clears session, record telemetry before this call
             this.processException(e, tabID)
         }

packages/core/src/codewhispererChat/controllers/chat/messenger/messenger.ts

@@ -43,10 +43,11 @@ import { ChatItemButton, ChatItemContent, ChatItemFormItem, MynahIconsType, Myna
 import { ChatHistoryManager } from '../../../storages/chatHistory'
 import { ToolType, ToolUtils } from '../../../tools/toolUtils'
 import { ChatStream } from '../../../tools/chatStream'
-import { getWorkspaceForFile } from '../../../../shared/utilities/workspaceUtils'
 import path from 'path'
 import { CommandValidation } from '../../../tools/executeBash'
 import { extractErrorInfo } from '../../../../shared/utilities/messageUtil'
+import { Change } from 'diff'
+import { FsWriteParams } from '../../../tools/fsWrite'
 
 export type StaticTextResponseType = 'quick-action-help' | 'onboarding-help' | 'transform' | 'help'
 
@@ -219,8 +220,10 @@ export class Messenger {
 
                         const tool = ToolUtils.tryFromToolUse(toolUse)
                         if ('type' in tool) {
+                            let changeList: Change[] | undefined = undefined
                             if (tool.type === ToolType.FsWrite) {
                                 session.setShowDiffOnFileWrite(true)
+                                changeList = await tool.tool.getDiffChanges()
                             }
                             if (
                                 tool.type === ToolType.FsWrite ||
@@ -239,7 +242,8 @@ export class Messenger {
                                 triggerID,
                                 toolUse,
                                 validation,
-                                session.messageIdToUpdate
+                                session.messageIdToUpdate,
+                                changeList
                             )
                             await ToolUtils.queueDescription(tool, chatStream)
 
@@ -323,7 +327,7 @@ export class Messenger {
                 }
                 return true
             },
-            { timeout: 60000, truthy: true }
+            { timeout: 600000, truthy: true }
         )
             .catch((error: any) => {
                 const errorInfo = extractErrorInfo(error)
@@ -478,7 +482,8 @@ export class Messenger {
         triggerID: string,
         toolUse: ToolUse | undefined,
         validation: CommandValidation,
-        messageIdToUpdate: string | undefined
+        messageIdToUpdate: string | undefined,
+        changeList?: Change[]
     ) {
         const buttons: ChatItemButton[] = []
         let fileList: ChatItemContent['fileList'] = undefined
@@ -493,24 +498,29 @@ export class Messenger {
                 message = validation.warning + message
             }
         } else if (toolUse?.name === ToolType.FsWrite) {
-            const absoluteFilePath = (toolUse?.input as any).path
-            const projectPath = getWorkspaceForFile(absoluteFilePath)
-            const relativePath = projectPath ? path.relative(projectPath, absoluteFilePath) : absoluteFilePath
+            const input = toolUse.input as unknown as FsWriteParams
+            const fileName = path.basename(input.path)
+            const changes = changeList?.reduce(
+                (acc, { count = 0, added, removed }) => {
+                    if (added) {
+                        acc.added += count
+                    } else if (removed) {
+                        acc.deleted += count
+                    }
+                    return acc
+                },
+                { added: 0, deleted: 0 }
+            )
             // FileList
             fileList = {
                 fileTreeTitle: '',
                 hideFileCount: true,
-                filePaths: [relativePath],
+                filePaths: [fileName],
                 details: {
-                    [relativePath]: {
+                    [fileName]: {
                         // eslint-disable-next-line unicorn/no-null
                         icon: null,
-                        label: 'Created',
-                        changes: {
-                            added: 36,
-                            deleted: 0,
-                            total: 36,
-                        },
+                        changes: changes,
                     },
                 },
             }

packages/core/src/codewhispererChat/controllers/chat/model.ts

@@ -6,7 +6,6 @@
 import * as vscode from 'vscode'
 import {
     AdditionalContentEntry,
-    ChatMessage,
     Origin,
     RelevantTextDocument,
     ToolResult,
@@ -203,7 +202,6 @@ export interface TriggerPayload {
     traceId?: string
     contextLengths: ContextLengths
     workspaceRulesCount?: number
-    chatHistory?: ChatMessage[]
     toolResults?: ToolResult[]
     origin?: Origin
 }