@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostMcpServerSupportScope.js

@@ -0,0 +1,202 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise, Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { mcpAccessConfig, McpAccessValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement';
+import { COPILOT_STRICT_PLUGIN_ONLY_CUSTOMIZATION_CONFIG } from '@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/copilotManagedSettings';
+import { isStrictPluginOnlyCustomizationEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationLockdown';
+import { IMcpService, IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
+import { assessMcpServersForCopilotAgentHost, mergeInstalledMcpServersIntoAgentHostSupportAssessment } from './agentHostMcpServerSupport.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const MCP_SUPPORT_UPDATE_DEBOUNCE_DELAY = 50;
+function createEmptySupportSnapshot(coverage) {
+    return {
+        servers: [],
+        discoveryComplete: false,
+        coverage
+    };
+}
+let AgentHostMcpServerSupportScope = class AgentHostMcpServerSupportScope extends Disposable {
+    constructor(
+        _sessionType,
+        _roots,
+        _onDispose,
+        _mcpService,
+        _mcpWorkbenchService,
+        _configurationResolverService,
+        _configurationService
+    ) {
+        super();
+        this._sessionType = _sessionType;
+        this._roots = _roots;
+        this._onDispose = _onDispose;
+        this._mcpService = _mcpService;
+        this._mcpWorkbenchService = _mcpWorkbenchService;
+        this._configurationResolverService = _configurationResolverService;
+        this._configurationService = _configurationService;
+        this._support = observableValue("agentHostMcpServerSupport", {
+            servers: [],
+            discoveryComplete: false,
+            coverage: {
+                restrictedByMcpAccess: false,
+                restrictedByCustomizationPolicy: false
+            }
+        });
+        this._isResolved = observableValue("agentHostMcpServerSupportResolved", false);
+        this._latestResolution = ( new DeferredPromise());
+        this._refCount = 0;
+        this._updateSequence = 0;
+        this._isDisposed = false;
+        this._updateDelayer = this._register(( new Delayer(MCP_SUPPORT_UPDATE_DEBOUNCE_DELAY)));
+        const update = async sequence => {
+            try {
+                const lazyState = this._mcpService.lazyCollectionState.get();
+                const initialAssessment = await assessMcpServersForCopilotAgentHost(
+                    this._mcpService.servers.get(),
+                    this._configurationResolverService,
+                    this._sessionType,
+                    this._roots,
+                    lazyState.state
+                );
+                if (!initialAssessment) {
+                    this._completeUpdate(sequence, createEmptySupportSnapshot(this._getCoverage()));
+                    return;
+                }
+                if (sequence !== this._updateSequence || this._isDisposed) {
+                    return;
+                }
+                await this._mcpWorkbenchService.whenInitialLocalMcpServersLoaded;
+                if (sequence !== this._updateSequence || this._isDisposed) {
+                    return;
+                }
+                const installedServers = this._mcpWorkbenchService.local.flatMap(server => {
+                    const local = server.local;
+                    return local ? [{
+                        id: local.id,
+                        name: server.name,
+                        label: server.label,
+                        configuration: local.config,
+                        configPath: this._mcpWorkbenchService.getMcpConfigPath(local),
+                        sandbox: local.rootSandbox,
+                        runtimeState: server.runtimeStatus?.state
+                    }] : [];
+                });
+                const assessment = await mergeInstalledMcpServersIntoAgentHostSupportAssessment(
+                    initialAssessment,
+                    installedServers,
+                    this._configurationResolverService,
+                    this._roots
+                );
+                if (sequence !== this._updateSequence) {
+                    return;
+                }
+                this._completeUpdate(sequence, {
+                    ...assessment,
+                    coverage: this._getCoverage()
+                });
+            } catch (error) {
+                onUnexpectedError(error);
+                this._completeUpdate(sequence, createEmptySupportSnapshot(this._getCoverage()));
+            } finally {
+                if (sequence === this._updateSequence && !this._latestResolution.isSettled) {
+                    this._latestResolution.complete();
+                }
+            }
+        };
+        const scheduleUpdate = () => {
+            if (this._isDisposed) {
+                return;
+            }
+            const sequence = ++this._updateSequence;
+            const previousResolution = this._latestResolution;
+            this._latestResolution = ( new DeferredPromise());
+            transaction(tx => this._isResolved.set(false, tx));
+            if (!previousResolution.isSettled) {
+                previousResolution.complete();
+            }
+            this._updateDelayer.trigger(() => update(sequence)).catch(() => {});
+        };
+        this._register(autorun(reader => {
+            for (const server of this._mcpService.servers.read(reader)) {
+                server.readDefinitions().read(reader);
+                server.enablement.read(reader);
+            }
+            this._mcpService.lazyCollectionState.read(reader);
+            scheduleUpdate();
+        }));
+        this._register(this._mcpWorkbenchService.onChange(scheduleUpdate));
+        this._register(this._configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(mcpAccessConfig) || event.affectsConfiguration(COPILOT_STRICT_PLUGIN_ONLY_CUSTOMIZATION_CONFIG)) {
+                scheduleUpdate();
+            }
+        }));
+    }
+    acquire() {
+        this._refCount++;
+        let released = false;
+        return {
+            support: this._support,
+            isResolved: this._isResolved,
+            whenResolved: () => this._whenResolved(),
+            dispose: () => {
+                if (!released) {
+                    released = true;
+                    this._release();
+                }
+            }
+        };
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._updateSequence++;
+        if (!this._latestResolution.isSettled) {
+            this._latestResolution.complete();
+        }
+        super.dispose();
+        this._onDispose();
+    }
+    async _whenResolved() {
+        while (!this._isDisposed) {
+            const resolution = this._latestResolution;
+            await resolution.p;
+            if (resolution === this._latestResolution) {
+                return;
+            }
+        }
+    }
+    _completeUpdate(sequence, snapshot) {
+        if (sequence !== this._updateSequence || this._isDisposed) {
+            return;
+        }
+        transaction(tx => {
+            this._support.set(snapshot, tx);
+            this._isResolved.set(true, tx);
+        });
+    }
+    _getCoverage() {
+        const access = this._configurationService.getValue(mcpAccessConfig);
+        const strictPluginOnly = this._configurationService.getValue(COPILOT_STRICT_PLUGIN_ONLY_CUSTOMIZATION_CONFIG);
+        return {
+            restrictedByMcpAccess: access !== McpAccessValue.All,
+            restrictedByCustomizationPolicy: isStrictPluginOnlyCustomizationEnabled(strictPluginOnly)
+        };
+    }
+    _release() {
+        if (--this._refCount === 0) {
+            this.dispose();
+        }
+    }
+};
+AgentHostMcpServerSupportScope = ( __decorate([( __param(3, IMcpService)), ( __param(4, IMcpWorkbenchService)), ( __param(5, IConfigurationResolverService)), ( __param(6, IConfigurationService))], AgentHostMcpServerSupportScope));
+
+export { AgentHostMcpServerSupportScope };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModeSynchronizer.d.ts

@@ -1 +1,24 @@
-export {};
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+export declare class AgentHostModeSynchronizer extends Disposable implements IWorkbenchContribution {
+    private readonly _chatWidgetService;
+    private readonly _provisionalSessionService;
+    private readonly _storageService;
+    static readonly ID = "workbench.contrib.agentHostModeSynchronizer";
+    private readonly _widgetListeners;
+    private readonly _updatingWidgets;
+    constructor(_chatWidgetService: IChatWidgetService, _provisionalSessionService: IAgentHostUntitledProvisionalSessionService, _storageService: IStorageService, environmentService: IWorkbenchEnvironmentService);
+    private _attachWidget;
+    private _onWidgetModeChanged;
+    private _syncWidgetFromBackend;
+    private _applyMode;
+    private _findMode;
+    private _agentUriFromMode;
+    private _storeSelectedAgent;
+    private _readSelectedAgent;
+    private _resolveBackendSession;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModeSynchronizer.js

@@ -1,10 +1,12 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { AgentSession } from '../../../../../../platform/agentHost/common/agentService.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
 import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { agentHostAgentPickerStorageKey } from '../../../../../../platform/agentHost/common/customAgents.js';
+import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 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 { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
@@ -13,6 +15,8 @@ import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workb
 import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
 import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IAgentHostUntitledProvisionalSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
 
 const AGENT_HOST_SESSION_SCHEME_PREFIX = "agent-host-";
 let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposable {
@@ -40,6 +44,9 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         this._register(
             this._chatWidgetService.onDidAddWidget(widget => this._attachWidget(widget))
         );
+        this._register(
+            this._chatWidgetService.onDidRemoveWidget(widget => this._widgetListeners.deleteAndDispose(widget))
+        );
         this._register(this._chatWidgetService.onDidChangeFocusedSession(() => {
             const widget = this._chatWidgetService.lastFocusedWidget;
             if (widget) {
@@ -59,13 +66,20 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         }
         const store = ( new DisposableStore());
         store.add(
-            widget.input.onDidChangeCurrentChatMode(() => this._onWidgetModeChanged(widget))
+            widget.input.onDidChangeCurrentChatMode(e => this._onWidgetModeChanged(widget, e))
         );
         store.add(widget.onDidChangeViewModel(() => this._syncWidgetFromBackend(widget)));
+        store.add(autorun(reader => {
+            const modes = widget.input.currentChatModesObs.read(reader);
+            reader.store.add(modes.onDidChange(() => this._syncWidgetFromBackend(widget)));
+        }));
         this._widgetListeners.set(widget, store);
         this._syncWidgetFromBackend(widget);
     }
-    _onWidgetModeChanged(widget) {
+    _onWidgetModeChanged(widget, e) {
+        if (!e.isUserInitiated) {
+            return;
+        }
         if (( this._updatingWidgets.has(widget))) {
             return;
         }
@@ -87,7 +101,13 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         if (!sessionResource || !backendSession) {
             return;
         }
+        if (!isUntitledChatSession(sessionResource)) {
+            return;
+        }
         const agentUri = this._readSelectedAgent(sessionResource);
+        if (agentUri === undefined) {
+            return;
+        }
         void this._applyMode(widget, sessionResource, agentUri);
     }
     async _applyMode(widget, sessionResource, agentUri) {
@@ -96,8 +116,7 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         if (widget.viewModel?.sessionResource.toString() !== ( sessionResource.toString())) {
             return;
         }
-        const modeId = agentUri ?? ChatMode.Agent.id;
-        const mode = this._findMode(modes, modeId);
+        const mode = this._findMode(modes, agentUri);
         if (!mode || widget.input.currentModeObs.get().id === mode.id) {
             return;
         }
@@ -151,3 +170,5 @@ registerWorkbenchContribution2(
     AgentHostModeSynchronizer,
     WorkbenchPhase.Eventually
 );
+
+export { AgentHostModeSynchronizer };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostPermissionUiContribution.js

@@ -5,12 +5,12 @@ import { escapeMarkdownSyntaxTokens, MarkdownString } from '@codingame/monaco-vs
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { AgentHostPermissionMode } from '../../../../../../platform/agentHost/common/agentHostResourceService.js';
+import { AgentHostPermissionMode } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService';
 import { IAgentHostResourceService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService.service';
 import { agentHostAuthority, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
-import { ChatInputNotificationSeverity } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import { ChatInputNotificationActionKind, ChatInputNotificationSeverity } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
 import { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
@@ -64,23 +64,26 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
         const path = request.uri.scheme === Schemas.file ? request.uri.fsPath : ( request.uri.toString());
         const fence = "`".repeat((path.match(/`+/g)?.reduce((m, s) => Math.max(m, s.length), 0) ?? 0) + 1);
         const codePath = `${fence}${path}${fence}`;
-        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5507, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5508, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
-        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5509, "+1 more request waiting")) : ( localize(5510, "+{0} more requests waiting", totalPending - 1)) : undefined;
+        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(6034, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(6035, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
+        const description = totalPending > 1 ? totalPending === 2 ? ( localize(6036, "+1 more request waiting")) : ( localize(6037, "+{0} more requests waiting", totalPending - 1)) : undefined;
         return {
             id: AgentHostPermissionUiContribution_1.NOTIFICATION_ID,
             severity: ChatInputNotificationSeverity.Warning,
             message,
             description,
             actions: [{
-                label: ( localize(5511, "Deny")),
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6038, "Deny")),
                 commandId: DENY_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5512, "Allow")),
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6039, "Allow")),
                 commandId: ALLOW_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5513, "Always Allow")),
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6040, "Always Allow")),
                 commandId: ALLOW_ALWAYS_COMMAND,
                 commandArgs: [request.id]
             }],

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostPromptCacheNotification.d.ts

@@ -0,0 +1,21 @@
+import { Disposable, type IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type IAgentSubscription } from "../../../../../../platform/agentHost/common/state/agentSubscription.js";
+import { type SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
+import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
+export declare class AgentHostPromptCacheNotification extends Disposable {
+    private readonly _notificationService;
+    private readonly _storageService;
+    private readonly _logService;
+    private readonly _trackedSessions;
+    private readonly _cacheExpirations;
+    private readonly _dismissedExpirations;
+    private _experimentEnabled;
+    constructor(_notificationService: IChatInputNotificationService, assignmentService: IWorkbenchAssignmentService, _storageService: IStorageService, _logService: ILogService);
+    trackSession(sessionResource: URI, subscription: IAgentSubscription<SessionState>): IDisposable;
+    private _updateNotification;
+    private _notificationId;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostPromptCacheNotification.js

@@ -0,0 +1,137 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { readSessionPromptCacheState } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+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 { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { ChatInputNotificationActionKind, ChatInputNotificationSeverity } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
+
+const PROMPT_CACHE_EXPIRATION_NOTIFICATION_EXPERIMENT = "copilotchat.promptCacheExpirationNotification";
+const PROMPT_CACHE_EXPIRATION_DISABLED_STORAGE_KEY = "chat.promptCacheExpirationNotification.disabled";
+const DISABLE_PROMPT_CACHE_EXPIRATION_NOTIFICATION_COMMAND = "workbench.action.chat.disablePromptCacheExpirationNotification";
+const PROMPT_CACHE_EXPIRATION_LEARN_MORE_URL = "https://code.visualstudio.com/docs/agents/agent-troubleshooting/cache-explorer#_why-prompt-caching-matters";
+let AgentHostPromptCacheNotification = class AgentHostPromptCacheNotification extends Disposable {
+    constructor(_notificationService, assignmentService, _storageService, _logService) {
+        super();
+        this._notificationService = _notificationService;
+        this._storageService = _storageService;
+        this._logService = _logService;
+        this._trackedSessions = this._register(( new DisposableMap()));
+        this._cacheExpirations = ( new ResourceMap());
+        this._dismissedExpirations = ( new ResourceMap());
+        this._experimentEnabled = false;
+        this._register(
+            CommandsRegistry.registerCommand(DISABLE_PROMPT_CACHE_EXPIRATION_NOTIFICATION_COMMAND, () => {
+                this._storageService.store(
+                    PROMPT_CACHE_EXPIRATION_DISABLED_STORAGE_KEY,
+                    true,
+                    StorageScope.PROFILE,
+                    StorageTarget.USER
+                );
+                for (const sessionResource of ( this._cacheExpirations.keys())) {
+                    this._notificationService.deleteNotification(this._notificationId(sessionResource));
+                }
+            })
+        );
+        this._register(this._notificationService.onDidDismiss(id => {
+            for (const [sessionResource, cacheExpiresAt] of this._cacheExpirations) {
+                if (id === this._notificationId(sessionResource)) {
+                    this._dismissedExpirations.set(sessionResource, cacheExpiresAt);
+                    break;
+                }
+            }
+        }));
+        void assignmentService.getTreatment(PROMPT_CACHE_EXPIRATION_NOTIFICATION_EXPERIMENT).then(enabled => {
+            this._experimentEnabled = enabled === true;
+            for (const sessionResource of ( this._cacheExpirations.keys())) {
+                this._updateNotification(sessionResource);
+            }
+        }).catch(error => this._logService.warn(
+            `[AgentHostPromptCacheNotification] Failed to resolve experiment: ${error}`
+        ));
+    }
+    trackSession(sessionResource, subscription) {
+        const key = ( sessionResource.toString());
+        const store = ( new DisposableStore());
+        this._trackedSessions.set(key, store);
+        const expirationScheduler = store.add(( new RunOnceScheduler(() => this._updateNotification(sessionResource), 0)));
+        const update = state => {
+            expirationScheduler.cancel();
+            const promptCache = state && !(state instanceof Error) ? readSessionPromptCacheState(state._meta) : undefined;
+            if (promptCache) {
+                if (this._cacheExpirations.get(sessionResource) !== promptCache.cacheExpiresAt) {
+                    this._dismissedExpirations.delete(sessionResource);
+                }
+                this._cacheExpirations.set(sessionResource, promptCache.cacheExpiresAt);
+                const expirationTime = Date.parse(promptCache.cacheExpiresAt);
+                if (Number.isFinite(expirationTime)) {
+                    const remainingTime = expirationTime - Date.now();
+                    if (remainingTime > 0) {
+                        expirationScheduler.schedule(remainingTime);
+                    }
+                }
+            } else {
+                this._cacheExpirations.delete(sessionResource);
+                this._dismissedExpirations.delete(sessionResource);
+            }
+            this._updateNotification(sessionResource);
+        };
+        store.add(subscription.onDidChange(update));
+        update(subscription.value);
+        store.add(toDisposable(() => {
+            this._cacheExpirations.delete(sessionResource);
+            this._dismissedExpirations.delete(sessionResource);
+            this._notificationService.deleteNotification(this._notificationId(sessionResource));
+        }));
+        return toDisposable(() => this._trackedSessions.deleteAndDispose(key));
+    }
+    _updateNotification(sessionResource) {
+        const cacheExpiresAt = this._cacheExpirations.get(sessionResource);
+        const expirationTime = cacheExpiresAt ? Date.parse(cacheExpiresAt) : Number.NaN;
+        const disabled = this._storageService.getBoolean(PROMPT_CACHE_EXPIRATION_DISABLED_STORAGE_KEY, StorageScope.PROFILE, false);
+        if (!this._experimentEnabled || disabled || !Number.isFinite(expirationTime) || Date.now() < expirationTime) {
+            this._notificationService.deleteNotification(this._notificationId(sessionResource));
+            return;
+        }
+        if (this._dismissedExpirations.get(sessionResource) === cacheExpiresAt) {
+            return;
+        }
+        this._notificationService.setNotification({
+            id: this._notificationId(sessionResource),
+            telemetryId: "copilot.promptCacheExpired",
+            severity: ChatInputNotificationSeverity.Info,
+            message: ( localize(6041, "This chat's prompt cache is stale")),
+            description: ( new MarkdownString(( localize(
+                6042,
+                "The next prompt will incur increased cost. Consider starting a new chat. [Learn more]({0})",
+                PROMPT_CACHE_EXPIRATION_LEARN_MORE_URL
+            )))),
+            actions: [{
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6043, "Start New Chat")),
+                commandId: "workbench.action.chat.newChat"
+            }],
+            dismissible: true,
+            autoDismissOnMessage: true,
+            mute: {
+                commandId: DISABLE_PROMPT_CACHE_EXPIRATION_NOTIFICATION_COMMAND,
+                tooltip: ( localize(6044, "Don't Show Again"))
+            },
+            sessionResources: [sessionResource]
+        });
+    }
+    _notificationId(sessionResource) {
+        return `copilot.promptCacheExpired.${( sessionResource.toString())}`;
+    }
+};
+AgentHostPromptCacheNotification = ( __decorate([( __param(0, IChatInputNotificationService)), ( __param(1, IWorkbenchAssignmentService)), ( __param(2, IStorageService)), ( __param(3, ILogService))], AgentHostPromptCacheNotification));
+
+export { AgentHostPromptCacheNotification };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostProtectedResourcesService.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type AgentProvider } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { type ProtectedResourceMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { IAgentHostProtectedResourcesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostProtectedResourcesService.service";
+export declare class AgentHostProtectedResourcesService extends Disposable implements IAgentHostProtectedResourcesService {
+    private readonly _agentHostService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<string>;
+    /**
+     * Signature of the protected resources last seen per provider, so a change is
+     * emitted only when the advertised set actually changes (e.g. Claude switching
+     * between native and proxy) rather than on every root state update.
+     */
+    private readonly _lastSignature;
+    constructor(_agentHostService: IAgentHostService);
+    getProtectedResources(providerId: AgentProvider): readonly ProtectedResourceMetadata[] | undefined;
+    private _sync;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostProtectedResourcesService.js

@@ -0,0 +1,55 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+let AgentHostProtectedResourcesService = class AgentHostProtectedResourcesService extends Disposable {
+    constructor(_agentHostService) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._lastSignature = ( new Map());
+        this._register(
+            this._agentHostService.rootState.onDidChange(rootState => this._sync(rootState))
+        );
+        const initial = this._agentHostService.rootState.value;
+        if (initial && !(initial instanceof Error)) {
+            this._sync(initial);
+        }
+    }
+    getProtectedResources(providerId) {
+        const rootState = this._agentHostService.rootState.value;
+        if (!rootState || rootState instanceof Error) {
+            return undefined;
+        }
+        const agent = rootState.agents.find(a => a.provider === providerId);
+        return agent ? agent.protectedResources ?? [] : undefined;
+    }
+    _sync(rootState) {
+        const incoming = ( new Set(( rootState.agents.map(a => a.provider))));
+        const changed = [];
+        for (const provider of [...( this._lastSignature.keys())]) {
+            if (!( incoming.has(provider))) {
+                this._lastSignature.delete(provider);
+                changed.push(provider);
+            }
+        }
+        for (const agent of rootState.agents) {
+            const signature = JSON.stringify(( (agent.protectedResources ?? []).map(resource => [resource.resource, resource.required !== false])));
+            if (this._lastSignature.get(agent.provider) !== signature) {
+                this._lastSignature.set(agent.provider, signature);
+                changed.push(agent.provider);
+            }
+        }
+        for (const provider of changed) {
+            this._onDidChange.fire(provider);
+        }
+    }
+};
+AgentHostProtectedResourcesService = ( __decorate([( __param(0, IAgentHostService))], AgentHostProtectedResourcesService));
+
+export { AgentHostProtectedResourcesService };