@codingame/monaco-vscode-api 37.3.3 → 37.3.4

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

@@ -0,0 +1,45 @@
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { URI } from "../../../../../base/common/uri.js";
+import { ICloudSandboxApiService } from "../../../../../platform/agentHost/common/cloudSandboxAgentHost.service.js";
+import { IReplayedTaskHistory } from "../../../../../platform/agentHost/common/taskEventReplay.js";
+import { ILogService } from "../../../../../platform/log/common/log.service.js";
+import { IChatSession, IChatSessionContentProvider } from "../../../../../workbench/contrib/chat/common/chatSessionsService.js";
+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 '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { localize } from '../../../../../nls.js';
+import { AgentSession } from '../../../../../platform/agentHost/common/agent.js';
+import { ICloudSandboxApiService } from '../../../../../platform/agentHost/common/cloudSandboxAgentHost.service.js';
+import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import { turnsToHistory, messageToRequestOrigin, messageToVariableData, activeTurnToProgress } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/stateToProgressAdapter.js';
+import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
+
+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(
+                        4381,
+                        "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 "../../../../../platform/agentHost/common/agent.js";
+import type { ISession } from "../../../../services/sessions/common/session.js";
+import { RemoteAgentHostSessionsProvider } from "./remoteAgentHostSessionsProvider.js";
+/**
+ * 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 '../../../../../platform/agentHost/common/agent.js';
+import { RemoteAgentHostSessionsProvider } from './remoteAgentHostSessionsProvider.js';
+
+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/remoteAgentHostSessionsProvider.js

@@ -164,7 +164,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         );
         this.automations = this._automationStore;
         this.browseActions = [{
-            label: ( localize(4414, "Folders")),
+            label: ( localize(4530, "Folders")),
             description: displayName,
             group: SESSION_WORKSPACE_GROUP_REMOTE,
             icon: Codicon.remote,
@@ -355,7 +355,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
     _validateBeforeCreate(_sessionType) {
         if (!this._connection) {
             throw ( new Error(( localize(
-                4415,
+                4531,
                 "Cannot create session: not connected to remote agent host '{0}'.",
                 this.label
             ))));
@@ -363,14 +363,14 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
     }
     _noAgentsErrorMessage() {
         return localize(
-            4416,
+            4532,
             "Remote agent host '{0}' has not advertised any agents yet.",
             this.label
         );
     }
     _notConnectedSendErrorMessage() {
         return localize(
-            4417,
+            4533,
             "Cannot send request: not connected to remote agent host '{0}'.",
             this.label
         );
@@ -611,7 +611,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
                 await this._connectOnDemand();
             } catch (err) {
                 this._notificationService.error(( localize(
-                    4418,
+                    4534,
                     "Failed to connect to remote agent host '{0}': {1}",
                     this.label,
                     err instanceof Error ? err.message : String(err)
@@ -620,7 +620,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
             }
         }
         if (!this._connection) {
-            this._notificationService.error(( localize(4419, "Unable to connect to remote agent host '{0}'.", this.label)));
+            this._notificationService.error(( localize(4535, "Unable to connect to remote agent host '{0}'.", this.label)));
             return undefined;
         }
         const defaultUri = agentHostUri(this._connectionAuthority, this._defaultDirectory ?? "/");
@@ -629,7 +629,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
                 canSelectFiles: false,
                 canSelectFolders: true,
                 canSelectMany: false,
-                title: ( localize(4420, "Select Folder on {0}", this.label)),
+                title: ( localize(4536, "Select Folder on {0}", this.label)),
                 availableFileSystems: [AGENT_HOST_SCHEME],
                 defaultUri
             });

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

@@ -54,7 +54,7 @@ async function runServerUpgrade(accessor, provider, upgradeMethod) {
     const progressService = accessor.get(IProgressService);
     await progressService.withProgress({
         location: ProgressLocation.Notification,
-        title: ( localize(4421, "Updating {0}...", provider.label))
+        title: ( localize(4537, "Updating {0}...", provider.label))
     }, async progress => {
         try {
             const upgradeResult = await remoteAgentHostService.triggerServerUpgrade(address, upgradeMethod);
@@ -77,7 +77,7 @@ async function runServerUpgrade(accessor, provider, upgradeMethod) {
                             break;
                         }
                         progress.report({
-                            message: ( localize(4422, "Restarting in {0}s...", secondsLeft))
+                            message: ( localize(4538, "Restarting in {0}s...", secondsLeft))
                         });
                         await timeout(1000);
                     }
@@ -86,26 +86,26 @@ async function runServerUpgrade(accessor, provider, upgradeMethod) {
                 }
                 if (!reconnectAlreadyInFlight) {
                     progress.report({
-                        message: ( localize(4423, "Reconnecting..."))
+                        message: ( localize(4539, "Reconnecting..."))
                     });
                     await reconnectRemoteHost(provider, remoteAgentHostService);
                 }
             } else if (upgradeResult.upgradeNeeded === false) {
                 notificationService.notify({
                     severity: Severity$1.Info,
-                    message: ( localize(4424, "{0} is already on the latest version.", provider.label))
+                    message: ( localize(4540, "{0} is already on the latest version.", provider.label))
                 });
             } else {
                 notificationService.notify({
                     severity: Severity$1.Warning,
-                    message: upgradeResult.error ? ( localize(4425, "Failed to update {0}: {1}", provider.label, upgradeResult.error)) : ( localize(4426, "{0} did not start an update.", provider.label))
+                    message: upgradeResult.error ? ( localize(4541, "Failed to update {0}: {1}", provider.label, upgradeResult.error)) : ( localize(4542, "{0} did not start an update.", provider.label))
                 });
             }
         } catch (err) {
             notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localize(
-                    4427,
+                    4543,
                     "Failed to update {0}: {1}",
                     provider.label,
                     err instanceof Error ? err.message : String(err)
@@ -128,18 +128,18 @@ function watchForIncompatibleNotifications(provider, instantiationService, notif
             if (upgradeMethod) {
                 primaryActions.push(toAction({
                     id: "agentHost.upgradeFromIncompatible",
-                    label: ( localize(4428, "Update Server")),
+                    label: ( localize(4544, "Update Server")),
                     run: () => instantiationService.invokeFunction(accessor => runServerUpgrade(accessor, provider, upgradeMethod))
                 }));
             }
             primaryActions.push(toAction({
                 id: "agentHost.showRemoteHostOptions",
-                label: ( localize(4429, "Show Options")),
+                label: ( localize(4545, "Show Options")),
                 run: () => instantiationService.invokeFunction(accessor => showRemoteHostOptions(accessor, provider))
             }));
             notificationService.notify({
                 severity: Severity$1.Warning,
-                message: ( localize(4430, "Cannot connect to {0}: {1}", provider.label, status.message)),
+                message: ( localize(4546, "Cannot connect to {0}: {1}", provider.label, status.message)),
                 actions: {
                     primary: primaryActions
                 }
@@ -151,49 +151,49 @@ function watchForIncompatibleNotifications(provider, instantiationService, notif
 function getStatusLabel(status) {
     switch (status.kind) {
     case "connected":
-        return localize(4431, "Online");
+        return localize(4547, "Online");
     case "connecting":
-        return localize(4432, "Connecting");
+        return localize(4548, "Connecting");
     case "reconnecting":
-        return localize(4433, "Reconnecting");
+        return localize(4549, "Reconnecting");
     case "disconnected":
-        return localize(4434, "Offline");
+        return localize(4550, "Offline");
     case "incompatible":
-        return localize(4435, "Incompatible");
+        return localize(4551, "Incompatible");
     }
 }
 function getStatusHover(status, address) {
     switch (status.kind) {
     case "connected":
-        return address ? ( localize(4436, "Remote agent host is connected and ready.\n\nAddress: {0}", address)) : ( localize(4437, "Remote agent host is connected and ready."));
+        return address ? ( localize(4552, "Remote agent host is connected and ready.\n\nAddress: {0}", address)) : ( localize(4553, "Remote agent host is connected and ready."));
     case "connecting":
         return address ? ( localize(
-            4438,
+            4554,
             "Attempting to connect to remote agent host...\n\nAddress: {0}",
             address
-        )) : ( localize(4439, "Attempting to connect to remote agent host..."));
+        )) : ( localize(4555, "Attempting to connect to remote agent host..."));
     case "reconnecting":
         return address ? ( localize(
-            4440,
+            4556,
             "The remote agent host connection dropped and is being restored automatically.\n\nAddress: {0}",
             address
         )) : ( localize(
-            4441,
+            4557,
             "The remote agent host connection dropped and is being restored automatically."
         ));
     case "disconnected":
-        return address ? ( localize(4442, "Remote agent host is disconnected.\n\nAddress: {0}", address)) : ( localize(4443, "Remote agent host is disconnected."));
+        return address ? ( localize(4558, "Remote agent host is disconnected.\n\nAddress: {0}", address)) : ( localize(4559, "Remote agent host is disconnected."));
     case "incompatible":
         {
             const offered = status.supportedByClient.join(", ");
             return address ? ( localize(
-                4444,
+                4560,
                 "Cannot connect to remote agent host: {0}\n\nThis client speaks protocol version {1}.\n\nAddress: {2}",
                 status.message,
                 offered,
                 address
             )) : ( localize(
-                4445,
+                4561,
                 "Cannot connect to remote agent host: {0}\n\nThis client speaks protocol version {1}.",
                 status.message,
                 offered
@@ -218,35 +218,35 @@ function buildRemoteHostOptionItems(options) {
     const items = [];
     if (options.upgradeMethod) {
         items.push({
-            label: "$(cloud-download) " + ( localize(4446, "Update Server")),
+            label: "$(cloud-download) " + ( localize(4562, "Update Server")),
             id: "upgrade"
         });
     }
     if (!options.isConnected) {
         items.push({
-            label: "$(debug-restart) " + ( localize(4447, "Reconnect")),
+            label: "$(debug-restart) " + ( localize(4563, "Reconnect")),
             id: "reconnect"
         });
     }
     items.push({
-        label: "$(trash) " + ( localize(4448, "Remove Remote")),
+        label: "$(trash) " + ( localize(4564, "Remove Remote")),
         id: "remove"
     }, {
-        label: "$(copy) " + ( localize(4449, "Copy Address")),
+        label: "$(copy) " + ( localize(4565, "Copy Address")),
         id: "copy"
     });
     items.push(
         usesSSHConfigFile(options.preferenceKey ?? options.address, options.isWebPlatform ?? isWeb) ? {
-            label: "$(settings-gear) " + ( localize(4450, "Open SSH Configuration")),
+            label: "$(settings-gear) " + ( localize(4566, "Open SSH Configuration")),
             id: "sshConfig"
         } : {
-            label: "$(settings-gear) " + ( localize(4451, "Open Settings")),
+            label: "$(settings-gear) " + ( localize(4567, "Open Settings")),
             id: "settings"
         }
     );
     if (supportsRemoteAgentHostLocationPreference(options.preferenceKey ?? options.address, options.isWebPlatform ?? isWeb)) {
         items.push({
-            label: "$(server-process) " + ( localize(4452, "Change Preferred Agent Location")),
+            label: "$(server-process) " + ( localize(4568, "Change Preferred Agent Location")),
             id: "locationPreference"
         });
     }
@@ -267,7 +267,7 @@ async function changeRemoteAgentHostLocationPreference(options) {
     const provider = options.provider;
     if (!provider) {
         options.notificationService.warn(( localize(
-            4453,
+            4569,
             "Preference saved for {0}, but no active connection was found. This takes effect the next time it connects.",
             options.hostLabel
         )));
@@ -275,14 +275,14 @@ async function changeRemoteAgentHostLocationPreference(options) {
     }
     await options.progressService.withProgress({
         location: ProgressLocation.Notification,
-        title: ( localize(4454, "Reconnecting to {0}...", options.hostLabel))
+        title: ( localize(4570, "Reconnecting to {0}...", options.hostLabel))
     }, async () => {
         try {
             await reconnectRemoteHost(provider, options.remoteAgentHostService);
-            options.notificationService.info(( localize(4455, "Preference updated for {0}.", options.hostLabel)));
+            options.notificationService.info(( localize(4571, "Preference updated for {0}.", options.hostLabel)));
         } catch (err) {
             options.notificationService.error(( localize(
-                4456,
+                4572,
                 "Preference saved for {0}, but reconnection failed: {1}",
                 options.hostLabel,
                 err instanceof Error ? err.message : String(err)
@@ -321,21 +321,21 @@ async function showRemoteHostOptions(accessor, provider, options = {}) {
     const result = await ( new Promise(resolve => {
         const store = ( new DisposableStore());
         const picker = store.add(quickInputService.createQuickPick());
-        picker.placeholder = ( localize(4457, "Options for {0}", provider.label));
+        picker.placeholder = ( localize(4573, "Options for {0}", provider.label));
         picker.items = items;
         if (RemoteAgentHostConnectionStatus.isIncompatible(status)) {
             const offered = status.supportedByClient.join(", ");
             const served = status.offeredByServer?.length ? status.offeredByServer.join(", ") : undefined;
             picker.severity = Severity$1.Warning;
             picker.validationMessage = served ? ( localize(
-                4458,
+                4574,
                 "Incompatible protocol version. We speak {0}, but {1} speaks {2}. Ensure {3} and {1} are both up to date.",
                 offered,
                 provider.label,
                 served,
                 productService.nameShort
             )) : ( localize(
-                4459,
+                4575,
                 "Incompatible protocol version. We speak {0}. Error from {1}: {2}\n\n Ensure {3} and {1} are both up to date.",
                 offered,
                 provider.label,

package/vscode/src/vs/sessions/contrib/sessionInputBanners/browser/sessionInputBannerWidget.js

@@ -99,7 +99,7 @@ let SessionInputBannerWidget = class SessionInputBannerWidget extends Disposable
             button.setTitle(action.label);
             button.setAriaLabel(`${banner.ariaLabel} ${action.label}`);
             if (button instanceof ButtonWithDropdown) {
-                button.dropdownButton.setAriaLabel(( localize(4467, "More Actions for {0}", action.label)));
+                button.dropdownButton.setAriaLabel(( localize(4583, "More Actions for {0}", action.label)));
             }
             this._buttons.push({
                 button,
@@ -220,16 +220,16 @@ let SessionInputBannerWidget = class SessionInputBannerWidget extends Disposable
     _renderNavigation(store) {
         const navigation = append(this.domNode, $(".session-input-banner-navigation"));
         const previous = store.add(( new Button(navigation, {
-            ...this._navigationButtonOptions(( localize(4468, "Previous Banner")))
+            ...this._navigationButtonOptions(( localize(4584, "Previous Banner")))
         })));
         previous.element.classList.add("session-input-banner-navigation-button", "previous");
         previous.icon = Codicon.chevronLeft;
         this._previousButton = previous;
         store.add(previous.onDidClick(() => this._move(-1, "previous")));
         const position = append(navigation, $("span.session-input-banner-position"));
-        position.textContent = ( localize(4469, "{0}/{1}", this._activeIndex + 1, this._banners.length));
+        position.textContent = ( localize(4585, "{0}/{1}", this._activeIndex + 1, this._banners.length));
         const next = store.add(( new Button(navigation, {
-            ...this._navigationButtonOptions(( localize(4470, "Next Banner")))
+            ...this._navigationButtonOptions(( localize(4586, "Next Banner")))
         })));
         next.element.classList.add("session-input-banner-navigation-button", "next");
         next.icon = Codicon.chevronRight;