@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxReadOnlySessionHandler.d.ts

@@ -0,0 +1,45 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+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 { ICloudSandboxApiService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service";
+import { IReplayedTaskHistory } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/taskEventReplay";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatSession, IChatSessionContentProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+export interface ICloudSandboxReadOnlyConfig {
+    /** Mission Control task owning the session, which is what persisted history is addressed by. */
+    readonly taskId: string;
+    /** Chat participant id. Matches the live handler, where `agentId === sessionType`. */
+    readonly agentId: string;
+    /** Sanitized agent-host authority used to rewrite resource URIs in history. */
+    readonly connectionAuthority: string;
+    /**
+     * History already in flight, so the first open does not repeat a fetch running alongside the
+     * connect. Consumed once; later opens read afresh so a stale prefetch cannot pin the transcript.
+     */
+    readonly prefetchedHistory?: Promise<IReplayedTaskHistory | undefined>;
+}
+/**
+ * Content provider for cloud sandbox sessions served from Mission Control's persisted history
+ * rather than a live host — a dormant environment, or one whose connect failed.
+ *
+ * Registered only while no connection exists, and disposed as soon as one is established, so it
+ * never shadows the live handler.
+ */
+export declare class CloudSandboxReadOnlySessionHandler extends Disposable implements IChatSessionContentProvider {
+    private readonly _config;
+    private readonly _apiService;
+    private readonly _logService;
+    /** Cleared on first use, so only the opening read benefits from work already in flight. */
+    private _prefetchedHistory;
+    /**
+     * Starts `false`: an environment that goes on to wake must not have been shown as read-only.
+     * Observable so an already-rendered session can be settled in place by {@link markReadOnly}.
+     */
+    private readonly _isReadOnly;
+    constructor(_config: ICloudSandboxReadOnlyConfig, _apiService: ICloudSandboxApiService, _logService: ILogService);
+    /** Settle as read-only once the connect has failed; open sessions disable their composer. */
+    markReadOnly(): void;
+    /** Persisted history, preferring a prefetch already in flight over a fresh read. */
+    private _readHistory;
+    provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
+}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxReadOnlySessionHandler.js

@@ -0,0 +1,109 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+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 { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+import { ICloudSandboxApiService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { turnsToHistory, messageToRequestOrigin, messageToVariableData, activeTurnToProgress } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/stateToProgressAdapter';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const LOG_PREFIX = "[CloudSandboxReadOnly]";
+class ReadOnlyChatSession extends Disposable {
+    constructor(sessionResource, history, title, isReadOnly) {
+        super();
+        this.sessionResource = sessionResource;
+        this.history = history;
+        this.title = title;
+        this.isReadOnly = isReadOnly;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+    }
+    dispose() {
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+}
+let CloudSandboxReadOnlySessionHandler = class CloudSandboxReadOnlySessionHandler extends Disposable {
+    constructor(_config, _apiService, _logService) {
+        super();
+        this._config = _config;
+        this._apiService = _apiService;
+        this._logService = _logService;
+        this._isReadOnly = observableValue("cloudSandboxReadOnly", false);
+        this._prefetchedHistory = _config.prefetchedHistory;
+    }
+    markReadOnly() {
+        this._isReadOnly.set(true, undefined);
+    }
+    async _readHistory(token) {
+        const prefetched = this._prefetchedHistory;
+        this._prefetchedHistory = undefined;
+        if (prefetched) {
+            const replayed = await prefetched;
+            if (replayed) {
+                return replayed;
+            }
+        }
+        return this._apiService.getSessionHistory(this._config.taskId, token);
+    }
+    async provideChatSessionContent(sessionResource, token) {
+        const sessionId = AgentSession.id(sessionResource);
+        const replayed = await this._readHistory(token);
+        const session = replayed?.sessions.find(s => AgentSession.id(( URI.parse(s.session))) === sessionId);
+        if (!session) {
+            this._logService.warn(
+                `${LOG_PREFIX} No persisted history for session ${sessionId} in task ${this._config.taskId} (replayed sessions: [${replayed?.sessions.map(s => s.session).join(", ") ?? "none"}]); opening an empty read-only session.`
+            );
+            return ( new ReadOnlyChatSession(sessionResource, [], undefined, this._isReadOnly));
+        }
+        const chat = session.chats.get(session.defaultChat) ?? [...( session.chats.values())][0];
+        const history = chat ? turnsToHistory(( URI.parse(session.session)), chat.turns, this._config.agentId, this._config.connectionAuthority, undefined, undefined, undefined, undefined, this._config.agentId) : [];
+        const active = chat?.activeTurn;
+        if (active) {
+            history.push({
+                id: active.id,
+                type: "request",
+                prompt: active.message.text,
+                participant: this._config.agentId,
+                variableData: messageToVariableData(active.message, this._config.connectionAuthority),
+                origin: messageToRequestOrigin(( URI.parse(session.session)), active.message, this._config.agentId, this._config.agentId)
+            });
+            history.push({
+                type: "response",
+                parts: activeTurnToProgress(( URI.parse(session.session)), active, this._config.connectionAuthority, sessionResource.authority),
+                participant: this._config.agentId
+            });
+        }
+        if (replayed?.truncated) {
+            this._logService.warn(
+                `${LOG_PREFIX} History for task ${this._config.taskId} is truncated; the final exchange may be incomplete.`
+            );
+            history.push({
+                type: "response",
+                parts: [{
+                    kind: "warning",
+                    content: ( new MarkdownString(( localize(
+                        4265,
+                        "This conversation is incomplete. Its recorded history ends mid-response, so the last exchange may be missing."
+                    ))))
+                }],
+                participant: this._config.agentId
+            });
+        }
+        this._logService.info(`${LOG_PREFIX} Opened ${( sessionResource.toString())} read-only with ${history.length} history item(s) from ${chat?.turns.length ?? 0} turn(s); chats=[${[...( session.chats.keys())].join(", ")}], default=${session.defaultChat}.`);
+        return ( new ReadOnlyChatSession(
+            sessionResource,
+            history,
+            session.state.title || undefined,
+            this._isReadOnly
+        ));
+    }
+};
+CloudSandboxReadOnlySessionHandler = ( __decorate([( __param(1, ICloudSandboxApiService)), ( __param(2, ILogService))], CloudSandboxReadOnlySessionHandler));
+
+export { CloudSandboxReadOnlySessionHandler };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxSessionsProvider.d.ts

@@ -0,0 +1,49 @@
+import { type IAgentSessionMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
+import type { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { RemoteAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
+/**
+ * Sessions provider for a Copilot cloud sandbox.
+ *
+ * Adds the handling for sessions this client provisioned but the host has not materialized yet:
+ * Mission Control mints the session id and returns it before the sandbox is even awake, so such a
+ * session is real, addressable, and unknown to the host all at once.
+ */
+export declare class CloudSandboxSessionsProvider extends RemoteAgentHostSessionsProvider {
+    /**
+     * Provisional sessions kept out of {@link getSessions} because the caller is still showing a
+     * placeholder row for them. They stay reachable by resource, so opening one still works.
+     */
+    private readonly _withheldSessions;
+    /**
+     * Raw id → deadline after which eviction resumes, or `undefined` while the clock has not
+     * started. It starts when a connected host first omits the session, not at seed time, because
+     * waking a sandbox can take minutes.
+     */
+    private readonly _provisionalSessions;
+    /** How long a provisional session resists eviction after the host first omits it. */
+    static readonly PROVISIONAL_GRACE_MS: number;
+    /**
+     * Seed a session this client just provisioned. It is cached so a later discovery pass
+     * reconciles against it rather than adding a second entry, but stays out of the sessions list
+     * until {@link publishWithheldSession} and resists eviction until the host lists it.
+     */
+    seedProvisionalSession(rawMeta: IAgentSessionMetadata): void;
+    /**
+     * Reveal a session seeded by {@link seedProvisionalSession}, so {@link getSessions} returns it.
+     *
+     * Pass `announce: false` when the caller immediately fires its own change event covering this
+     * session: the list re-reads {@link getSessions} on any change, so a single event can both drop
+     * a placeholder row and reveal this one.
+     */
+    publishWithheldSession(rawId: string, options?: {
+        announce?: boolean;
+    }): void;
+    /**
+     * Look up a cached session by raw id, **including** ones withheld from {@link getSessions},
+     * which callers that seeded a session need before it is listed.
+     */
+    getCachedSession(rawId: string): ISession | undefined;
+    getSessions(): ISession[];
+    protected _isSessionEvictable(rawId: string): boolean;
+    protected _onHostListedSessions(rawIds: ReadonlySet<string>): void;
+}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxSessionsProvider.js

@@ -0,0 +1,69 @@
+
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+import { RemoteAgentHostSessionsProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider';
+
+class CloudSandboxSessionsProvider extends RemoteAgentHostSessionsProvider {
+    constructor() {
+        super(...arguments);
+        this._withheldSessions = ( new Set());
+        this._provisionalSessions = ( new Map());
+    }
+    static {
+        this.PROVISIONAL_GRACE_MS = 2 * 60_000;
+    }
+    seedProvisionalSession(rawMeta) {
+        const meta = this._adoptSessionMeta(rawMeta);
+        const rawId = AgentSession.id(meta.session);
+        if (( this._sessionCache.has(rawId))) {
+            return;
+        }
+        this._sessionCache.set(rawId, this.createAdapter(meta));
+        this._withheldSessions.add(rawId);
+        this._provisionalSessions.set(rawId, undefined);
+    }
+    publishWithheldSession(rawId, options) {
+        if (!this._withheldSessions.delete(rawId)) {
+            return;
+        }
+        const session = this._sessionCache.get(rawId);
+        if (session && options?.announce !== false) {
+            this._onDidChangeSessions.fire({
+                added: [session],
+                removed: [],
+                changed: []
+            });
+        }
+    }
+    getCachedSession(rawId) {
+        return this._sessionCache.get(rawId);
+    }
+    getSessions() {
+        const sessions = super.getSessions();
+        return this._withheldSessions.size === 0 ? sessions : sessions.filter(session => !( this._withheldSessions.has(AgentSession.id(session.resource))));
+    }
+    _isSessionEvictable(rawId) {
+        if (!( this._provisionalSessions.has(rawId))) {
+            return true;
+        }
+        const deadline = this._provisionalSessions.get(rawId);
+        if (deadline === undefined || Date.now() < deadline) {
+            return false;
+        }
+        this._provisionalSessions.delete(rawId);
+        return true;
+    }
+    _onHostListedSessions(rawIds) {
+        if (this._provisionalSessions.size === 0) {
+            return;
+        }
+        for (const [rawId, deadline] of [...this._provisionalSessions]) {
+            if (( rawIds.has(rawId))) {
+                this._provisionalSessions.delete(rawId);
+            } else if (deadline === undefined) {
+                this._provisionalSessions.set(rawId, Date.now() + CloudSandboxSessionsProvider.PROVISIONAL_GRACE_MS);
+            }
+        }
+    }
+}
+
+export { CloudSandboxSessionsProvider };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/entryDrivenProviderContribution.d.ts

@@ -0,0 +1,47 @@
+import { type Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, DisposableMap, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type IRemoteAgentHostEntry, RemoteAgentHostConnectionStatus, RemoteAgentHostEntryType } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { type IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { type IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { type INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { type IAgentHostAutoConnect, type IAgentHostConnectProgress } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider";
+import { type ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { RemoteAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
+/** Options supplied by a remote-host kind when creating its sessions provider. */
+export interface IEntryDrivenProviderOptions {
+    readonly connectOnDemand?: () => Promise<void>;
+    readonly disconnectOnDemand?: () => Promise<void>;
+    readonly onDidReportConnectProgress?: Event<IAgentHostConnectProgress>;
+    readonly autoConnect?: IAgentHostAutoConnect;
+    readonly initialStatus?: RemoteAgentHostConnectionStatus;
+    readonly preferenceKey?: string;
+}
+/**
+ * Shared provider ownership for remote-host kinds whose providers correspond
+ * directly to remote-host entries. Subclasses own their entry discovery and
+ * on-demand connection behavior; this class owns only provider lifecycle.
+ */
+export declare abstract class EntryDrivenProviderContribution extends Disposable {
+    protected readonly _remoteAgentHostService: IRemoteAgentHostService;
+    protected readonly _configurationService: IConfigurationService;
+    protected readonly _instantiationService: IInstantiationService;
+    protected readonly _sessionsProvidersService: ISessionsProvidersService;
+    protected readonly _notificationService: INotificationService;
+    protected readonly _providerStores: DisposableMap<string, DisposableStore>;
+    protected readonly _providerInstances: Map<string, RemoteAgentHostSessionsProvider>;
+    private readonly _wiredAddresses;
+    constructor(_remoteAgentHostService: IRemoteAgentHostService, _configurationService: IConfigurationService, _instantiationService: IInstantiationService, _sessionsProvidersService: ISessionsProvidersService, _notificationService: INotificationService);
+    protected get _enabled(): boolean;
+    /** The entry kind this contribution owns when discovering configured entries. */
+    protected abstract readonly _entryType: RemoteAgentHostEntryType;
+    /** Supplies all entries owned by this contribution. */
+    protected _getProviderEntries(): readonly IRemoteAgentHostEntry[];
+    /** Supplies kind-specific on-demand behavior for an entry's provider. */
+    protected abstract _getProviderOptions(entry: IRemoteAgentHostEntry): IEntryDrivenProviderOptions;
+    protected _reconcile(): void;
+    protected _reconcileProviders(): void;
+    protected _createProvider(address: string, name: string, options: IEntryDrivenProviderOptions): RemoteAgentHostSessionsProvider;
+    private _wireConnections;
+    private _updateConnectionStatuses;
+}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/entryDrivenProviderContribution.js

@@ -0,0 +1,109 @@
+
+import { Disposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { RemoteAgentHostsEnabledSettingId, getEntryAddress, RemoteAgentHostConnectionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { RemoteAgentHostSessionsProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider';
+import { watchForIncompatibleNotifications } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteHostOptions';
+
+class EntryDrivenProviderContribution extends Disposable {
+    constructor(
+        _remoteAgentHostService,
+        _configurationService,
+        _instantiationService,
+        _sessionsProvidersService,
+        _notificationService
+    ) {
+        super();
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._notificationService = _notificationService;
+        this._providerStores = this._register(( new DisposableMap()));
+        this._providerInstances = ( new Map());
+        this._wiredAddresses = ( new Set());
+    }
+    get _enabled() {
+        return this._configurationService.getValue(RemoteAgentHostsEnabledSettingId);
+    }
+    _getProviderEntries() {
+        if (!this._enabled) {
+            return [];
+        }
+        return this._remoteAgentHostService.configuredEntries.filter(entry => entry.connection.type === this._entryType);
+    }
+    _reconcile() {
+        this._reconcileProviders();
+        this._wireConnections();
+        this._updateConnectionStatuses();
+    }
+    _reconcileProviders() {
+        const entries = this._getProviderEntries();
+        const desiredAddresses = ( new Set(entries.map(entry => getEntryAddress(entry))));
+        for (const [address] of this._providerStores) {
+            if (!( desiredAddresses.has(address))) {
+                this._providerStores.deleteAndDispose(address);
+            }
+        }
+        for (const entry of entries) {
+            const address = getEntryAddress(entry);
+            const existing = this._providerInstances.get(address);
+            if (existing && existing.label !== (entry.name || address)) {
+                this._providerStores.deleteAndDispose(address);
+            }
+            if (!( this._providerStores.has(address))) {
+                this._createProvider(address, entry.name, this._getProviderOptions(entry));
+            }
+        }
+    }
+    _createProvider(address, name, options) {
+        const store = ( new DisposableStore());
+        const provider = this._instantiationService.createInstance(RemoteAgentHostSessionsProvider, {
+            address,
+            name,
+            connectOnDemand: options.connectOnDemand,
+            disconnectOnDemand: options.disconnectOnDemand,
+            onDidReportConnectProgress: options.onDidReportConnectProgress,
+            autoConnect: options.autoConnect,
+            preferenceKey: options.preferenceKey
+        });
+        if (options.initialStatus !== undefined) {
+            provider.setConnectionStatus(options.initialStatus);
+        }
+        store.add(provider);
+        store.add(this._sessionsProvidersService.registerProvider(provider));
+        store.add(
+            watchForIncompatibleNotifications(provider, this._instantiationService, this._notificationService)
+        );
+        this._providerInstances.set(address, provider);
+        store.add(toDisposable(() => {
+            this._providerInstances.delete(address);
+            this._wiredAddresses.delete(address);
+        }));
+        this._providerStores.set(address, store);
+        return provider;
+    }
+    _wireConnections() {
+        for (const [address, provider] of this._providerInstances) {
+            const connectionInfo = this._remoteAgentHostService.connections.find(connection => connection.address === address);
+            if (connectionInfo && RemoteAgentHostConnectionStatus.isConnected(connectionInfo.status)) {
+                const connection = this._remoteAgentHostService.getConnection(address);
+                if (connection) {
+                    provider.setConnection(connection, connectionInfo.defaultDirectory);
+                    this._wiredAddresses.add(address);
+                }
+            } else if (this._wiredAddresses.delete(address)) {
+                provider.clearConnection();
+            }
+        }
+    }
+    _updateConnectionStatuses() {
+        for (const [address, provider] of this._providerInstances) {
+            const connectionInfo = this._remoteAgentHostService.connections.find(connection => connection.address === address);
+            if (connectionInfo) {
+                provider.setConnectionStatus(connectionInfo.status);
+            }
+        }
+    }
+}
+
+export { EntryDrivenProviderContribution };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/hostFilter.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/hostFilter.contribution.js

@@ -0,0 +1,72 @@
+
+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, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IsWebContext } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkeys';
+import { IsAuxiliaryWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IsPhoneLayoutContext, IsNewChatSessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { IAgentHostFilterService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service';
+import { HostFilterActionViewItem } from './hostFilterActionViewItem.js';
+import { MobileHostFilterActionViewItem } from './mobileHostFilterActionViewItem.js';
+
+const PICK_HOST_FILTER_ID = "sessions.agentHostFilter.pick";
+registerAction2(class PickAgentHostFilterAction extends Action2 {
+    constructor() {
+        super({
+            id: PICK_HOST_FILTER_ID,
+            title: ( localize2(4271, "Select Agent Host")),
+            f1: false,
+            menu: [{
+                id: Menus.SidebarAgentHost,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(IsWebContext, ( IsAuxiliaryWindowContext.toNegated()), ( IsPhoneLayoutContext.negate())))
+            }, {
+                id: Menus.MobileTitleBarCenter,
+                group: "navigation",
+                order: 0,
+                when: ( ContextKeyExpr.and(IsWebContext, ( IsAuxiliaryWindowContext.toNegated()), IsNewChatSessionContext))
+            }]
+        });
+    }
+    async run(_accessor) {}
+});
+let AgentHostFilterContribution = class AgentHostFilterContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.agentHostFilter";
+    }
+    constructor(filterService, actionViewItemService) {
+        super();
+        const registered = this._register(( new Emitter()));
+        const refreshSignal = Event.any(
+            filterService.onDidChange,
+            filterService.onDidChangeDiscovering,
+            registered.event
+        );
+        this._register(actionViewItemService.register(
+            Menus.SidebarAgentHost,
+            PICK_HOST_FILTER_ID,
+            (action, _options, instaService) => instaService.createInstance(HostFilterActionViewItem, action, "sidebar"),
+            refreshSignal
+        ));
+        this._register(actionViewItemService.register(
+            Menus.MobileTitleBarCenter,
+            PICK_HOST_FILTER_ID,
+            (action, _options, instaService) => instaService.createInstance(MobileHostFilterActionViewItem, action),
+            refreshSignal
+        ));
+        queueMicrotask(() => registered.fire());
+    }
+};
+AgentHostFilterContribution = ( __decorate([( __param(0, IAgentHostFilterService)), ( __param(1, IActionViewItemService))], AgentHostFilterContribution));
+registerWorkbenchContribution2(
+    AgentHostFilterContribution.ID,
+    AgentHostFilterContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/hostFilterActionViewItem.d.ts

@@ -0,0 +1,79 @@
+import { BaseActionViewItem } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IAgentHostFilterService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service";
+/**
+ * Visual appearance of {@link HostFilterActionViewItem}.
+ *
+ * - `titlebar` — the original compact pill designed for the desktop
+ *   titlebar's left toolbar. Fixed-height pill with `--vscode-titleBar-…`
+ *   text colors and a `max-width` so it never grows too wide.
+ * - `sidebar` — full-width row aligned with the rest of the agents
+ *   sidebar (matches `.sidebar-action-button`'s rhythm), used by the
+ *   {@link AgentHostShortcutsWidget} on web desktop.
+ */
+export type HostFilterAppearance = "titlebar" | "sidebar";
+/**
+ * Compound widget showing the agent host picker plus a connection-state
+ * button. Originally lived in the desktop titlebar, now also rendered as a
+ * sidebar row via {@link HostFilterAppearance}.
+ */
+export declare class HostFilterActionViewItem extends BaseActionViewItem {
+    private readonly _appearance;
+    protected readonly _filterService: IAgentHostFilterService;
+    private readonly _contextMenuService;
+    private readonly _hoverService;
+    private _dropdownElement;
+    private _labelElement;
+    private _chevronElement;
+    private _connectElement;
+    private _sidebarButton;
+    private _sidebarLeadingIcon;
+    private _titlebarLeadingIcon;
+    private _sidebarTrailingIcon;
+    private readonly _dropdownHover;
+    private readonly _connectHover;
+    constructor(action: IAction, _appearance: HostFilterAppearance | undefined, _filterService: IAgentHostFilterService, _contextMenuService: IContextMenuService, _hoverService: IHoverService);
+    render(container: HTMLElement): void;
+    /**
+     * Original compact pill rendered in the desktop titlebar's left toolbar.
+     * Custom DOM driven directly by click handlers + context menu service.
+     */
+    private _renderTitlebar;
+    /**
+     * Sidebar appearance — full-width row matching the Customizations links
+     * (`CustomizationLinkViewItem`). Same Monaco `Button` shell, same
+     * `.sidebar-action-button` styling, same `supportIcons` label rendering.
+     * The trailing connect indicator is rendered alongside the picker
+     * button as a sibling control, so the row visually mirrors the
+     * Customizations rows in the toolbar above without making the
+     * indicator part of the picker label.
+     */
+    private _renderSidebar;
+    private _wireConnectButton;
+    private _renderSidebarButtonAffordances;
+    protected _isInteractive(): boolean;
+    /**
+     * Whether re-discovery is the useful action, i.e. there is no host the
+     * user can connect to. True with no hosts at all, and with only
+     * non-connectable entries such as a sandbox group.
+     */
+    protected _canRetry(): boolean;
+    /**
+     * Whether clicking the pill re-runs discovery rather than opening the
+     * picker. Only when there is nothing to switch between — with 2+ entries
+     * the click opens the menu, so the affordances must read as a menu.
+     */
+    protected _retriesOnClick(): boolean;
+    private _update;
+    /**
+     * Point the leading icon at `icon`. Both appearances keep a stable element
+     * for it and only swap its codicon class — the titlebar icon carries a
+     * looping "discovering" animation that a rebuilt node would restart.
+     */
+    private _renderLeadingIcon;
+    private _updateConnectButton;
+    private _onConnectClick;
+    protected _showMenu(e: Event): void;
+}