@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatService.js

@@ -2,6 +2,7 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
@@ -9,16 +10,22 @@ import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { TerminalChatContextKeys } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
-import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { LocalChatSessionUri, chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { isNumber, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 
 var StorageKeys;
-(function (StorageKeys) {
+(function(StorageKeys) {
     StorageKeys["ToolSessionMappings"] = "terminalChat.toolSessionMappings";
     StorageKeys["CommandIdMappings"] = "terminalChat.commandIdMappings";
 })(StorageKeys || (StorageKeys = {}));
 let TerminalChatService = class TerminalChatService extends Disposable {
-    constructor(_logService, _terminalService, _storageService, _contextKeyService, _chatService) {
+    constructor(
+        _logService,
+        _terminalService,
+        _storageService,
+        _contextKeyService,
+        _chatService
+    ) {
         super();
         this._logService = _logService;
         this._terminalService = _terminalService;
@@ -27,30 +34,32 @@ let TerminalChatService = class TerminalChatService extends Disposable {
         this._chatService = _chatService;
         this._terminalInstancesByToolSessionId = ( new Map());
         this._toolSessionIdByTerminalInstance = ( new Map());
-        this._chatSessionIdByTerminalInstance = ( new Map());
+        this._chatSessionResourceByTerminalInstance = ( new Map());
         this._terminalInstanceListenersByToolSessionId = this._register(( new DisposableMap()));
         this._chatSessionListenersByTerminalInstance = this._register(( new DisposableMap()));
-        this._onDidRegisterTerminalInstanceForToolSession = ( new Emitter());
+        this._onDidContinueInBackground = this._register(( new Emitter()));
+        this.onDidContinueInBackground = this._onDidContinueInBackground.event;
+        this._onDidRegisterTerminalInstanceForToolSession = this._register(( new Emitter()));
         this.onDidRegisterTerminalInstanceWithToolSession = this._onDidRegisterTerminalInstanceForToolSession.event;
         this._activeProgressParts = ( new Set());
         this._pendingRestoredMappings = ( new Map());
-        this._sessionAutoApprovalEnabled = ( new Set());
-        this._sessionAutoApproveRules = ( new Map());
+        this._sessionAutoApprovalEnabled = ( new ResourceMap());
+        this._sessionAutoApproveRules = ( new ResourceMap());
         this._hasToolTerminalContext = TerminalChatContextKeys.hasChatTerminals.bindTo(this._contextKeyService);
         this._hasHiddenToolTerminalContext = TerminalChatContextKeys.hasHiddenChatTerminals.bindTo(this._contextKeyService);
         this._restoreFromStorage();
         this._register(this._chatService.onDidDisposeSession(e => {
             for (const resource of e.sessionResource) {
-                const sessionId = LocalChatSessionUri.parseLocalSessionId(resource);
-                if (sessionId) {
-                    this._sessionAutoApproveRules.delete(sessionId);
-                }
+                this._sessionAutoApproveRules.delete(resource);
+                this._sessionAutoApprovalEnabled.delete(resource);
             }
         }));
     }
     registerTerminalInstanceWithToolSession(terminalToolSessionId, instance) {
         if (!terminalToolSessionId) {
-            this._logService.warn('Attempted to register a terminal instance with an undefined tool session ID');
+            this._logService.warn(
+                "Attempted to register a terminal instance with an undefined tool session ID"
+            );
             return;
         }
         this._terminalInstancesByToolSessionId.set(terminalToolSessionId, instance);
@@ -69,16 +78,15 @@ let TerminalChatService = class TerminalChatService extends Disposable {
                     this._terminalInstancesByToolSessionId.delete(terminalToolSessionId);
                     this._toolSessionIdByTerminalInstance.delete(instance);
                     this._terminalInstanceListenersByToolSessionId.deleteAndDispose(terminalToolSessionId);
-                    const sessionId = LocalChatSessionUri.parseLocalSessionId(resource);
-                    if (sessionId) {
-                        this._sessionAutoApprovalEnabled.delete(sessionId);
-                    }
+                    this._sessionAutoApprovalEnabled.delete(resource);
                     this._persistToStorage();
                     this._updateHasToolTerminalContextKeys();
                 }
             }
         }));
-        this._register(this._terminalService.onDidChangeInstances(() => this._updateHasToolTerminalContextKeys()));
+        this._register(
+            this._terminalService.onDidChangeInstances(() => this._updateHasToolTerminalContextKeys())
+        );
         if (isNumber(instance.shellLaunchConfig?.attachPersistentProcess?.id) || isNumber(instance.persistentProcessId)) {
             this._persistToStorage();
         }
@@ -90,7 +98,9 @@ let TerminalChatService = class TerminalChatService extends Disposable {
             return undefined;
         }
         if (( this._pendingRestoredMappings.has(terminalToolSessionId))) {
-            const instance = this._terminalService.instances.find(i => i.shellLaunchConfig.attachPersistentProcess?.id === this._pendingRestoredMappings.get(terminalToolSessionId));
+            const instance = this._terminalService.instances.find(
+                i => i.shellLaunchConfig.attachPersistentProcess?.id === this._pendingRestoredMappings.get(terminalToolSessionId)
+            );
             if (instance) {
                 this._tryAdoptRestoredMapping(instance);
                 return instance;
@@ -109,20 +119,25 @@ let TerminalChatService = class TerminalChatService extends Disposable {
     getToolSessionIdForInstance(instance) {
         return this._toolSessionIdByTerminalInstance.get(instance);
     }
-    registerTerminalInstanceWithChatSession(chatSessionId, instance) {
-        if (this._chatSessionIdByTerminalInstance.get(instance) === chatSessionId) {
+    registerTerminalInstanceWithChatSession(chatSessionResource, instance) {
+        const existingResource = this._chatSessionResourceByTerminalInstance.get(instance);
+        if (existingResource && ( existingResource.toString()) === ( chatSessionResource.toString())) {
             return;
         }
         this._chatSessionListenersByTerminalInstance.deleteAndDispose(instance);
-        this._chatSessionIdByTerminalInstance.set(instance, chatSessionId);
+        this._chatSessionResourceByTerminalInstance.set(instance, chatSessionResource);
         const disposable = instance.onDisposed(() => {
-            this._chatSessionIdByTerminalInstance.delete(instance);
+            this._chatSessionResourceByTerminalInstance.delete(instance);
             this._chatSessionListenersByTerminalInstance.deleteAndDispose(instance);
         });
         this._chatSessionListenersByTerminalInstance.set(instance, disposable);
     }
+    getChatSessionResourceForInstance(instance) {
+        return this._chatSessionResourceByTerminalInstance.get(instance);
+    }
     getChatSessionIdForInstance(instance) {
-        return this._chatSessionIdByTerminalInstance.get(instance);
+        const resource = this._chatSessionResourceByTerminalInstance.get(instance);
+        return resource ? chatSessionResourceToId(resource) : undefined;
     }
     isBackgroundTerminal(terminalToolSessionId) {
         if (!terminalToolSessionId) {
@@ -196,9 +211,8 @@ let TerminalChatService = class TerminalChatService extends Disposable {
                     this._pendingRestoredMappings.set(toolSessionId, persistentProcessId);
                 }
             }
-        }
-        catch (err) {
-            this._logService.warn('Failed to restore terminal chat tool session mappings', err);
+        } catch (err) {
+            this._logService.warn("Failed to restore terminal chat tool session mappings", err);
         }
     }
     _tryAdoptRestoredMapping(instance) {
@@ -227,23 +241,24 @@ let TerminalChatService = class TerminalChatService extends Disposable {
         try {
             const entries = [];
             for (const [toolSessionId, instance] of this._terminalInstancesByToolSessionId.entries()) {
-                const persistentId = isNumber(instance.persistentProcessId)
-                    ? instance.persistentProcessId
-                    : instance.shellLaunchConfig.attachPersistentProcess?.id;
+                const persistentId = isNumber(instance.persistentProcessId) ? instance.persistentProcessId : instance.shellLaunchConfig.attachPersistentProcess?.id;
                 const shouldPersist = instance.shouldPersist || instance.shellLaunchConfig.forcePersist;
                 if (isNumber(persistentId) && shouldPersist) {
                     entries.push([toolSessionId, persistentId]);
                 }
             }
             if (entries.length > 0) {
-                this._storageService.store(StorageKeys.ToolSessionMappings, JSON.stringify(entries), StorageScope.WORKSPACE, StorageTarget.MACHINE);
-            }
-            else {
+                this._storageService.store(
+                    StorageKeys.ToolSessionMappings,
+                    JSON.stringify(entries),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.MACHINE
+                );
+            } else {
                 this._storageService.remove(StorageKeys.ToolSessionMappings, StorageScope.WORKSPACE);
             }
-        }
-        catch (err) {
-            this._logService.warn('Failed to persist terminal chat tool session mappings', err);
+        } catch (err) {
+            this._logService.warn("Failed to persist terminal chat tool session mappings", err);
         }
     }
     _updateHasToolTerminalContextKeys() {
@@ -252,35 +267,31 @@ let TerminalChatService = class TerminalChatService extends Disposable {
         const hiddenTerminalCount = this.getToolSessionTerminalInstances(true).length;
         this._hasHiddenToolTerminalContext.set(hiddenTerminalCount > 0);
     }
-    setChatSessionAutoApproval(chatSessionId, enabled) {
+    setChatSessionAutoApproval(chatSessionResource, enabled) {
         if (enabled) {
-            this._sessionAutoApprovalEnabled.add(chatSessionId);
-        }
-        else {
-            this._sessionAutoApprovalEnabled.delete(chatSessionId);
+            this._sessionAutoApprovalEnabled.set(chatSessionResource, true);
+        } else {
+            this._sessionAutoApprovalEnabled.delete(chatSessionResource);
         }
     }
-    hasChatSessionAutoApproval(chatSessionId) {
-        return ( this._sessionAutoApprovalEnabled.has(chatSessionId));
+    hasChatSessionAutoApproval(chatSessionResource) {
+        return ( this._sessionAutoApprovalEnabled.has(chatSessionResource));
     }
-    addSessionAutoApproveRule(chatSessionId, key, value) {
-        let sessionRules = this._sessionAutoApproveRules.get(chatSessionId);
+    addSessionAutoApproveRule(chatSessionResource, key, value) {
+        let sessionRules = this._sessionAutoApproveRules.get(chatSessionResource);
         if (!sessionRules) {
             sessionRules = {};
-            this._sessionAutoApproveRules.set(chatSessionId, sessionRules);
+            this._sessionAutoApproveRules.set(chatSessionResource, sessionRules);
         }
         sessionRules[key] = value;
     }
-    getSessionAutoApproveRules(chatSessionId) {
-        return this._sessionAutoApproveRules.get(chatSessionId) ?? {};
+    getSessionAutoApproveRules(chatSessionResource) {
+        return this._sessionAutoApproveRules.get(chatSessionResource) ?? {};
+    }
+    continueInBackground(terminalToolSessionId) {
+        this._onDidContinueInBackground.fire(terminalToolSessionId);
     }
 };
-TerminalChatService = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, ITerminalService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IChatService))
-], TerminalChatService));
+TerminalChatService = ( __decorate([( __param(0, ILogService)), ( __param(1, ITerminalService)), ( __param(2, IStorageService)), ( __param(3, IContextKeyService)), ( __param(4, IChatService))], TerminalChatService));
 
 export { TerminalChatService };

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatWidget.js

@@ -30,7 +30,7 @@ import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 
 registerCss(terminalChatWidget);
 var Constants;
-(function (Constants) {
+(function(Constants) {
     Constants[Constants["HorizontalMargin"] = 10] = "HorizontalMargin";
     Constants[Constants["VerticalMargin"] = 30] = "VerticalMargin";
     Constants[Constants["RightPadding"] = 12] = "RightPadding";
@@ -38,7 +38,7 @@ var Constants;
     Constants[Constants["MaxHeightPercentageOfViewport"] = 0.75] = "MaxHeightPercentageOfViewport";
 })(Constants || (Constants = {}));
 var Message;
-(function (Message) {
+(function(Message) {
     Message[Message["None"] = 0] = "None";
     Message[Message["AcceptSession"] = 1] = "AcceptSession";
     Message[Message["CancelSession"] = 2] = "CancelSession";
@@ -49,11 +49,23 @@ var Message;
     Message[Message["ReturnInput"] = 64] = "ReturnInput";
 })(Message || (Message = {}));
 let TerminalChatWidget = class TerminalChatWidget extends Disposable {
-    get inlineChatWidget() { return this._inlineChatWidget; }
+    get inlineChatWidget() {
+        return this._inlineChatWidget;
+    }
     get lastResponseContent() {
         return this._lastResponseContent;
     }
-    constructor(_terminalElement, _instance, _xterm, contextKeyService, _chatService, _storageService, instantiationService, _chatAgentService, _chatWidgetService) {
+    constructor(
+        _terminalElement,
+        _instance,
+        _xterm,
+        contextKeyService,
+        _chatService,
+        _storageService,
+        instantiationService,
+        _chatAgentService,
+        _chatWidgetService
+    ) {
         super();
         this._terminalElement = _terminalElement;
         this._instance = _instance;
@@ -65,8 +77,8 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         this._onDidHide = this._register(( new Emitter()));
         this.onDidHide = this._onDidHide.event;
         this._messages = this._store.add(( new Emitter()));
-        this._viewStateStorageKey = 'terminal-inline-chat-view-state';
-        this._terminalAgentName = 'terminal';
+        this._viewStateStorageKey = "terminal-inline-chat-view-state";
+        this._terminalAgentName = "terminal";
         this._model = this._register(( new MutableDisposable()));
         this._sessionDisposables = this._register(( new MutableDisposable()));
         this._requestInProgress = observableValue(this, false);
@@ -76,8 +88,8 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         this._requestActiveContextKey = TerminalChatContextKeys.requestActive.bindTo(contextKeyService);
         this._responseContainsCodeBlockContextKey = TerminalChatContextKeys.responseContainsCodeBlock.bindTo(contextKeyService);
         this._responseContainsMulitpleCodeBlocksContextKey = TerminalChatContextKeys.responseContainsMultipleCodeBlocks.bindTo(contextKeyService);
-        this._container = createElement('div');
-        this._container.classList.add('terminal-inline-chat');
+        this._container = createElement("div");
+        this._container.classList.add("terminal-inline-chat");
         this._terminalElement.appendChild(this._container);
         this._inlineChatWidget = instantiationService.createInstance(InlineChatWidget, {
             location: ChatAgentLocation.Terminal,
@@ -98,15 +110,23 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
             secondaryMenuId: MENU_INLINE_CHAT_WIDGET_SECONDARY,
             chatWidgetViewOptions: {
                 menus: {
-                    telemetrySource: 'terminal-inline-chat',
+                    telemetrySource: "terminal-inline-chat",
                     executeToolbar: MenuId.ChatExecute,
-                    inputSideToolbar: MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR,
+                    inputSideToolbar: MENU_TERMINAL_CHAT_WIDGET_INPUT_SIDE_TOOLBAR
                 },
                 defaultMode: ChatMode.Ask
             }
         });
-        this._register(this._inlineChatWidget.chatWidget.onDidChangeViewModel(() => this._saveViewState()));
-        this._register(Event.any(this._inlineChatWidget.onDidChangeHeight, this._instance.onDimensionsChanged, this._inlineChatWidget.chatWidget.onDidChangeContentHeight, Event.debounce(this._xterm.raw.onCursorMove, () => void 0, MicrotaskDelay))(() => this._relayout()));
+        this._register(
+            this._inlineChatWidget.chatWidget.onDidChangeViewModel(() => this._saveViewState())
+        );
+        this._register(Event.any(
+            this._inlineChatWidget.onDidChangeHeight,
+            this._instance.onDimensionsChanged,
+            this._inlineChatWidget.chatWidget.onDidChangeContentHeight,
+            Event.fromObservableLight(this._inlineChatWidget.chatWidget.input.selectedLanguageModel),
+            Event.debounce(this._xterm.raw.onCursorMove, () => void 0, MicrotaskDelay)
+        )(() => this._relayout()));
         const observer = ( new ResizeObserver(() => this._relayout()));
         observer.observe(this._terminalElement);
         this._register(toDisposable(() => observer.disconnect()));
@@ -117,13 +137,12 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         this._register(this._focusTracker.onDidBlur(() => this._focusedContextKey.set(false)));
         this._register(autorun(r => {
             const isBusy = this._inlineChatWidget.requestInProgress.read(r);
-            this._container.classList.toggle('busy', isBusy);
+            this._container.classList.toggle("busy", isBusy);
             this._inlineChatWidget.toggleStatus(!!this._inlineChatWidget.responseContent);
             if (isBusy || !this._inlineChatWidget.responseContent) {
                 this._responseContainsCodeBlockContextKey.set(false);
                 this._responseContainsMulitpleCodeBlocksContextKey.set(false);
-            }
-            else {
+            } else {
                 Promise.all([
                     this._inlineChatWidget.getCodeBlockInfo(0),
                     this._inlineChatWidget.getCodeBlockInfo(1)
@@ -154,7 +173,11 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         }
         const terminalViewportHeight = this._getTerminalViewportHeight();
         const widgetAllowedPercentBasedHeight = (terminalViewportHeight ?? 0) * Constants.MaxHeightPercentageOfViewport;
-        const height = Math.max(Math.min(Constants.MaxHeight, this._inlineChatWidget.contentHeight, widgetAllowedPercentBasedHeight), this._inlineChatWidget.minHeight);
+        const height = Math.max(Math.min(
+            Constants.MaxHeight,
+            this._inlineChatWidget.contentHeight,
+            widgetAllowedPercentBasedHeight
+        ), this._inlineChatWidget.minHeight);
         if (height === 0) {
             return;
         }
@@ -165,12 +188,12 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
     }
     _resetPlaceholder() {
         const defaultAgent = this._chatAgentService.getDefaultAgent(ChatAgentLocation.Terminal);
-        this.inlineChatWidget.placeholder = defaultAgent?.description ?? ( localize(12013, 'Ask about commands'));
+        this.inlineChatWidget.placeholder = defaultAgent?.description ?? ( localize(12341, "Ask about commands"));
     }
     async reveal() {
         await this._createSession();
         this._doLayout();
-        this._container.classList.remove('hide');
+        this._container.classList.remove("hide");
         this._visibleContextKey.set(true);
         this._resetPlaceholder();
         this._inlineChatWidget.focus();
@@ -198,11 +221,14 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
             return;
         }
         const widgetAllowedPercentBasedHeight = terminalViewportHeight * Constants.MaxHeightPercentageOfViewport;
-        const height = Math.max(Math.min(Constants.MaxHeight, this._inlineChatWidget.contentHeight, widgetAllowedPercentBasedHeight), this._inlineChatWidget.minHeight);
+        const height = Math.max(Math.min(
+            Constants.MaxHeight,
+            this._inlineChatWidget.contentHeight,
+            widgetAllowedPercentBasedHeight
+        ), this._inlineChatWidget.minHeight);
         if (top > terminalViewportHeight - height && terminalViewportHeight - height > 0) {
             this._setTerminalViewportOffset(top - (terminalViewportHeight - height));
-        }
-        else {
+        } else {
             this._setTerminalViewportOffset(undefined);
         }
     }
@@ -210,24 +236,23 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         return this._terminalElement.clientHeight;
     }
     hide() {
-        this._container.classList.add('hide');
+        this._container.classList.add("hide");
         this._inlineChatWidget.reset();
         this._resetPlaceholder();
         this._inlineChatWidget.updateToolbar(false);
         this._visibleContextKey.set(false);
-        this._inlineChatWidget.value = '';
+        this._inlineChatWidget.value = "";
         this._instance.focus();
         this._setTerminalViewportOffset(undefined);
         this._onDidHide.fire();
     }
     _setTerminalViewportOffset(offset) {
-        if (offset === undefined || this._container.classList.contains('hide')) {
-            this._terminalElement.style.position = '';
-            this._terminalElement.style.bottom = '';
+        if (offset === undefined || this._container.classList.contains("hide")) {
+            this._terminalElement.style.position = "";
+            this._terminalElement.style.bottom = "";
             TerminalStickyScrollContribution.get(this._instance)?.hideUnlock();
-        }
-        else {
-            this._terminalElement.style.position = 'relative';
+        } else {
+            this._terminalElement.style.position = "relative";
             this._terminalElement.style.bottom = `${offset}px`;
             TerminalStickyScrollContribution.get(this._instance)?.hideLock();
         }
@@ -239,7 +264,7 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         return this._inlineChatWidget.hasFocus();
     }
     setValue(value) {
-        this._inlineChatWidget.value = value ?? '';
+        this._inlineChatWidget.value = value ?? "";
     }
     async acceptCommand(shouldExecute) {
         const code = await this.inlineChatWidget.getCodeBlockInfo(0);
@@ -254,7 +279,7 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         return this._focusTracker;
     }
     async _createSession() {
-        this._sessionCtor = createCancelablePromise(async (token) => {
+        this._sessionCtor = createCancelablePromise(async token => {
             if (!this._model.value) {
                 const modelRef = this._chatService.startSession(ChatAgentLocation.Terminal);
                 this._model.value = modelRef;
@@ -268,7 +293,12 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
     _saveViewState() {
         const viewState = this._inlineChatWidget.chatWidget.getViewState();
         if (viewState) {
-            this._storageService.store(this._viewStateStorageKey, JSON.stringify(viewState), StorageScope.PROFILE, StorageTarget.USER);
+            this._storageService.store(
+                this._viewStateStorageKey,
+                JSON.stringify(viewState),
+                StorageScope.PROFILE,
+                StorageTarget.USER
+            );
         }
     }
     clear() {
@@ -292,7 +322,9 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         this._activeRequestCts = ( new CancellationTokenSource());
         const store = ( new DisposableStore());
         this._requestActiveContextKey.set(true);
-        const response = await this._inlineChatWidget.chatWidget.acceptInput(lastInput, { isVoiceInput: options?.isVoiceInput });
+        const response = await this._inlineChatWidget.chatWidget.acceptInput(lastInput, {
+            isVoiceInput: options?.isVoiceInput
+        });
         this._currentRequestId = response?.requestId;
         const responsePromise = ( new DeferredPromise());
         try {
@@ -319,12 +351,10 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
             await responsePromise.p;
             this._lastResponseContent = response?.response.getMarkdown();
             return response;
-        }
-        catch {
+        } catch {
             this._lastResponseContent = undefined;
             return;
-        }
-        finally {
+        } finally {
             store.dispose();
         }
     }
@@ -347,53 +377,49 @@ let TerminalChatWidget = class TerminalChatWidget extends Disposable {
         }
         const message = [];
         for (const item of currentRequest.response.response.value) {
-            if (item.kind === 'textEditGroup') {
+            if (item.kind === "textEditGroup") {
                 for (const group of item.edits) {
                     message.push({
-                        kind: 'textEdit',
+                        kind: "textEdit",
                         edits: group,
                         uri: item.uri
                     });
                 }
-            }
-            else if (item.kind === 'notebookEditGroup') {
+            } else if (item.kind === "notebookEditGroup") {
                 for (const group of item.edits) {
                     if (isCellTextEditOperationArray(group)) {
                         message.push({
-                            kind: 'textEdit',
+                            kind: "textEdit",
                             edits: ( group.map(e => e.edit)),
                             uri: group[0].uri
                         });
-                    }
-                    else {
+                    } else {
                         message.push({
-                            kind: 'notebookEdit',
+                            kind: "notebookEdit",
                             edits: group,
                             uri: item.uri
                         });
                     }
                 }
-            }
-            else {
+            } else {
                 message.push(item);
             }
         }
-        this._chatService.addCompleteRequest(widget.viewModel.sessionResource, `@${this._terminalAgentName} ${currentRequest.message.text}`, currentRequest.variableData, currentRequest.attempt, {
-            message,
-            result: currentRequest.response.result,
-            followups: currentRequest.response.followups
-        });
+        this._chatService.addCompleteRequest(
+            widget.viewModel.sessionResource,
+            `@${this._terminalAgentName} ${currentRequest.message.text}`,
+            currentRequest.variableData,
+            currentRequest.attempt,
+            {
+                message,
+                result: currentRequest.response.result,
+                followups: currentRequest.response.followups
+            }
+        );
         widget.focusResponseItem();
         this.hide();
     }
 };
-TerminalChatWidget = ( __decorate([
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IChatService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IChatAgentService)),
-    ( __param(8, IChatWidgetService))
-], TerminalChatWidget));
+TerminalChatWidget = ( __decorate([( __param(3, IContextKeyService)), ( __param(4, IChatService)), ( __param(5, IStorageService)), ( __param(6, IInstantiationService)), ( __param(7, IChatAgentService)), ( __param(8, IChatWidgetService))], TerminalChatWidget));
 
 export { TerminalChatWidget };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/alternativeRecommendation.js

@@ -1,43 +1,30 @@
 
 
 let previouslyRecommededInSession = false;
-const terminalCommands = [
-    {
-        commands: [
-            ( new RegExp(/^python3? -m pip install(\b)/)),
-            ( new RegExp(/^pip3? install(\b)/)),
-        ],
-        tags: ['python environment'],
-    },
-    {
-        commands: [
-            ( new RegExp(/^python3? -m jupyter(\b)/)),
-            ( new RegExp(/^python3? -m pip install\b.*jupyter\b.*/)),
-            ( new RegExp(/^pip3? install\b.*jupyter\b.*/)),
-            (
-            new RegExp(/^jupyter(\b)/)),
-        ],
-        tags: ['python environment', 'jupyter environment'],
-    }
-];
+const terminalCommands = [{
+    commands: [( new RegExp(/^python3? -m pip install(\b)/)), ( new RegExp(/^pip3? install(\b)/))],
+    tags: ["python environment"]
+}, {
+    commands: [( new RegExp(/^python3? -m jupyter(\b)/)), ( new RegExp(/^python3? -m pip install\b.*jupyter\b.*/)), ( new RegExp(/^pip3? install\b.*jupyter\b.*/)), (
+    new RegExp(/^jupyter(\b)/))],
+    tags: ["python environment", "jupyter environment"]
+}];
 function getRecommendedToolsOverRunInTerminal(commandLine, languageModelToolsService) {
-    const tools = languageModelToolsService.getTools();
+    const tools = languageModelToolsService.getTools(undefined);
     if (!tools || previouslyRecommededInSession) {
         return;
     }
     const recommendedTools = ( new Set());
     const messages = [
         `The terminal command '${commandLine}' was not executed.`,
-        `Try using some of the following tools instead of running a Terminal Command (if unable to use one of these tools as an alternative then run the same terminal command again):`,
+        `Try using some of the following tools instead of running a Terminal Command (if unable to use one of these tools as an alternative then run the same terminal command again):`
     ];
     for (const terminalCommand of terminalCommands) {
-        if (!( terminalCommand.commands.some((condition) => condition.test(commandLine)))) {
+        if (!( terminalCommand.commands.some(condition => condition.test(commandLine)))) {
             continue;
         }
         const tagsToSearchFor = terminalCommand.tags;
-        Array.from(tools)
-            .filter(t => ( tagsToSearchFor.some(tag => t.tags?.includes(tag))))
-            .forEach(tool => {
+        Array.from(tools).filter(t => ( tagsToSearchFor.some(tag => t.tags?.includes(tag)))).forEach(tool => {
             recommendedTools.add(tool.id);
         });
     }
@@ -46,7 +33,7 @@ function getRecommendedToolsOverRunInTerminal(commandLine, languageModelToolsSer
     });
     if (recommendedTools.size) {
         previouslyRecommededInSession = true;
-        return messages.join('  \n');
+        return messages.join("  \n");
     }
     return undefined;
 }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/commandParsers/commandFileWriteParser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Interface for command-specific file write parsers.
+ * Each parser is responsible for detecting when a specific command will write to files
+ * (beyond simple shell redirections which are handled separately via tree-sitter queries).
+ */
+export interface ICommandFileWriteParser {
+    /**
+     * The name of the command this parser handles (e.g., 'sed', 'tee').
+     */
+    readonly commandName: string;
+    /**
+     * Checks if this parser can handle the given command text.
+     * Should return true only if the command would write to files.
+     * @param commandText The full text of a single command (not a pipeline).
+     */
+    canHandle(commandText: string): boolean;
+    /**
+     * Extracts the file paths that would be written to by this command.
+     * Should only be called if canHandle() returns true.
+     * @param commandText The full text of a single command (not a pipeline).
+     * @returns Array of file paths that would be modified.
+     */
+    extractFileWrites(commandText: string): string[];
+}