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

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsManagementService.js

@@ -0,0 +1,397 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { openSession } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsOpener';
+import { ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isAgentSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { LocalNewSession, RemoteNewSession } from '../../chat/browser/newSession.js';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { GITHUB_REMOTE_FILE_SCHEME } from '../../fileTreeView/browser/githubFileSystemProvider.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const IsNewChatSessionContext = ( new RawContextKey("isNewChatSession", true));
+const IsActiveSessionBackgroundProviderContext = ( new RawContextKey("isActiveSessionBackgroundProvider", false, ( localize(2519, "Whether the active session uses the background agent provider"))));
+const LAST_SELECTED_SESSION_KEY = "agentSessions.lastSelectedSession";
+const repositoryOptionId = "repository";
+let SessionsManagementService = class SessionsManagementService extends Disposable {
+    constructor(
+        storageService,
+        uriIdentityService,
+        agentSessionsService,
+        chatSessionsService,
+        chatWidgetService,
+        chatService,
+        instantiationService,
+        logService,
+        contextKeyService,
+        commandService,
+        languageModelsService
+    ) {
+        super();
+        this.storageService = storageService;
+        this.uriIdentityService = uriIdentityService;
+        this.agentSessionsService = agentSessionsService;
+        this.chatSessionsService = chatSessionsService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatService = chatService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.commandService = commandService;
+        this.languageModelsService = languageModelsService;
+        this._activeSession = observableValue(this, undefined);
+        this.activeSession = this._activeSession;
+        this._newActiveSessionDisposables = this._register(( new DisposableStore()));
+        this._newSession = this._register(( new MutableDisposable()));
+        this.isNewChatSessionContext = IsNewChatSessionContext.bindTo(contextKeyService);
+        this._isBackgroundProvider = IsActiveSessionBackgroundProviderContext.bindTo(contextKeyService);
+        this.lastSelectedSession = this.loadLastSelectedSession();
+        this._register(this.storageService.onWillSaveState(() => this.saveLastSelectedSession()));
+        this._register(
+            this.agentSessionsService.model.onDidChangeSessions(() => this.refreshActiveSessionFromModel())
+        );
+        this._register(this.agentSessionsService.model.onDidChangeSessionArchivedState(e => {
+            if (e.isArchived()) {
+                const currentActive = this._activeSession.get();
+                if (currentActive && ( currentActive.resource.toString()) === ( e.resource.toString())) {
+                    this.openNewSessionView();
+                }
+            }
+        }));
+    }
+    refreshActiveSessionFromModel() {
+        const currentActive = this._activeSession.get();
+        if (!currentActive) {
+            return;
+        }
+        const agentSession = this.agentSessionsService.model.getSession(currentActive.resource);
+        if (!agentSession) {
+            if (currentActive.isUntitled) {
+                const chatViewWidgets = this.chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat);
+                const committedResource = chatViewWidgets[0]?.viewModel?.sessionResource;
+                const committedSession = committedResource ? this.agentSessionsService.model.getSession(committedResource) : undefined;
+                if (committedSession) {
+                    this.setActiveSession(committedSession);
+                }
+            } else {
+                this.showNextSession();
+            }
+            return;
+        }
+        this.setActiveSession(agentSession);
+    }
+    showNextSession() {
+        const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived()).sort(
+            (a, b) => (b.timing.lastRequestEnded ?? b.timing.created) - (a.timing.lastRequestEnded ?? a.timing.created)
+        );
+        if (sessions.length > 0) {
+            this.setActiveSession(sessions[0]);
+            this.instantiationService.invokeFunction(openSession, sessions[0]);
+        } else {
+            this.openNewSessionView();
+        }
+    }
+    getRepositoryFromMetadata(session) {
+        const metadata = session.metadata;
+        if (!metadata) {
+            return [undefined, undefined];
+        }
+        if (session.providerType === AgentSessionProviders.Cloud) {
+            const branch = typeof metadata.branch === "string" ? metadata.branch : "HEAD";
+            const repositoryUri = ( URI.from({
+                scheme: GITHUB_REMOTE_FILE_SCHEME,
+                authority: "github",
+                path: `/${metadata.owner}/${metadata.name}/${encodeURIComponent(branch)}`
+            }));
+            return [repositoryUri, undefined];
+        }
+        const workingDirectoryPath = metadata?.workingDirectoryPath;
+        if (workingDirectoryPath) {
+            return [URI.file(workingDirectoryPath), undefined];
+        }
+        const repositoryPath = metadata?.repositoryPath;
+        const repositoryPathUri = typeof repositoryPath === "string" ? URI.file(repositoryPath) : undefined;
+        const worktreePath = metadata?.worktreePath;
+        const worktreePathUri = typeof worktreePath === "string" ? URI.file(worktreePath) : undefined;
+        return [
+            URI.isUri(repositoryPathUri) ? repositoryPathUri : undefined,
+            URI.isUri(worktreePathUri) ? worktreePathUri : undefined
+        ];
+    }
+    getRepositoryFromSessionOption(sessionResource) {
+        const optionValue = this.chatSessionsService.getSessionOption(sessionResource, repositoryOptionId);
+        if (!optionValue) {
+            return undefined;
+        }
+        const optionId = typeof optionValue === "string" ? optionValue : optionValue.id;
+        if (!optionId) {
+            return undefined;
+        }
+        try {
+            return ( URI.parse(optionId));
+        } catch {
+            return undefined;
+        }
+    }
+    getActiveSession() {
+        return this._activeSession.get();
+    }
+    async openSession(sessionResource, openOptions) {
+        this.isNewChatSessionContext.set(false);
+        const existingSession = this.agentSessionsService.model.getSession(sessionResource);
+        if (existingSession) {
+            await this.openExistingSession(existingSession, openOptions);
+        } else if (this._newSession.value && this.uriIdentityService.extUri.isEqual(sessionResource, this._newSession.value.resource)) {
+            await this.openNewSession(this._newSession.value);
+        }
+    }
+    async createNewSessionForTarget(target, sessionResource, defaultRepoUri) {
+        if (!this.isNewChatSessionContext.get()) {
+            this.isNewChatSessionContext.set(true);
+        }
+        let newSession;
+        if (target === AgentSessionProviders.Background) {
+            newSession = this.instantiationService.createInstance(LocalNewSession, sessionResource, defaultRepoUri);
+        } else {
+            newSession = this.instantiationService.createInstance(RemoteNewSession, sessionResource, target);
+        }
+        this._newSession.value = newSession;
+        this.setActiveSession(newSession);
+        return newSession;
+    }
+    async openExistingSession(session, openOptions) {
+        this.setActiveSession(session);
+        await this.instantiationService.invokeFunction(openSession, session, openOptions);
+    }
+    async openNewSession(newSession) {
+        this.setActiveSession(newSession);
+        const sessionResource = newSession.resource;
+        const chatWidget = await this.chatWidgetService.openSession(sessionResource, ChatViewPaneTarget);
+        if (!chatWidget?.viewModel) {
+            this.logService.warn(`[ActiveSessionService] Failed to open session: ${( sessionResource.toString())}`);
+            return;
+        }
+        const repository = this.getRepositoryFromSessionOption(sessionResource);
+        this.logService.info(`[ActiveSessionService] Active session changed (new): ${( sessionResource.toString())}, repository: ${repository?.toString() ?? "none"}`);
+    }
+    async sendRequestForNewSession(sessionResource, options) {
+        const session = this._newSession.value;
+        if (!session) {
+            this.logService.error(
+                `[SessionsManagementService] No new session found for resource: ${( sessionResource.toString())}`
+            );
+            return;
+        }
+        if (!this.uriIdentityService.extUri.isEqual(sessionResource, session.resource)) {
+            this.logService.error(
+                `[SessionsManagementService] Session resource mismatch. Expected: ${( session.resource.toString())}, received: ${( sessionResource.toString())}`
+            );
+            return;
+        }
+        const query = session.query;
+        if (!query) {
+            this.logService.error("[SessionsManagementService] No query set on session");
+            return;
+        }
+        const contribution = this.chatSessionsService.getChatSessionContribution(session.target);
+        const sendOptions = {
+            location: ChatAgentLocation.Chat,
+            userSelectedModelId: session.modelId,
+            modeInfo: {
+                kind: ChatModeKind.Agent,
+                isBuiltin: true,
+                modeInstructions: undefined,
+                modeId: "agent",
+                applyCodeBlockSuggestionId: undefined
+            },
+            agentIdSilent: contribution?.type,
+            attachedContext: session.attachedContext
+        };
+        await this.chatSessionsService.getOrCreateChatSession(session.resource, CancellationToken.None);
+        await this.doSendRequestForNewSession(
+            session,
+            query,
+            sendOptions,
+            session.selectedOptions,
+            options?.openNewSessionView
+        );
+        this._newSession.value = undefined;
+    }
+    async doSendRequestForNewSession(session, query, sendOptions, selectedOptions, openNewSessionView) {
+        await this.openSession(session.resource);
+        if (openNewSessionView) {
+            this.openNewSessionView();
+        }
+        const modelRef = this.chatService.acquireExistingSession(session.resource);
+        if (modelRef) {
+            const model = modelRef.object;
+            if (session.modelId) {
+                const languageModel = this.languageModelsService.lookupLanguageModel(session.modelId);
+                if (languageModel) {
+                    model.inputModel.setState({
+                        selectedModel: {
+                            identifier: session.modelId,
+                            metadata: languageModel
+                        }
+                    });
+                }
+            }
+            if (selectedOptions && selectedOptions.size > 0) {
+                const contributedSession = model.contributedChatSession;
+                if (contributedSession) {
+                    const initialSessionOptions = ( [...selectedOptions.entries()].map(([optionId, value]) => ({
+                        optionId,
+                        value
+                    })));
+                    model.setContributedChatSession({
+                        ...contributedSession,
+                        initialSessionOptions
+                    });
+                }
+            }
+            modelRef.dispose();
+        }
+        const existingResources = ( new Set(( this.agentSessionsService.model.sessions.map(s => ( s.resource.toString())))));
+        const result = await this.chatService.sendRequest(session.resource, query, sendOptions);
+        if (result.kind === "rejected") {
+            this.logService.error(`[ActiveSessionService] sendRequest rejected: ${result.reason}`);
+            return;
+        }
+        let newSession = this.agentSessionsService.model.sessions.find(s => !( existingResources.has(( s.resource.toString()))));
+        if (!newSession) {
+            let listener;
+            newSession = await Promise.race([( new Promise(resolve => {
+                listener = this.agentSessionsService.model.onDidChangeSessions(() => {
+                    const session = this.agentSessionsService.model.sessions.find(s => !( existingResources.has(( s.resource.toString()))));
+                    if (session) {
+                        resolve(session);
+                    }
+                });
+            })), ( new Promise(resolve => setTimeout(() => resolve(undefined), 30_000)))]);
+            listener?.dispose();
+        }
+        if (newSession && !openNewSessionView) {
+            this.setActiveSession(newSession);
+        }
+    }
+    openNewSessionView() {
+        if (this.isNewChatSessionContext.get()) {
+            return;
+        }
+        this.setActiveSession(undefined);
+        this.isNewChatSessionContext.set(true);
+    }
+    setActiveSession(session) {
+        let activeSessionItem;
+        if (session) {
+            if (isAgentSession(session)) {
+                this.lastSelectedSession = session.resource;
+                const [repository, worktree] = this.getRepositoryFromMetadata(session);
+                activeSessionItem = {
+                    isUntitled: this.chatService.getSession(session.resource)?.contributedChatSession?.isUntitled ?? true,
+                    label: session.label,
+                    resource: session.resource,
+                    repository,
+                    worktree,
+                    providerType: session.providerType
+                };
+            } else {
+                activeSessionItem = {
+                    isUntitled: true,
+                    label: undefined,
+                    resource: session.resource,
+                    repository: session.repoUri,
+                    worktree: undefined,
+                    providerType: session.target
+                };
+                this._newActiveSessionDisposables.clear();
+                this._newActiveSessionDisposables.add(session.onDidChange(e => {
+                    if (e === "repoUri") {
+                        this.doSetActiveSession({
+                            isUntitled: true,
+                            label: undefined,
+                            resource: session.resource,
+                            repository: session.repoUri,
+                            worktree: undefined,
+                            providerType: session.target
+                        });
+                    }
+                }));
+            }
+        }
+        this.doSetActiveSession(activeSessionItem);
+    }
+    doSetActiveSession(activeSessionItem) {
+        if (this.equalsSessionItem(this._activeSession.get(), activeSessionItem)) {
+            return;
+        }
+        if (activeSessionItem) {
+            this.logService.info(`[ActiveSessionService] Active session changed: ${( activeSessionItem.resource.toString())}`);
+            this.logService.trace(
+                `[ActiveSessionService] Active session details: ${JSON.stringify(activeSessionItem)}`
+            );
+        } else {
+            this.logService.trace("[ActiveSessionService] Active session cleared");
+        }
+        this._isBackgroundProvider.set(activeSessionItem?.providerType === AgentSessionProviders.Background);
+        this._activeSession.set(activeSessionItem, undefined);
+    }
+    equalsSessionItem(a, b) {
+        if (a === b) {
+            return true;
+        }
+        if (!a || !b) {
+            return false;
+        }
+        return (a.label === b.label && ( a.resource.toString()) === ( b.resource.toString()) && a.repository?.toString() === b.repository?.toString() && a.worktree?.toString() === b.worktree?.toString() && a.providerType === b.providerType);
+    }
+    async commitWorktreeFiles(session, fileUris) {
+        const worktreeUri = session.worktree;
+        if (!worktreeUri) {
+            throw ( new Error("Cannot commit worktree files: active session has no associated worktree"));
+        }
+        for (const fileUri of fileUris) {
+            await this.commandService.executeCommand("github.copilot.cli.sessions.commitToWorktree", {
+                worktreeUri,
+                fileUri
+            });
+        }
+        await this.agentSessionsService.model.resolve(AgentSessionProviders.Background);
+    }
+    loadLastSelectedSession() {
+        const cached = this.storageService.get(LAST_SELECTED_SESSION_KEY, StorageScope.WORKSPACE);
+        if (!cached) {
+            return undefined;
+        }
+        try {
+            return ( URI.parse(cached));
+        } catch {
+            return undefined;
+        }
+    }
+    saveLastSelectedSession() {
+        if (this.lastSelectedSession) {
+            this.storageService.store(LAST_SELECTED_SESSION_KEY, ( this.lastSelectedSession.toString()), StorageScope.WORKSPACE, StorageTarget.MACHINE);
+        }
+    }
+};
+SessionsManagementService = ( __decorate([( __param(0, IStorageService)), ( __param(1, IUriIdentityService)), ( __param(2, IAgentSessionsService)), ( __param(3, IChatSessionsService)), ( __param(4, IChatWidgetService)), ( __param(5, IChatService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IContextKeyService)), ( __param(9, ICommandService)), ( __param(10, ILanguageModelsService))], SessionsManagementService));
+
+export { IsActiveSessionBackgroundProviderContext, IsNewChatSessionContext, SessionsManagementService };

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityService.d.ts

@@ -19,9 +19,8 @@ export declare class ChatAccessibilityService extends Disposable implements ICha
     private readonly _chatService;
     readonly _serviceBrand: undefined;
     private _pendingSignalMap;
-    private readonly notifications;
+    private readonly toasts;
     constructor(_accessibilitySignalService: IAccessibilitySignalService, _instantiationService: IInstantiationService, _configurationService: IConfigurationService, _hostService: IHostService, _widgetService: IChatWidgetService, _chatService: IChatService);
-    dispose(): void;
     acceptRequest(uri: URI, skipRequestSignal?: boolean): void;
     disposeRequest(requestId: URI): void;
     acceptResponse(widget: ChatWidget, container: HTMLElement, response: IChatResponseViewModel | string | undefined, requestId: URI, isVoiceInput?: boolean): void;

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityService.js

@@ -1,11 +1,10 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { getWindow, triggerNotification } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
 import { status, alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
-import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap, DisposableSet, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
 import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
@@ -17,8 +16,9 @@ import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/s
 import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
 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 { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration, ChatNotificationMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { AccessibilityVoiceSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/speech/common/speechService';
 
 const CHAT_RESPONSE_PENDING_ALLOWANCE_MS = 4000;
@@ -39,7 +39,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
         this._widgetService = _widgetService;
         this._chatService = _chatService;
         this._pendingSignalMap = this._register(( new DisposableMap()));
-        this.notifications = ( new Set());
+        this.toasts = this._register(( new DisposableSet()));
         this._register(this._widgetService.onDidBackgroundSession(e => {
             const session = this._chatService.getSession(e);
             if (!session) {
@@ -52,13 +52,6 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             this.disposeRequest(e);
         }));
     }
-    dispose() {
-        for (const ds of Array.from(this.notifications)) {
-            ds.dispose();
-        }
-        this.notifications.clear();
-        super.dispose();
-    }
     acceptRequest(uri, skipRequestSignal) {
         if (!skipRequestSignal) {
             this._accessibilitySignalService.playSignal(AccessibilitySignal.chatRequestSent, {
@@ -103,51 +96,45 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
         });
     }
     async _showOSNotification(widget, container, responseContent) {
-        if (!this._configurationService.getValue(ChatConfiguration.NotifyWindowOnResponseReceived)) {
+        const mode = this._configurationService.getValue(ChatConfiguration.NotifyWindowOnResponseReceived);
+        if (mode === ChatNotificationMode.Off) {
             return;
         }
         const targetWindow = getWindow(container);
         if (!targetWindow) {
             return;
         }
-        if (targetWindow.document.hasFocus()) {
+        const isFocused = targetWindow.document.hasFocus();
+        if (mode !== ChatNotificationMode.Always && isFocused) {
             return;
         }
         if (!responseContent || !responseContent.trim()) {
             return;
         }
-        await this._hostService.focus(targetWindow, {
-            mode: FocusMode.Notify
-        });
-        for (const ds of Array.from(this.notifications)) {
-            ds.dispose();
-            this.notifications.delete(ds);
-        }
-        const title = widget?.viewModel?.model.title ? ( localize(4598, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4599, "Untitled Chat"));
-        const notification = await triggerNotification(title, {
-            detail: ( localize(4600, "New chat response."))
-        });
-        if (!notification) {
-            return;
+        if (!isFocused) {
+            await this._hostService.focus(targetWindow, {
+                mode: FocusMode.Notify
+            });
         }
-        const disposables = ( new DisposableStore());
-        disposables.add(notification);
-        this.notifications.add(disposables);
-        disposables.add(Event.once(notification.onClick)(async () => {
+        this.toasts.clearAndDisposeAll();
+        const title = widget?.viewModel?.model.title ? ( localize(4690, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4691, "Untitled Chat"));
+        const cts = ( new CancellationTokenSource());
+        const disposable = toDisposable(() => cts.dispose(true));
+        this.toasts.add(disposable);
+        const {
+            clicked
+        } = await this._hostService.showToast({
+            title,
+            body: ( localize(4692, "New chat response."))
+        }, cts.token);
+        this.toasts.deleteAndDispose(disposable);
+        if (clicked) {
             await this._hostService.focus(targetWindow, {
                 mode: FocusMode.Force
             });
             await this._widgetService.reveal(widget);
             widget.focusInput();
-            disposables.dispose();
-            this.notifications.delete(disposables);
-        }));
-        disposables.add(this._hostService.onDidChangeFocus(focus => {
-            if (focus) {
-                disposables.dispose();
-                this.notifications.delete(disposables);
-            }
-        }));
+        }
     }
 };
 ChatAccessibilityService = ( __decorate([( __param(0, IAccessibilitySignalService)), ( __param(1, IInstantiationService)), ( __param(2, IConfigurationService)), ( __param(3, IHostService)), ( __param(4, IChatWidgetService)), ( __param(5, IChatService))], ChatAccessibilityService));

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatResponseAccessibleView.d.ts

@@ -4,8 +4,9 @@ import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { AccessibleViewProviderId, AccessibleViewType, IAccessibleViewContentProvider } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView";
 import { IAccessibleViewImplementation } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry";
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { AccessibilityVerbositySettingId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration";
-import { IChatExtensionsContent, IChatPullRequestContent, IChatSubagentToolInvocationData, IChatTerminalToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, ILegacyChatTerminalToolInvocationData, IToolResultOutputDetailsSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatExtensionsContent, IChatPullRequestContent, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTerminalToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolResourcesInvocationData, ILegacyChatTerminalToolInvocationData, IToolResultOutputDetailsSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IToolResultInputOutputDetails, IToolResultOutputDetails } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ChatTreeItem, IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { Location } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
@@ -16,8 +17,10 @@ export declare class ChatResponseAccessibleView implements IAccessibleViewImplem
     readonly when: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").RawContextKey<boolean>;
     getProvider(accessor: ServicesAccessor): ChatResponseAccessibleProvider | undefined;
 }
-type ToolSpecificData = IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData;
+type ToolSpecificData = IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData;
 type ResultDetails = Array<URI | Location> | IToolResultInputOutputDetails | IToolResultOutputDetails | IToolResultOutputDetailsSerialized;
+export declare const CHAT_ACCESSIBLE_VIEW_INCLUDE_THINKING_STORAGE_KEY = "chat.accessibleView.includeThinking";
+export declare function isThinkingContentIncludedInAccessibleView(storageService: IStorageService): boolean;
 export declare function getToolSpecificDataDescription(toolSpecificData: ToolSpecificData | undefined): string;
 export declare function getResultDetailsDescription(resultDetails: ResultDetails | undefined): {
     input?: string;
@@ -28,11 +31,13 @@ export declare function getToolInvocationA11yDescription(invocationMessage: stri
 declare class ChatResponseAccessibleProvider extends Disposable implements IAccessibleViewContentProvider {
     private readonly _widget;
     private readonly _wasOpenedFromInput;
+    private readonly _storageService;
     private _focusedItem;
     private readonly _focusedItemDisposables;
+    private readonly _storageDisposables;
     private readonly _onDidChangeContent;
     readonly onDidChangeContent: Event<void>;
-    constructor(_widget: IChatWidget, item: ChatTreeItem, _wasOpenedFromInput: boolean);
+    constructor(_widget: IChatWidget, item: ChatTreeItem, _wasOpenedFromInput: boolean, _storageService: IStorageService);
     readonly id = AccessibleViewProviderId.PanelChat;
     readonly verbositySettingKey = AccessibilityVerbositySettingId.Chat;
     readonly options: {
@@ -43,6 +48,7 @@ declare class ChatResponseAccessibleProvider extends Disposable implements IAcce
     private _renderMessageAsPlaintext;
     private _getContent;
     private _normalizeWhitespace;
+    private _shouldIncludeThinkingContent;
     onClose(): void;
     provideNextContent(): string | undefined;
     providePreviousContent(): string | undefined;