@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.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(5971, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5972, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
+        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5973, "+1 more request waiting")) : ( localize(5974, "+{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(5975, "Deny")),
                 commandId: DENY_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5512, "Allow")),
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(5976, "Allow")),
                 commandId: ALLOW_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5513, "Always Allow")),
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(5977, "Always Allow")),
                 commandId: ALLOW_ALWAYS_COMMAND,
                 commandArgs: [request.id]
             }],

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 };

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

@@ -0,0 +1,62 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { type ChangesetFile } 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 { IEditSessionEntryDiff } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
+import { IChatResponseFileChangesProvider, IChatResponseFileEdit } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatResponseFileChangesService";
+/** Maps one Agent Host changeset file into the diff shape used by chat editors. */
+export declare function agentHostChangesetFileToEntryDiff(file: ChangesetFile, connectionAuthority: string): IEditSessionEntryDiff | undefined;
+/**
+ * Supplies the chat "Changed N files" summary for agent host responses from the
+ * authoritative per-turn changeset the host computes server-side (the same
+ * source backing the Agents-app Changes view), rather than from the chat
+ * editing session.
+ *
+ * For each `(sessionResource, requestId)` it subscribes to the session's
+ * per-turn changeset — `requestId` is the agent host turn id — and maps its
+ * files into {@link IEditSessionEntryDiff} entries. Subscriptions are acquired
+ * lazily inside the returned observable (so they exist only while a summary is
+ * actually observing the diffs) and the per-request observables are memoized so
+ * repeated lookups share one subscription.
+ *
+ * The per-request diffs are monotonic: a turn that has reported changes keeps
+ * them, because every recompute, resubscribe and reconnect passes through a
+ * window where the client can see no files and consumers hide themselves when
+ * a turn reports nothing.
+ */
+export declare class AgentHostResponseFileChangesProvider extends Disposable implements IChatResponseFileChangesProvider {
+    private readonly _connection;
+    private readonly _connectionAuthority;
+    private readonly _resolveBackendSession;
+    private readonly _resolveBackendChat;
+    private readonly _logService;
+    private readonly _perRequest;
+    private readonly _perRequestFileEdits;
+    constructor(_connection: IAgentConnection, _connectionAuthority: string, _resolveBackendSession: (sessionResource: URI) => URI | undefined, _resolveBackendChat: ((sessionResource: URI) => URI | undefined) | undefined, _logService: ILogService);
+    getChangesForRequest(sessionResource: URI, requestId: string): IObservable<readonly IEditSessionEntryDiff[]> | undefined;
+    getFileEditsForRequest(sessionResource: URI, requestId: string): IObservable<readonly IChatResponseFileEdit[]> | undefined;
+    private _createDiffsObservable;
+    /**
+     * The session-wide branch changeset, exposed as a per-turn fallback but only
+     * for the specific turn recorded as an adopted legacy Copilot CLI session's
+     * final migrated turn. That turn has no per-turn checkpoint, so without this
+     * its committed-on-branch work never appears in the chat editor (#333642).
+     * Every other case — native sessions, earlier turns, and any turn added after
+     * adoption (which has its own real per-turn changeset) — yields an empty list,
+     * so this never alters the changes shown for those turns.
+     */
+    private _createBranchFallbackDiffsObservable;
+    private _createFileEditDiffsObservable;
+    /**
+     * Builds a two-level observable that owns a refcounted subscription to
+     * `component` at the (observable) resource. The outer observable acquires
+     * the subscription against the current resource and releases it when the
+     * resource changes or no one observes; the inner observable tracks the
+     * subscription's value.
+     */
+    private _subscribe;
+    private _responsePartsToEntryDiffs;
+    private _fileEditToEntryDiff;
+}

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

@@ -0,0 +1,40 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import '../../../../../../platform/agentHost/common/changesetUri.js';
+import { normalizeFileEdit } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/fileEditDiff';
+import { toAgentHostUri, toAgentHostContentUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { FileEditKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+
+function agentHostChangesetFileToEntryDiff(file, connectionAuthority) {
+    const normalized = normalizeFileEdit(file.edit);
+    if (!normalized) {
+        return undefined;
+    }
+    const modifiedURI = toAgentHostUri(normalized.resource, connectionAuthority);
+    const originalURI = normalized.beforeContentUri ? toAgentHostContentUri(normalized.beforeContentUri, connectionAuthority) : modifiedURI;
+    const modifiedSnapshotURI = normalized.afterContentUri ? toAgentHostContentUri(normalized.afterContentUri, connectionAuthority) : undefined;
+    return {
+        originalURI,
+        modifiedURI,
+        modifiedSnapshotURI,
+        isCreated: normalized.kind === FileEditKind.Create,
+        isDeleted: normalized.kind === FileEditKind.Delete,
+        added: file.edit.diff?.added ?? 0,
+        removed: file.edit.diff?.removed ?? 0,
+        quitEarly: false,
+        identical: false,
+        isFinal: true,
+        isBusy: false
+    };
+}
+
+export { agentHostChangesetFileToEntryDiff };

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

@@ -0,0 +1,59 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { type DefaultChangesetKind } from "../../../../../../platform/agentHost/common/changesetUri.js";
+import { ISessionArtifact } from "../../../../../../platform/agentHost/common/sessionArtifacts.js";
+import { Changeset, SessionState, SessionSummaryMeta } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IClipboardService } from "@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { type ChatPillsCompactMode } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/browser/chatPills";
+import { IBrowserViewWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { ISessionChatPillVisibilityService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/sessionChatPills.service";
+import { type ChatWidget } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget";
+export interface IAgentHostSessionPillMetadata {
+    readonly pullRequestUrls: readonly string[];
+    readonly pullRequestTitles: ReadonlyMap<string, string>;
+    readonly issueUrls: readonly string[];
+    readonly issueTitles: ReadonlyMap<string, string>;
+    readonly artifacts: readonly ISessionArtifact[];
+    readonly references: readonly ISessionArtifact[];
+}
+/**
+ * Partitions Agent Host metadata into dedicated GitHub, artifact, and reference
+ * pills. Every list is most recent first, so each pill's dropdown opens on what
+ * the session did last.
+ */
+export declare function getAgentHostSessionPillMetadata(meta: SessionSummaryMeta | undefined): IAgentHostSessionPillMetadata;
+/** Resolves the session-wide changeset represented by the workbench Changes pill. */
+export declare function resolveAgentHostSessionChangeset(backendSession: URI, changesets: readonly Changeset[] | undefined, defaultKind?: DefaultChangesetKind): {
+    readonly changeset: Changeset;
+    readonly resource: URI;
+} | undefined;
+/** Resolves the chat channel URI a workbench chat resource addresses. */
+export declare function getAgentHostSessionChatResource(sessionResource: URI, state: Pick<SessionState, "chats" | "defaultChat"> | undefined): URI | undefined;
+/** Returns the workbench chat resources whose browsers belong in the current chat's pill. */
+export declare function getAgentHostSessionBrowserOwnerIds(sessionResource: URI, state: Pick<SessionState, "chats" | "defaultChat"> | undefined): ReadonlySet<string>;
+/** Adds Agent Host session metadata pills to a workbench chat input. */
+export declare class AgentHostSessionInputPills extends Disposable {
+    private readonly _widget;
+    private readonly _browserViewService;
+    private readonly _clipboardService;
+    private readonly _configurationService;
+    private readonly _editorService;
+    private readonly _openerService;
+    private readonly _browserChanged;
+    private readonly _browserListeners;
+    constructor(_widget: ChatWidget, compact: ChatPillsCompactMode, connectionsService: IAgentHostConnectionsService, _browserViewService: IBrowserViewWorkbenchService, _clipboardService: IClipboardService, _configurationService: IConfigurationService, _editorService: IEditorService, instantiationService: IInstantiationService, _openerService: IOpenerService, visibility: ISessionChatPillVisibilityService);
+    private _buildReferenceSections;
+    private _buildArtifactSections;
+    private _artifactEntry;
+    private _browserEntry;
+    private _openBrowser;
+    private _openChanges;
+    private _openExternal;
+    private _openResource;
+    private _refreshBrowserListeners;
+}