@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/outputMonitor.js

@@ -13,21 +13,41 @@ import { ChatModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/cont
 import { ElicitationState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ChatMessageRole, getTextResponseFromStream } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service';
 import { OutputMonitorState, PollingConsts } from './types.js';
-import { getTextResponseFromStream } from './utils.js';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
-import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 
 let OutputMonitor = class OutputMonitor extends Disposable {
     get state() {
         return this._state;
     }
+    _formatLastLineForLog(output) {
+        if (!output) {
+            return "<empty>";
+        }
+        const lastLine = output.trimEnd().split(/\r?\n/).pop() ?? "";
+        if (!lastLine) {
+            return "<empty>";
+        }
+        if (this._isSensitivePrompt(lastLine)) {
+            return "<redacted>";
+        }
+        return lastLine.length > 200 ? lastLine.slice(0, 200) + "…" : lastLine;
+    }
+    _formatOptionsForLog(options) {
+        if (!options.length) {
+            return "[]";
+        }
+        const maxOptions = 12;
+        const shown = ( options.slice(0, maxOptions).map(o => o.replace(/\r?\n/g, "return")));
+        const suffix = options.length > maxOptions ? `, …(+${options.length - maxOptions})` : "";
+        return `[${shown.join(", ")}${suffix}]`;
+    }
     get pollingResult() {
         return this._pollingResult;
     }
@@ -88,11 +108,16 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 switch (this._state) {
                 case OutputMonitorState.PollingForIdle:
                     {
+                        this._logService.trace(`OutputMonitor: Entering PollingForIdle (extended=${extended})`);
                         this._state = await this._waitForIdle(this._execution, extended, token);
+                        this._logService.trace(
+                            `OutputMonitor: PollingForIdle completed -> state=${OutputMonitorState[this._state]}`
+                        );
                         continue;
                     }
                 case OutputMonitorState.Timeout:
                     {
+                        this._logService.trace(`OutputMonitor: Entering Timeout state (extended=${extended})`);
                         const shouldContinuePolling = await this._handleTimeoutState(command, invocationContext, extended, token);
                         if (shouldContinuePolling) {
                             extended = true;
@@ -108,11 +133,16 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                     break;
                 case OutputMonitorState.Idle:
                     {
+                        this._logService.trace("OutputMonitor: Entering Idle handler");
                         const idleResult = await this._handleIdleState(token);
                         if (idleResult.shouldContinuePollling) {
+                            this._logService.trace("OutputMonitor: Idle handler -> continue polling");
                             this._state = OutputMonitorState.PollingForIdle;
                             continue;
                         } else {
+                            this._logService.trace(
+                                `OutputMonitor: Idle handler -> stop polling (hasResources=${!!idleResult.resources}, hasModelEval=${!!idleResult.modelOutputEvalResponse}, outputLen=${idleResult.output?.length ?? 0})`
+                            );
                             resources = idleResult.resources;
                             modelOutputEvalResponse = idleResult.modelOutputEvalResponse;
                             output = idleResult.output;
@@ -128,6 +158,9 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 this._state = OutputMonitorState.Cancelled;
             }
         } finally {
+            this._logService.trace(
+                `OutputMonitor: Monitoring finished (state=${OutputMonitorState[this._state]}, duration=${Date.now() - pollStartTime}ms)`
+            );
             this._pollingResult = {
                 state: this._state,
                 output: output ?? this._execution.getOutput(),
@@ -150,7 +183,11 @@ let OutputMonitor = class OutputMonitor extends Disposable {
     }
     async _handleIdleState(token) {
         const output = this._execution.getOutput(this._lastPromptMarker);
+        this._logService.trace(
+            `OutputMonitor: Idle output summary: len=${output.length}, lastLine=${this._formatLastLineForLog(output)}`
+        );
         if (detectsNonInteractiveHelpPattern(output)) {
+            this._logService.trace("OutputMonitor: Idle -> non-interactive help pattern detected, stopping");
             return {
                 shouldContinuePollling: false,
                 output
@@ -159,12 +196,18 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         const isTask = this._execution.task !== undefined;
         const isTaskInactive = this._execution.isActive ? !(await this._execution.isActive()) : true;
         if (isTask && isTaskInactive && detectsVSCodeTaskFinishMessage(output)) {
+            this._logService.trace(
+                "OutputMonitor: Idle -> VS Code task finish message detected for inactive task, stopping"
+            );
             return {
                 shouldContinuePollling: false,
                 output
             };
         }
         if ((!isTask || !isTaskInactive) && detectsGenericPressAnyKeyPattern(output)) {
+            this._logService.trace(
+                "OutputMonitor: Idle -> generic \"press any key\" detected, requesting free-form input"
+            );
             const currentMarker = this._execution.instance.registerMarker();
             if (currentMarker) {
                 this._lastPromptMarker = currentMarker;
@@ -178,24 +221,38 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 detectedRequestForFreeFormInput: true
             }, true );
             if (receivedTerminalInput) {
+                this._logService.trace(
+                    "OutputMonitor: Free-form input received for \"press any key\", continue polling"
+                );
                 await timeout(200);
                 return {
                     shouldContinuePollling: true
                 };
             } else {
+                this._logService.trace("OutputMonitor: Free-form input declined for \"press any key\", stopping");
                 return {
                     shouldContinuePollling: false
                 };
             }
         }
         if (this._userInputtedSinceIdleDetected) {
+            this._logService.trace(
+                "OutputMonitor: User input detected since idle; skipping prompt and continuing polling"
+            );
             this._cleanupIdleInputListener();
             return {
                 shouldContinuePollling: true
             };
         }
+        this._logService.trace("OutputMonitor: Determining user input options via language model");
         const confirmationPrompt = await this._determineUserInputOptions(this._execution, token);
+        this._logService.trace(
+            `OutputMonitor: Input options result: ${confirmationPrompt ? `prompt=${this._formatLastLineForLog(confirmationPrompt.prompt)}, options=${confirmationPrompt.options.length} ${this._formatOptionsForLog(confirmationPrompt.options)}, freeForm=${!!confirmationPrompt.detectedRequestForFreeFormInput}` : "none"}`
+        );
         if (this._userInputtedSinceIdleDetected) {
+            this._logService.trace(
+                "OutputMonitor: User input arrived during input-option analysis; continuing polling"
+            );
             this._cleanupIdleInputListener();
             return {
                 shouldContinuePollling: true
@@ -203,27 +260,53 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         }
         if (confirmationPrompt?.detectedRequestForFreeFormInput) {
             if (this._userInputtedSinceIdleDetected) {
+                this._logService.trace(
+                    "OutputMonitor: User input arrived before showing free-form prompt; continuing polling"
+                );
                 this._cleanupIdleInputListener();
                 return {
                     shouldContinuePollling: true
                 };
             }
+            const autoReply = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoReplyToPrompts);
+            if (autoReply && !this._isSensitivePrompt(confirmationPrompt.prompt)) {
+                const explicitInput = confirmationPrompt.suggestedInput ?? this._extractExplicitInputFromPrompt(confirmationPrompt.prompt);
+                const normalizedInput = this._normalizeAutoReplyInput(explicitInput);
+                if (normalizedInput !== undefined) {
+                    this._logService.trace("OutputMonitor: Auto-replying to free-form prompt");
+                    await this._execution.instance.sendText(normalizedInput, true);
+                    this._outputMonitorTelemetryCounters.inputToolAutoAcceptCount++;
+                    this._outputMonitorTelemetryCounters.inputToolAutoChars += normalizedInput.length;
+                    return {
+                        shouldContinuePollling: true
+                    };
+                }
+            }
             this._cleanupIdleInputListener();
             this._outputMonitorTelemetryCounters.inputToolFreeFormInputShownCount++;
+            this._logService.trace("OutputMonitor: Showing free-form input elicitation");
             const receivedTerminalInput = await this._requestFreeFormTerminalInput(token, this._execution, confirmationPrompt);
             if (receivedTerminalInput) {
+                this._logService.trace("OutputMonitor: Free-form input received; continuing polling");
                 await timeout(200);
                 return {
                     shouldContinuePollling: true
                 };
             } else {
+                this._logService.trace("OutputMonitor: Free-form input declined; stopping");
                 return {
                     shouldContinuePollling: false
                 };
             }
         }
         if (confirmationPrompt?.options.length) {
+            this._logService.trace(
+                `OutputMonitor: Showing option-based input flow (options=${confirmationPrompt.options.length})`
+            );
             const suggestedOptionResult = await this._selectAndHandleOption(confirmationPrompt, token);
+            this._logService.trace(
+                `OutputMonitor: Suggested option result: ${suggestedOptionResult?.suggestedOption ? "hasSuggestion" : "none"} (autoSent=${!!suggestedOptionResult?.sentToTerminal})`
+            );
             if (suggestedOptionResult?.sentToTerminal) {
                 this._cleanupIdleInputListener();
                 return {
@@ -231,12 +314,16 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 };
             }
             if (this._userInputtedSinceIdleDetected) {
+                this._logService.trace(
+                    "OutputMonitor: User input arrived during option selection; continuing polling"
+                );
                 this._cleanupIdleInputListener();
                 return {
                     shouldContinuePollling: true
                 };
             }
             this._cleanupIdleInputListener();
+            this._logService.trace("OutputMonitor: Showing confirmation elicitation for suggested option");
             const confirmed = await this._confirmRunInTerminal(
                 token,
                 suggestedOptionResult?.suggestedOption ?? confirmationPrompt.options[0],
@@ -244,10 +331,12 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 confirmationPrompt
             );
             if (confirmed) {
+                this._logService.trace("OutputMonitor: Option confirmed/sent; continuing polling");
                 return {
                     shouldContinuePollling: true
                 };
             } else {
+                this._logService.trace("OutputMonitor: Option declined; stopping");
                 this._execution.instance.focus(true);
                 return {
                     shouldContinuePollling: false
@@ -256,8 +345,9 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         }
         this._cleanupIdleInputListener();
         const custom = await this._pollFn?.(this._execution, token, this._taskService);
+        this._logService.trace(`OutputMonitor: Custom poller result: ${custom ? "provided" : "none"}`);
         const resources = custom?.resources;
-        const modelOutputEvalResponse = await this._assessOutputForErrors(this._execution.getOutput(), token);
+        const modelOutputEvalResponse = this._pollFn ? undefined : await this._assessOutputForErrors(this._execution.getOutput(), token);
         return {
             resources,
             modelOutputEvalResponse,
@@ -291,12 +381,18 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 currentInterval = Math.min(currentInterval * 2, maxInterval);
                 const currentOutput = execution.getOutput();
                 if (detectsNonInteractiveHelpPattern(currentOutput)) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> non-interactive help detected (waited=${waited}ms)`
+                    );
                     this._state = OutputMonitorState.Idle;
                     this._setupIdleInputListener();
                     return this._state;
                 }
                 const promptResult = detectsInputRequiredPattern(currentOutput);
                 if (promptResult) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> input-required pattern detected (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentOutput)})`
+                    );
                     this._state = OutputMonitorState.Idle;
                     this._setupIdleInputListener();
                     return this._state;
@@ -313,6 +409,9 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                     `OutputMonitor: waitForIdle check: waited=${waited}ms, recentlyIdle=${recentlyIdle}, isActive=${isActive}`
                 );
                 if (recentlyIdle && isActive !== true) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> recentlyIdle && !active (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentOutput)})`
+                    );
                     this._state = OutputMonitorState.Idle;
                     this._setupIdleInputListener();
                     return this._state;
@@ -328,8 +427,10 @@ let OutputMonitor = class OutputMonitor extends Disposable {
     }
     _setupIdleInputListener() {
         this._userInputtedSinceIdleDetected = false;
+        this._logService.trace("OutputMonitor: Setting up idle input listener");
         this._userInputListener.value = this._execution.instance.onDidInputData(() => {
             this._userInputtedSinceIdleDetected = true;
+            this._logService.trace("OutputMonitor: Detected user terminal input while idle");
         });
     }
     _cleanupIdleInputListener() {
@@ -349,26 +450,29 @@ let OutputMonitor = class OutputMonitor extends Disposable {
             }]
         }], {}, token);
         try {
-            const responseFromStream = getTextResponseFromStream(response);
-            await Promise.all([response.result, responseFromStream]);
-            return await responseFromStream;
+            return await getTextResponseFromStream(response);
         } catch (err) {
             return "Error occurred " + err;
         }
     }
     async _determineUserInputOptions(execution, token) {
         if (token.isCancellationRequested) {
+            this._logService.trace("OutputMonitor: determineUserInputOptions cancelled before start");
             return;
         }
         const model = await this._getLanguageModel();
         if (!model) {
+            this._logService.trace("OutputMonitor: determineUserInputOptions no language model available");
             return undefined;
         }
         const lastLines = execution.getOutput(this._lastPromptMarker).trimEnd().split("\n").slice(-15).join("\n");
+        this._logService.trace(
+            `OutputMonitor: determineUserInputOptions analyzing lastLines (len=${lastLines.length})`
+        );
         if (detectsNonInteractiveHelpPattern(lastLines)) {
             return undefined;
         }
-        const promptText = `Analyze the following terminal output. If it contains a prompt requesting user input (such as a confirmation, selection, or yes/no question) that appears at the VERY END of the output and has NOT already been answered (i.e., there is no user response or subsequent output after the prompt), extract the prompt text. IMPORTANT: Only detect prompts that are at the end of the output with no content following them - if there is any output after the prompt, the prompt has already been answered and you should return null. The prompt may ask to choose from a set. If so, extract the possible options as a JSON object with keys 'prompt', 'options' (an array of strings or an object with option to description mappings), and 'freeFormInput': false. If no options are provided, and free form input is requested, for example: Password:, return the word freeFormInput. For example, if the options are "[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [C] Cancel", the option to description mappings would be {"Y": "Yes", "A": "Yes to All", "N": "No", "L": "No to All", "C": "Cancel"}. If there is no such prompt, return null. If the option is ambiguous, return null.
+        const promptText = `Analyze the following terminal output. If it contains a prompt requesting user input (such as a confirmation, selection, or yes/no question) that appears at the VERY END of the output and has NOT already been answered (i.e., there is no user response or subsequent output after the prompt), extract the prompt text. IMPORTANT: Only detect prompts that are at the end of the output with no content following them - if there is any output after the prompt, the prompt has already been answered and you should return null. The prompt may ask to choose from a set. If so, extract the possible options as a JSON object with keys 'prompt', 'options' (an array of strings or an object with option to description mappings), and 'freeFormInput': false. If no options are provided, and free form input is requested, return a JSON object with keys 'prompt', 'options', 'freeFormInput': true, and 'input'. The 'input' field should be the exact text to type only when the output explicitly states what to type (for example, Type "exit" to quit). If there is no explicit input, set 'input' to null. For Enter, set 'input' to "\\r". If the option is ambiguous, return null.
             Examples:
             1. Output: "Do you want to overwrite? (y/n)"
                 Response: {"prompt": "Do you want to overwrite?", "options": ["y", "n"], "freeFormInput": false}
@@ -389,7 +493,7 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 Response: {"prompt": "Continue", "options": ["y", "N"], "freeFormInput": false}
 
             7. Output: "Password:"
-                Response: {"prompt": "Password:", "freeFormInput": true, "options": []}
+                Response: {"prompt": "Password:", "freeFormInput": true, "options": [], "input": null}
             8. Output: "press ctrl-c to detach, ctrl-d to kill"
                 Response: null
             9. Output: "Continue (y/n)? y"
@@ -399,11 +503,13 @@ let OutputMonitor = class OutputMonitor extends Disposable {
 
             Alternatively, the prompt may request free form input, for example:
             1. Output: "Enter your username:"
-                Response: {"prompt": "Enter your username:", "freeFormInput": true, "options": []}
+                Response: {"prompt": "Enter your username:", "freeFormInput": true, "options": [], "input": null}
             2. Output: "Password:"
-                Response: {"prompt": "Password:", "freeFormInput": true, "options": []}
+                Response: {"prompt": "Password:", "freeFormInput": true, "options": [], "input": null}
             3. Output: "Press any key to continue..."
-                Response: {"prompt": "Press any key to continue...", "freeFormInput": true, "options": []}
+                Response: {"prompt": "Press any key to continue...", "freeFormInput": true, "options": [], "input": "\\r"}
+            4. Output: "Type 'exit' to quit the game."
+                Response: {"prompt": "Type 'exit' to quit the game.", "freeFormInput": true, "options": [], "input": "exit"}
             Now, analyze this output:
             ${lastLines}
             `;
@@ -418,16 +524,20 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         try {
             const match = responseText.match(/\{[\s\S]*\}/);
             if (match) {
-                const obj = JSON.parse(match[0]);
-                if (isObject(obj) && "prompt" in obj && isString(obj.prompt) && "options" in obj && "options" in obj && "freeFormInput" in obj && typeof obj.freeFormInput === "boolean") {
+                const parsed = JSON.parse(match[0]);
+                if (isObject(parsed) && Object.hasOwn(parsed, "prompt") && isString(parsed.prompt) && Object.hasOwn(parsed, "options") && Object.hasOwn(parsed, "freeFormInput") && typeof parsed.freeFormInput === "boolean") {
+                    const obj = parsed;
                     if (this._lastPrompt === obj.prompt) {
+                        this._logService.trace("OutputMonitor: determineUserInputOptions ignoring duplicate prompt");
                         return;
                     }
                     if (obj.freeFormInput === true) {
+                        const suggestedInput = isString(obj.input) && obj.input.trim().length ? obj.input.trim() : undefined;
                         return {
                             prompt: obj.prompt,
                             options: [],
-                            detectedRequestForFreeFormInput: true
+                            detectedRequestForFreeFormInput: true,
+                            suggestedInput
                         };
                     }
                     if (Array.isArray(obj.options) && obj.options.every(isString)) {
@@ -452,25 +562,61 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 }
             }
         } catch (err) {
-            console.error("Failed to parse confirmation prompt from language model response:", err);
+            this._logService.trace(
+                "OutputMonitor: Failed to parse confirmation prompt from language model response",
+                err
+            );
         }
         return undefined;
     }
-    async _selectAndHandleOption(confirmationPrompt, token) {
-        if (!confirmationPrompt?.options.length) {
+    _isSensitivePrompt(prompt) {
+        return /(password|passphrase|token|api\s*key|secret)/i.test(prompt);
+    }
+    _normalizeAutoReplyInput(input) {
+        if (!input) {
             return undefined;
         }
-        const model = this._chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat)[0]?.input.currentLanguageModel;
-        if (!model) {
+        const trimmed = input.trim();
+        if (!trimmed) {
             return undefined;
         }
-        const models = await this._languageModelsService.selectLanguageModels({
-            vendor: "copilot",
-            family: model.replaceAll("copilot/", "")
-        });
-        if (!models.length) {
+        const lowered = trimmed.toLowerCase();
+        if (lowered === "\\r" || lowered === "\\n" || lowered === "enter" || lowered === "return") {
+            return "";
+        }
+        return trimmed;
+    }
+    _extractExplicitInputFromPrompt(prompt) {
+        const normalizedPrompt = prompt.trim();
+        if (!normalizedPrompt) {
             return undefined;
         }
+        const directCommandMatch = normalizedPrompt.match(/\b(?:type|enter|input)\s+["'`]([^"'`]+)["'`]/i);
+        if (directCommandMatch?.[1]) {
+            return directCommandMatch[1];
+        }
+        const bareCommandMatch = normalizedPrompt.match(/\b(?:type|enter|input)\s+([\w.-]+)\b/i);
+        if (bareCommandMatch?.[1]) {
+            return bareCommandMatch[1];
+        }
+        return undefined;
+    }
+    async _selectAndHandleOption(confirmationPrompt, token) {
+        if (!confirmationPrompt?.options.length) {
+            return undefined;
+        }
+        const autoReply = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoReplyToPrompts);
+        let model = this._chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat)[0]?.input.currentLanguageModel;
+        if (model) {
+            const models = await this._languageModelsService.selectLanguageModels({
+                vendor: "copilot",
+                family: model.replaceAll("copilot/", "")
+            });
+            model = models[0];
+        }
+        if (!model) {
+            model = await this._getLanguageModel();
+        }
         const prompt = confirmationPrompt.prompt;
         const options = confirmationPrompt.options;
         const currentMarker = this._execution.instance.registerMarker();
@@ -479,26 +625,55 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         }
         this._lastPromptMarker = currentMarker;
         this._lastPrompt = prompt;
-        const promptText = `Given the following confirmation prompt and options from a terminal output, which option is the default?\nPrompt: "${prompt}"\nOptions: ${JSON.stringify(options)}\nRespond with only the option string.`;
-        const response = await this._languageModelsService.sendChatRequest(models[0], ( new ExtensionIdentifier("core")), [{
-            role: ChatMessageRole.User,
-            content: [{
-                type: "text",
-                value: promptText
-            }]
-        }], {}, token);
-        const suggestedOption = (await getTextResponseFromStream(response)).trim();
-        if (!suggestedOption) {
-            return;
+        let suggestedOption = "";
+        if (model) {
+            try {
+                const promptText = `Given the following confirmation prompt and options from a terminal output, which option is the default?\nPrompt: "${prompt}"\nOptions: ${JSON.stringify(options)}\nRespond with only the option string.`;
+                const response = await this._languageModelsService.sendChatRequest(model, ( new ExtensionIdentifier("core")), [{
+                    role: ChatMessageRole.User,
+                    content: [{
+                        type: "text",
+                        value: promptText
+                    }]
+                }], {}, token);
+                suggestedOption = (await getTextResponseFromStream(response)).trim();
+            } catch (err) {
+                this._logService.trace("OutputMonitor: Failed to get suggested option from model", err);
+            }
+        } else if (!autoReply) {
+            return undefined;
         }
-        const parsed = suggestedOption.replace(/['"`]/g, "").trim();
-        const index = confirmationPrompt.options.indexOf(parsed);
-        const validOption = confirmationPrompt.options.find(opt => parsed === opt.replace(/['"`]/g, "").trim());
-        if (!validOption || index === -1) {
-            return;
+        let validOption;
+        let index;
+        if (!suggestedOption) {
+            if (autoReply) {
+                validOption = options[0];
+                index = 0;
+                this._logService.trace(
+                    `OutputMonitor: No LLM suggestion, falling back to first option: ${validOption}`
+                );
+            } else {
+                return;
+            }
+        } else {
+            const match = matchTerminalPromptOption(confirmationPrompt.options, suggestedOption);
+            if (!match.option || match.index === -1) {
+                if (autoReply) {
+                    validOption = options[0];
+                    index = 0;
+                    this._logService.trace(
+                        `OutputMonitor: LLM suggestion '${suggestedOption}' didn't match options, falling back to first option: ${validOption}`
+                    );
+                } else {
+                    return;
+                }
+            } else {
+                validOption = match.option;
+                index = match.index;
+            }
         }
         let sentToTerminal = false;
-        if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoReplyToPrompts)) {
+        if (autoReply) {
             await this._execution.instance.sendText(validOption, true);
             this._outputMonitorTelemetryCounters.inputToolAutoAcceptCount++;
             this._outputMonitorTelemetryCounters.inputToolAutoChars += validOption?.length || 0;
@@ -521,11 +696,11 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         const {
             promise: userPrompt,
             part
-        } = this._createElicitationPart(token, execution.sessionId, ( new MarkdownString(( localize(12569, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
-            12570,
+        } = this._createElicitationPart(token, execution.sessionResource, ( new MarkdownString(( localize(13383, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
+            13384,
             "{0}\nPlease provide the required input to the terminal.\n\n",
             confirmationPrompt.prompt
-        )))), "", ( localize(12571, "Focus terminal")), undefined, () => {
+        )))), "", ( localize(13385, "Focus terminal")), undefined, () => {
             this._showInstance(execution.instance.instanceId);
             return focusTerminalSelection;
         });
@@ -578,17 +753,17 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         const {
             promise: userPrompt,
             part
-        } = this._createElicitationPart(token, execution.sessionId, ( new MarkdownString(( localize(12572, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
-            12573,
+        } = this._createElicitationPart(token, execution.sessionResource, ( new MarkdownString(( localize(13386, "The terminal is awaiting input.")))), ( new MarkdownString(( localize(
+            13387,
             "{0}\n Do you want to send `{1}`{2} followed by `Enter` to the terminal?",
             confirmationPrompt.prompt,
             suggestedOptionValue,
             isString(suggestedOption) ? "" : suggestedOption.description ? " (" + suggestedOption.description + ")" : ""
-        )))), "", ( localize(12574, "Allow")), ( localize(12575, "Focus Terminal")), async value => {
+        )))), "", ( localize(13388, "Allow")), ( localize(13389, "Focus Terminal")), async value => {
             let option = undefined;
             if (value === true) {
                 option = suggestedOptionValue;
-            } else if (typeof value === "object" && "label" in value) {
+            } else if (typeof value === "object" && Object.hasOwn(value, "label")) {
                 option = value.label.split(" (")[0];
             }
             this._outputMonitorTelemetryCounters.inputToolManualAcceptCount++;
@@ -654,7 +829,7 @@ let OutputMonitor = class OutputMonitor extends Disposable {
     }
     _createElicitationPart(
         token,
-        sessionId,
+        sessionResource,
         title,
         detail,
         subtitle,
@@ -664,7 +839,7 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         onReject,
         moreActions
     ) {
-        const chatModel = sessionId && this._chatService.getSession(LocalChatSessionUri.forSession(sessionId));
+        const chatModel = sessionResource && this._chatService.getSession(sessionResource);
         if (!(chatModel instanceof ChatModel)) {
             throw ( new Error("No model"));
         }
@@ -675,24 +850,30 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         let part;
         const promise = ( new Promise(resolve => {
             const thePart = part = ( new ChatElicitationRequestPart(title, detail, subtitle, acceptLabel, rejectLabel, async value => {
-                thePart.hide();
-                this._promptPart = undefined;
                 try {
                     const r = await (onAccept ? onAccept(value) : undefined);
                     resolve(r);
+                    if (typeof r === "symbol") {
+                        return ElicitationState.Pending;
+                    }
                 } catch {
                     resolve(undefined);
                 }
-                return ElicitationState.Accepted;
-            }, async () => {
                 thePart.hide();
                 this._promptPart = undefined;
+                return ElicitationState.Accepted;
+            }, async () => {
                 try {
                     const r = await (onReject ? onReject() : undefined);
                     resolve(r);
+                    if (typeof r === "symbol") {
+                        return ElicitationState.Pending;
+                    }
                 } catch {
                     resolve(undefined);
                 }
+                thePart.hide();
+                this._promptPart = undefined;
                 return ElicitationState.Rejected;
             },
             undefined, moreActions, () => this._outputMonitorTelemetryCounters.inputToolManualShownCount++));
@@ -706,16 +887,10 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         };
     }
     async _getLanguageModel() {
-        let models = await this._languageModelsService.selectLanguageModels({
+        const models = await this._languageModelsService.selectLanguageModels({
             vendor: "copilot",
             id: "copilot-fast"
         });
-        if (!models.length) {
-            models = await this._languageModelsService.selectLanguageModels({
-                vendor: "copilot",
-                family: "gpt-4o-mini"
-            });
-        }
         return models.length ? models[0] : undefined;
     }
 };
@@ -741,6 +916,46 @@ function getMoreActions(suggestedOption, confirmationPrompt) {
     }
     return moreActions.length ? moreActions : undefined;
 }
+function matchTerminalPromptOption(options, suggestedOption) {
+    const normalize = value => value.replace(/['"`]/g, "").trim().replace(/[.,:;]+$/, "");
+    const normalizedSuggestion = normalize(suggestedOption);
+    if (!normalizedSuggestion) {
+        return {
+            option: undefined,
+            index: -1
+        };
+    }
+    const candidates = [normalizedSuggestion];
+    const firstWhitespaceToken = normalizedSuggestion.split(/\s+/)[0];
+    if (firstWhitespaceToken && firstWhitespaceToken !== normalizedSuggestion) {
+        candidates.push(firstWhitespaceToken);
+    }
+    const firstAlphaNum = normalizedSuggestion.match(/[A-Za-z0-9]+/);
+    if (firstAlphaNum?.[0] && firstAlphaNum[0] !== normalizedSuggestion && firstAlphaNum[0] !== firstWhitespaceToken) {
+        candidates.push(firstAlphaNum[0]);
+    }
+    for (const candidate of candidates) {
+        const exactIndex = options.findIndex(opt => normalize(opt) === candidate);
+        if (exactIndex !== -1) {
+            return {
+                option: options[exactIndex],
+                index: exactIndex
+            };
+        }
+        const lowerCandidate = candidate.toLowerCase();
+        const ciIndex = options.findIndex(opt => normalize(opt).toLowerCase() === lowerCandidate);
+        if (ciIndex !== -1) {
+            return {
+                option: options[ciIndex],
+                index: ciIndex
+            };
+        }
+    }
+    return {
+        option: undefined,
+        index: -1
+    };
+}
 function detectsInputRequiredPattern(cursorLine) {
     return ([
         /\s*(?:\[[^\]]\]\s+[^\[\s][^\[]*\s*)+(?:\(default is\s+"[^"]+"\):)?\s+$/,
@@ -768,8 +983,8 @@ function detectsNonInteractiveHelpPattern(cursorLine) {
     ].some(e => e.test(cursorLine)));
 }
 const taskFinishMessages = [(
-localize(12576, "Terminal will be reused by tasks, press any key to close it.")), ( localize(12577, "Terminal will be reused by tasks, press any key to close it.")), (
-localize(12578, "Press any key to close the terminal.")), ( localize(12579, "Press any key to close the terminal."))];
+localize(13390, "Terminal will be reused by tasks, press any key to close it.")), ( localize(13391, "Terminal will be reused by tasks, press any key to close it.")), (
+localize(13392, "Press any key to close the terminal.")), ( localize(13393, "Press any key to close the terminal."))];
 function detectsVSCodeTaskFinishMessage(cursorLine) {
     const normalized = cursorLine.replace(/\s/g, "").toLowerCase();
     return (taskFinishMessages.some(msg => normalized.includes(msg.replace(/\s/g, "").toLowerCase())));
@@ -781,4 +996,4 @@ function detectsGenericPressAnyKeyPattern(cursorLine) {
     return /press a(?:ny)? key/i.test(cursorLine);
 }
 
-export { OutputMonitor, detectsGenericPressAnyKeyPattern, detectsInputRequiredPattern, detectsNonInteractiveHelpPattern, detectsVSCodeTaskFinishMessage };
+export { OutputMonitor, detectsGenericPressAnyKeyPattern, detectsInputRequiredPattern, detectsNonInteractiveHelpPattern, detectsVSCodeTaskFinishMessage, matchTerminalPromptOption };