@aws/lsp-codewhisperer 0.0.48 → 0.0.50

package/out/language-server/agenticChat/tools/chatDb/chatDb.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatDatabase = exports.EMPTY_CONVERSATION_LIST_ID = void 0;
+exports.ChatDatabase = exports.EMPTY_CONVERSATION_LIST_ID = exports.ToolResultValidationError = void 0;
 /*!
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -9,11 +9,19 @@ const Loki = require("lokijs");
 const util_1 = require("./util");
 const crypto = require("crypto");
 const path = require("path");
-const codewhisperer_streaming_1 = require("@amzn/codewhisperer-streaming");
+const codewhisperer_streaming_client_1 = require("@aws/codewhisperer-streaming-client");
 const path_1 = require("@aws/lsp-core/out/util/path");
+const chatHistoryMaintainer_1 = require("./chatHistoryMaintainer");
+class ToolResultValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ToolResultValidationError';
+    }
+}
+exports.ToolResultValidationError = ToolResultValidationError;
 exports.EMPTY_CONVERSATION_LIST_ID = 'empty';
-// Maximum number of messages to keep in history
-const MaxConversationHistoryMessages = 250;
+// Maximum number of history messages to include in each request to the LLM
+const maxConversationHistoryMessages = 250;
 /**
  * A singleton database class that manages chat history persistence using LokiJS.
  * This class handles storage and retrieval of chat conversations, messages, and tab states
@@ -36,6 +44,7 @@ class ChatDatabase {
     #initialized = false;
     #loadTimeMs;
     #dbFileSize;
+    #historyMaintainer;
     constructor(features) {
         this.#features = features;
         this.#dbDirectory = path.join(features.runtime.platform === 'browser'
@@ -45,13 +54,12 @@ class ChatDatabase {
         const dbName = `chat-history-${workspaceId}.json`;
         const dbPath = path.join(this.#dbDirectory, dbName);
         this.#features.logging.log(`Initializing database at ${dbPath}`);
-        this.#features.workspace.fs
-            .getFileSize(dbPath)
-            .then(({ size }) => {
+        (0, util_1.calculateDatabaseSize)(this.#features, dbPath)
+            .then(size => {
             this.#dbFileSize = size;
         })
             .catch(err => {
-            this.#features.logging.log(`Error getting db file size: ${err}`);
+            this.#features.logging.warn(`Error getting db file size: ${err}`);
         });
         const startTime = Date.now();
         this.#db = new Loki(dbName, {
@@ -62,6 +70,12 @@ class ChatDatabase {
             autosaveInterval: 1000,
             persistenceMethod: 'fs',
         });
+        this.#historyMaintainer = new chatHistoryMaintainer_1.ChatHistoryMaintainer(features, this.#dbDirectory, dbName, this.#db);
+        // Async process: Trimming history asynchronously if the size exceeds the max
+        // This process will take several seconds
+        this.#historyMaintainer.trimHistoryToMaxSize().catch(err => {
+            this.#features.logging.error(`Error trimming history: ${err}`);
+        });
     }
     static getInstance(features) {
         if (!ChatDatabase.#instance) {
@@ -73,6 +87,12 @@ class ChatDatabase {
         this.#db.close();
         ChatDatabase.#instance = undefined;
     }
+    /**
+     * Returns whether the database has been initialized.
+     */
+    isInitialized() {
+        return this.#initialized;
+    }
     setHistoryIdMapping(tabId, historyId) {
         this.#features.logging.log(`Setting historyIdMapping: tabId=${tabId}, historyId=${historyId}`);
         this.#historyIdMapping.set(tabId, historyId);
@@ -120,16 +140,124 @@ class ChatDatabase {
         this.#loadTimeMs = Date.now() - startTime;
     }
     getOpenTabs() {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const collection = this.#db.getCollection(util_1.TabCollection);
             return collection.find({ isOpen: true });
         }
     }
+    addTabWithContext(collection, historyId, tabContext) {
+        collection.insert({
+            tabType: 'cwc',
+            historyId,
+            title: 'Amazon Q Chat',
+            conversations: [],
+            isOpen: true,
+            updatedAt: new Date(),
+            tabContext,
+        });
+    }
+    getRules(tabId) {
+        if (this.#initialized) {
+            const collection = this.#db.getCollection(util_1.TabCollection);
+            const historyId = this.#historyIdMapping.get(tabId);
+            if (historyId) {
+                const tab = collection.findOne({ historyId });
+                return tab?.tabContext?.rules || { folders: {}, rules: {} };
+            }
+        }
+        return { folders: {}, rules: {} };
+    }
+    getPinnedContext(tabId) {
+        if (this.#initialized) {
+            const collection = this.#db.getCollection(util_1.TabCollection);
+            const historyId = this.getOrCreateHistoryId(tabId);
+            if (historyId) {
+                const tab = collection.findOne({ historyId });
+                return tab?.tabContext?.pinnedContext || util_1.DEFAULT_PINNED_CONTEXT;
+            }
+        }
+        return [];
+    }
+    setRules(tabId, rules) {
+        if (this.#initialized) {
+            const collection = this.#db.getCollection(util_1.TabCollection);
+            const historyId = this.getOrCreateHistoryId(tabId);
+            const tab = collection.findOne({ historyId });
+            this.#features.logging.log(`Updating rules: rules=${JSON.stringify(rules)}`);
+            if (!tab) {
+                this.addTabWithContext(collection, historyId, { rules });
+            }
+            else {
+                if (!tab.tabContext) {
+                    tab.tabContext = {};
+                }
+                tab.tabContext.rules = rules;
+                collection.update(tab);
+            }
+        }
+    }
+    addPinnedContext(tabId, context) {
+        if (this.#initialized) {
+            const collection = this.#db.getCollection(util_1.TabCollection);
+            const historyId = this.getOrCreateHistoryId(tabId);
+            if (historyId) {
+                this.#features.logging.log(`Adding pinned context: historyId=${historyId}, context=${JSON.stringify(context)}`);
+                const tab = collection.findOne({ historyId });
+                if (!tab) {
+                    this.addTabWithContext(collection, historyId, {
+                        pinnedContext: util_1.DEFAULT_PINNED_CONTEXT.concat([context]),
+                    });
+                }
+                else {
+                    if (!tab.tabContext) {
+                        tab.tabContext = {};
+                    }
+                    if (!tab.tabContext.pinnedContext) {
+                        tab.tabContext.pinnedContext = util_1.DEFAULT_PINNED_CONTEXT;
+                    }
+                    // Only add context item if its not already in this tab's pinned context
+                    if (!tab.tabContext.pinnedContext.find(c => c.id === context.id)) {
+                        // Active file pill should always be at the beginning of pinned context
+                        if (util_1.DEFAULT_PINNED_CONTEXT.find(item => context.id === item.id)) {
+                            tab.tabContext.pinnedContext.unshift(context);
+                        }
+                        else {
+                            tab.tabContext.pinnedContext.push(context);
+                        }
+                    }
+                    collection.update(tab);
+                }
+            }
+        }
+    }
+    removePinnedContext(tabId, context) {
+        if (this.#initialized) {
+            const collection = this.#db.getCollection(util_1.TabCollection);
+            const historyId = this.getOrCreateHistoryId(tabId);
+            if (historyId) {
+                this.#features.logging.log(`Removing pinned context: historyId=${historyId}, context=${JSON.stringify(context)}`);
+                const tab = collection.findOne({ historyId });
+                if (!tab) {
+                    this.addTabWithContext(collection, historyId, { pinnedContext: [] });
+                }
+                else {
+                    if (!tab.tabContext) {
+                        tab.tabContext = {};
+                    }
+                    if (!tab.tabContext.pinnedContext) {
+                        tab.tabContext.pinnedContext = [];
+                    }
+                    tab.tabContext.pinnedContext = tab.tabContext.pinnedContext.filter(c => c.id !== context.id);
+                    collection.update(tab);
+                }
+            }
+        }
+    }
     getLoadTime() {
         return this.#loadTimeMs;
     }
     getTab(historyId) {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const collection = this.#db.getCollection(util_1.TabCollection);
             return collection.findOne({ historyId });
         }
@@ -150,7 +278,7 @@ class ChatDatabase {
      * Delete a conversation from history when /clear command is sent on an open tab
      */
     clearTab(tabId) {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const tabCollection = this.#db.getCollection(util_1.TabCollection);
             const historyId = this.#historyIdMapping.get(tabId);
             if (historyId) {
@@ -161,7 +289,7 @@ class ChatDatabase {
         }
     }
     updateTabOpenState(tabId, isOpen) {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const tabCollection = this.#db.getCollection(util_1.TabCollection);
             const historyId = this.#historyIdMapping.get(tabId);
             if (historyId) {
@@ -188,7 +316,7 @@ class ChatDatabase {
     searchMessages(filter) {
         let searchResults = [];
         const startTime = Date.now();
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             if (!filter) {
                 this.#features.logging.log(`Empty search filter, returning all history`);
                 return { results: this.getHistory(), searchTime: Date.now() - startTime };
@@ -219,13 +347,13 @@ class ChatDatabase {
      * @param numMessages Optional number of most recent messages to return. If not provided, returns all messages.
      */
     getMessages(tabId, numMessages) {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const tabCollection = this.#db.getCollection(util_1.TabCollection);
             const historyId = this.#historyIdMapping.get(tabId);
             this.#features.logging.log(`Getting messages for tabId=${tabId}, historyId=${historyId}, numMessages=${numMessages}`);
             const tabData = historyId ? tabCollection.findOne({ historyId }) : undefined;
             if (tabData) {
-                const allMessages = tabData.conversations.flatMap((conversation) => conversation.messages.map(msg => (0, util_1.messageToStreamingMessage)(msg)));
+                const allMessages = tabData.conversations.flatMap((conversation) => conversation.messages);
                 if (numMessages !== undefined) {
                     return allMessages.slice(-numMessages);
                 }
@@ -238,7 +366,7 @@ class ChatDatabase {
      * Get all conversations for the current workspace, grouped by last updated time
      */
     getHistory() {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const tabCollection = this.#db.getCollection(util_1.TabCollection);
             const tabs = tabCollection.find();
             let groupedTabs = (0, util_1.groupTabsByDate)(tabs);
@@ -256,7 +384,7 @@ class ChatDatabase {
      * Deletes a conversation from history
      */
     deleteHistory(historyId) {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const tabCollection = this.#db.getCollection(util_1.TabCollection);
             tabCollection.findAndRemove({ historyId });
             this.#features.logging.log(`Removed conversation from history with historyId=${historyId}`);
@@ -266,6 +394,15 @@ class ChatDatabase {
             }
         }
     }
+    getOrCreateHistoryId(tabId) {
+        let historyId = this.#historyIdMapping.get(tabId);
+        if (!historyId) {
+            historyId = crypto.randomUUID();
+            this.#features.logging.log(`Creating new historyId=${historyId} for tabId=${tabId}`);
+            this.setHistoryIdMapping(tabId, historyId);
+        }
+        return historyId;
+    }
     /**
      * Adds a message to a conversation within a specified tab.
      *
@@ -276,16 +413,11 @@ class ChatDatabase {
      * - Updates tab's last updated time
      */
     addMessage(tabId, tabType, conversationId, message) {
-        if (this.#initialized) {
+        if (this.isInitialized()) {
             const clientType = this.#features.lsp.getClientInitializeParams()?.clientInfo?.name || 'unknown';
             const tabCollection = this.#db.getCollection(util_1.TabCollection);
             this.#features.logging.log(`Adding message to history: tabId=${tabId}, tabType=${tabType}, conversationId=${conversationId}`);
-            let historyId = this.#historyIdMapping.get(tabId);
-            if (!historyId) {
-                historyId = crypto.randomUUID();
-                this.#features.logging.log(`Creating new historyId=${historyId} for tabId=${tabId}`);
-                this.setHistoryIdMapping(tabId, historyId);
-            }
+            let historyId = this.getOrCreateHistoryId(tabId);
             const tabData = historyId ? tabCollection.findOne({ historyId }) : undefined;
             const tabTitle = (message.type === 'prompt' && message.shouldDisplayMessage !== false && message.body.trim().length > 0
                 ? message.body
@@ -306,7 +438,7 @@ class ChatDatabase {
                     isOpen: true,
                     tabType: tabType,
                     title: tabTitle,
-                    conversations: [{ conversationId, clientType, messages: [message] }],
+                    conversations: [{ conversationId, clientType, updatedAt: new Date(), messages: [message] }],
                 });
             }
         }
@@ -331,39 +463,29 @@ class ChatDatabase {
         return message;
     }
     /**
-     * Fixes the history to maintain the following invariants:
+     * Prepare the history messages for service request and fix the persisted history in DB to maintain the following invariants:
      * 1. The history contains at most MaxConversationHistoryMessages messages. Oldest messages are dropped.
-     * 2. The first message is from the user. Oldest messages are dropped if needed.
-     * 3. The last message is from the assistant. The last message is dropped if it is from the user.
-     * 4. The history contains alternating sequene of userMessage followed by assistantMessages
-     * 5. The toolUse and toolResult relationship is valid
-     * 6. The history character length is <= MaxConversationHistoryCharacters - newUserMessageCharacterCount. Oldest messages are dropped.
+     * 2. The first message is from the user and without any tool usage results, and the last message is from the assistant.
+     *    The history contains alternating sequene of userMessage followed by assistantMessages
+     * 3. The toolUse and toolResult relationship is valid
+     * 4. The history character length is <= MaxConversationHistoryCharacters - newUserMessageCharacterCount. Oldest messages are dropped.
      */
-    fixAndValidateHistory(tabId, newUserMessage, conversationId, remainingCharacterBudget) {
-        if (!this.#initialized) {
-            return true;
-        }
-        const historyId = this.#historyIdMapping.get(tabId);
-        this.#features.logging.info(`Fixing history: tabId=${tabId}, historyId=${historyId || 'undefined'}`);
-        if (!historyId) {
-            return true;
-        }
-        const tabCollection = this.#db.getCollection(util_1.TabCollection);
-        const tabData = tabCollection.findOne({ historyId });
-        if (!tabData) {
-            return true;
-        }
-        let allMessages = tabData.conversations.flatMap((conversation) => conversation.messages);
-        this.#features.logging.info(`Found ${allMessages.length} messages in conversation`);
-        //  Make sure we don't exceed MaxConversationHistoryMessages
-        allMessages = this.trimHistoryToMaxLength(allMessages);
-        //  Drop empty assistant partial if it’s the last message
-        this.handleEmptyAssistantMessage(allMessages);
-        //  Ensure messages in history a valid for server side checks
-        this.ensureValidMessageSequence(allMessages, newUserMessage);
-        // Ensure lastMessage in history toolUse and newMessage toolResult relationship is valid
-        const isValid = this.validateNewMessageToolResults(allMessages, newUserMessage);
-        //  Make sure max characters ≤ remaining Character Budget
+    fixAndGetHistory(tabId, newUserMessage, remainingCharacterBudget) {
+        if (!this.isInitialized()) {
+            return [];
+        }
+        this.#features.logging.info(`Fixing history: tabId=${tabId}`);
+        // 1. Make sure the length of the history messages don't exceed MaxConversationHistoryMessages
+        let allMessages = this.getMessages(tabId, maxConversationHistoryMessages);
+        if (allMessages.length === 0) {
+            return [];
+        }
+        // 2. Fix history: Ensure messages in history is valid for server side checks
+        this.ensureValidMessageSequence(tabId, allMessages);
+        // 3. Fix new user prompt: Ensure lastMessage in history toolUse and newMessage toolResult relationship is valid
+        this.validateAndFixNewMessageToolResults(allMessages, newUserMessage);
+        // 4. NOTE: Keep this trimming logic at the end of the preprocess.
+        // Make sure max characters ≤ remaining Character Budget, must be put at the end of preprocessing
         allMessages = this.trimMessagesToMaxLength(allMessages, remainingCharacterBudget);
         // Edge case: If the history is empty and the next message contains tool results, then we have to just abandon them.
         if (allMessages.length === 0 &&
@@ -373,34 +495,19 @@ class ChatDatabase {
             newUserMessage.userInputMessage.userInputMessageContext.toolResults = [];
             newUserMessage.userInputMessage.content = 'The conversation history has overflowed, clearing state';
         }
-        const clientType = this.#features.lsp.getClientInitializeParams()?.clientInfo?.name || 'unknown';
-        tabData.conversations = [
-            {
-                conversationId: conversationId,
-                clientType: clientType,
-                messages: allMessages,
-            },
-        ];
-        tabData.updatedAt = new Date();
-        tabCollection.update(tabData);
-        this.#features.logging.info(`Updated tab data in collection`);
-        return isValid;
-    }
-    trimHistoryToMaxLength(messages) {
-        while (messages.length > MaxConversationHistoryMessages) {
-            // Find the next valid user message to start from
-            const indexToTrim = this.findIndexToTrim(messages);
-            if (indexToTrim !== undefined && indexToTrim > 0) {
-                this.#features.logging.debug(`Removing the first ${indexToTrim} elements to maintain valid history length`);
-                messages.splice(0, indexToTrim);
-            }
-            else {
-                this.#features.logging.debug('Could not find a valid point to trim, reset history to reduce history size');
-                return [];
-            }
-        }
-        return messages;
+        return allMessages;
     }
+    /**
+     * Finds a suitable "break point" index in the message sequence.
+     *
+     * It ensures that the "break point" is at a clean conversation boundary where:
+     * 1. The message is from a user (type === 'prompt')
+     * 2. The message doesn't contain tool results that would break tool use/result pairs
+     * 3. The message has a non-empty body
+     *
+     * @param allMessages The array of conversation messages to search through
+     * @returns The index to trim from, or undefined if no suitable trimming point is found
+     */
     findIndexToTrim(allMessages) {
         for (let i = 2; i < allMessages.length; i++) {
             const message = allMessages[i];
@@ -414,18 +521,6 @@ class ChatDatabase {
         const ctx = message.userInputMessageContext;
         return !!ctx && (!ctx.toolResults || ctx.toolResults.length === 0) && message.body !== '';
     }
-    handleEmptyAssistantMessage(messages) {
-        if (messages.length < 2) {
-            return;
-        }
-        const lastMsg = messages[messages.length - 1];
-        if (lastMsg.type === 'answer' &&
-            (!lastMsg.body || lastMsg.body.trim().length === 0) &&
-            (!lastMsg.toolUses || lastMsg.toolUses.length === 0)) {
-            this.#features.logging.debug('Last message is empty partial assistant. Removed last assistant message and user message');
-            messages.splice(-2);
-        }
-    }
     trimMessagesToMaxLength(messages, remainingCharacterBudget) {
         let totalCharacters = this.calculateHistoryCharacterCount(messages);
         this.#features.logging.debug(`Current history characters: ${totalCharacters}`);
@@ -493,55 +588,95 @@ class ChatDatabase {
         }
         return count;
     }
-    ensureValidMessageSequence(messages, newUserMessage) {
+    /**
+     * Gets the latest conversation ID for a given tab
+     * @param tabId The ID of the tab to get the latest conversation ID from
+     * @returns The latest conversation ID, or an empty string if none exists
+     */
+    getLatestConversationId(tabId) {
+        const tabCollection = this.#db.getCollection(util_1.TabCollection);
+        const historyId = this.#historyIdMapping.get(tabId);
+        const tabData = historyId ? tabCollection.findOne({ historyId }) : undefined;
+        const lastConversationLength = tabData?.conversations?.length || 0;
+        if (lastConversationLength > 0) {
+            return tabData?.conversations[lastConversationLength - 1].conversationId || '';
+        }
+        return '';
+    }
+    /**
+     * Ensures that the message sequence follows the required pattern for a valid conversation.
+     *
+     * This method enforces two key rules:
+     * 1. The first message must be from the user (type === 'prompt')
+     * 2. The last message must be from the assistant (type === 'answer')
+     *
+     * If the first rule is violated, leading assistant messages are removed.
+     * If the second rule is violated, a dummy response is added to maintain the alternating user-assistant pattern.
+     *
+     * @param tabId - The current tabId.
+     * @param messages - The message history to validate and potentially modify, this will be attached to the service request.
+     */
+    ensureValidMessageSequence(tabId, messages) {
         if (messages.length === 0) {
             return;
         }
-        //  Make sure the first stored message is from the user (type === 'prompt'), else drop
+        // Make sure the first message sent to LLM is from the user (type === 'prompt'), else drop
         while (messages.length > 0 && messages[0].type === 'answer') {
             messages.shift();
             this.#features.logging.debug('Dropped first message since it is not from user');
         }
-        //  Make sure the last stored message is from the assistant (type === 'answer'), else drop
-        if (messages.length > 0 && messages[messages.length - 1].type === 'prompt') {
-            // When user aborts some in-progress tooluse event, we should still send the previous toolResult back
-            if (messages[messages.length - 1].userInputMessageContext?.toolResults) {
-                if (newUserMessage.userInputMessage?.userInputMessageContext) {
-                    newUserMessage.userInputMessage.userInputMessageContext.toolResults =
-                        messages[messages.length - 1].userInputMessageContext?.toolResults;
-                }
-            }
-            messages.pop();
-            this.#features.logging.debug('Dropped trailing user message');
-        }
-        if (messages.length === 0) {
-            return;
+        // Make sure the first user message doesn't have tool usage results.
+        while (messages.length > 0 &&
+            messages[0].type === 'prompt' &&
+            !this.isValidUserMessageWithoutToolResults(messages[0])) {
+            // Remove first user-assistant pair - here we assume that the mid-sequence messages are always in the alternating user-assistant pattern
+            messages.splice(0, 2);
+            this.#features.logging.debug('Dropped the first message pair since the user message has tool usage results');
         }
-        //  Make sure there are alternating user and assistant messages
-        const currentMessageType = (0, util_1.chatMessageToMessage)(newUserMessage).type;
-        const lastMessageType = messages[messages.length - 1].type;
-        if (currentMessageType === lastMessageType) {
-            this.#features.logging.warn(`Invalid alternation: last message is ${lastMessageType}, dropping it before inserting new ${currentMessageType}`);
-            messages.splice(messages.length - 1, 1);
+        //  Make sure the last message is from the assistant (type === 'answer'), else add a dummy response
+        if (messages.length > 0 && messages[messages.length - 1].type === 'prompt') {
+            // Add an assistant response to both request and DB to maintain a valid sequence
+            const dummyResponse = {
+                body: 'Thinking...',
+                type: 'answer',
+                shouldDisplayMessage: false,
+                timestamp: new Date(),
+            };
+            // Add to service request
+            messages.push(dummyResponse);
+            // Add to the last conversation in history DB
+            const lastConversationId = this.getLatestConversationId(tabId);
+            this.addMessage(tabId, 'cwc', lastConversationId, dummyResponse);
+            this.#features.logging.debug('Added a dummy response for the trailing user message');
         }
     }
-    validateNewMessageToolResults(messages, newUserMessage) {
+    /**
+     * This method modifies the new user message and ensuring that tool results in a new user message
+     * properly correspond to tool uses from the previous assistant message.
+     *
+     * This validation should be performed before sending requests and is critical for maintaining
+     * a coherent conversation flow when tools are involved, ensuring the AI model has accurate context
+     * about which tools were actually used and which were cancelled or failed.
+     *
+     * @param messages The conversation history messages
+     * @param newUserMessage The new user message being added to the conversation
+     * @throws ToolResultValidationError if the message is invalid and not able to be fixed
+     */
+    validateAndFixNewMessageToolResults(messages, newUserMessage) {
         if (newUserMessage?.userInputMessage?.userInputMessageContext) {
             const newUserMessageContext = newUserMessage.userInputMessage.userInputMessageContext;
             const toolResults = newUserMessageContext.toolResults || [];
             if (messages.length === 0) {
                 if (toolResults && toolResults.length > 0) {
-                    this.#features.logging.warn('New message has tool results but last message has no tool uses');
-                    return false;
+                    throw new ToolResultValidationError('New message has tool results but last message has no tool uses');
                 }
-                return true;
+                return;
             }
             const lastMsg = messages[messages.length - 1];
             const lastMsgToolUses = lastMsg?.toolUses || [];
             // If last message has no tool uses but new message has tool results, this is invalid
             if (toolResults && toolResults.length > 0 && lastMsgToolUses.length === 0) {
-                this.#features.logging.warn('New message has tool results but last message has no tool uses');
-                return false;
+                throw new ToolResultValidationError('New message has tool results but last message has no tool uses');
             }
             const toolUseIds = new Set(lastMsgToolUses.map(toolUse => toolUse.toolUseId));
             const validToolResults = toolResults.filter(toolResult => toolUseIds.has(toolResult.toolUseId));
@@ -552,7 +687,7 @@ class ChatDatabase {
                     this.#features.logging.warn(`newUserMessage missing ToolResult for ${toolUse.toolUseId}. Inserting cancelled.`);
                     validToolResults.push({
                         toolUseId: toolUse.toolUseId,
-                        status: codewhisperer_streaming_1.ToolResultStatus.ERROR,
+                        status: codewhisperer_streaming_client_1.ToolResultStatus.ERROR,
                         content: [{ text: 'Tool use was cancelled by the user' }],
                     });
                 }
@@ -560,10 +695,9 @@ class ChatDatabase {
             newUserMessageContext.toolResults = validToolResults;
             if (newUserMessageContext.toolResults.length === 0 &&
                 (!newUserMessage.userInputMessage.content || newUserMessage.userInputMessage.content?.trim() == '')) {
-                return false;
+                throw new ToolResultValidationError('Empty message with no tool results');
             }
         }
-        return true;
     }
     getSettings() {
         if (this.#initialized) {