@codingame/monaco-vscode-api 37.6.1 → 38.0.1

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -38,7 +38,7 @@ import '../../theme/common/colors/minimapColors.js';
 import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
-import { triggerClickAnimation } from '../../../base/browser/ui/animations/animations.js';
+import { captureAnimationTarget, triggerClickAnimation } from '../../../base/browser/ui/animations/animations.js';
 import { isDark } from '../../theme/common/theme.js';
 import { IThemeService } from '../../theme/common/themeService.service.js';
 import { hasNativeContextMenu } from '../../window/common/window.js';
@@ -208,18 +208,29 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
     async onClick(event) {
         event.preventDefault();
         event.stopPropagation();
-        if (this._options?.onClickAnimation && this.element && !this._accessibilityService.isMotionReduced()) {
-            const icon = this._menuItemAction.item.icon;
-            triggerClickAnimation(
-                this.element,
-                this._options.onClickAnimation,
-                ThemeIcon.isThemeIcon(icon) ? icon : undefined
-            );
-        }
+        const commandAction = this._commandAction;
+        let actionError;
+        const actionRunnerListener = this.actionRunner.onDidRun(event => {
+            if (event.action === commandAction) {
+                actionError = event.error;
+            }
+        });
         try {
-            await this.actionRunner.run(this._commandAction, this._context);
+            const animationTarget = this._options?.onClickAnimation && this.element ? captureAnimationTarget(this.element) : undefined;
+            await this.actionRunner.run(commandAction, this._context);
+            if (!actionError && this._options?.onClickAnimation && animationTarget && !this._accessibilityService.isMotionReduced()) {
+                const icon = this._menuItemAction.item.icon;
+                triggerClickAnimation(
+                    animationTarget,
+                    this._options.onClickAnimation,
+                    ThemeIcon.isThemeIcon(icon) ? icon : undefined
+                );
+                this._options.onDidTriggerClickAnimation?.();
+            }
         } catch (err) {
             this._notificationService.error(err);
+        } finally {
+            actionRunnerListener.dispose();
         }
     }
     render(container) {
@@ -263,7 +274,7 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altTitleSection = this._keybindingService.appendKeybinding(altTooltip, this._menuItemAction.alt.id, this._contextKeyService);
             title = ( localize(
-                1839,
+                1853,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -331,9 +342,9 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(1840, "{1} to {0}", this._action.label, kb2));
+                this.label.textContent = ( localize(1854, "{1} to {0}", this._action.label, kb2));
             } else {
-                this.label.textContent = ( localize(1841, "{0} ({1})", this._action.label, kb2));
+                this.label.textContent = ( localize(1855, "{0} ({1})", this._action.label, kb2));
             }
         }
     }

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -56,7 +56,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         const telemetrySource = _options?.telemetrySource;
         if (telemetrySource) {
             this._store.add(
-                this.actionBar.onDidRun(e => telemetryService.publicLog2("workbenchActionExecuted", {
+                this.actionBar.onWillRun(e => telemetryService.publicLog2("workbenchActionExecuted", {
                     id: e.action.id,
                     from: telemetrySource
                 }))
@@ -169,7 +169,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     } else {
                         primaryActions.push(toAction({
                             id: "label",
-                            label: ( localize(1842, "Hide")),
+                            label: ( localize(1856, "Hide")),
                             enabled: false,
                             run() {}
                         }));
@@ -183,7 +183,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(( new Separator()));
                     actions.push(toAction({
                         id: "resetThisMenu",
-                        label: ( localize(1843, "Reset Menu")),
+                        label: ( localize(1857, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }

package/vscode/src/vs/platform/actions/common/actions.service.d.ts

@@ -13,7 +13,7 @@ export interface IMenuService {
     */
     createMenu(id: MenuId, contextKeyService: IContextKeyService, options?: IMenuCreateOptions): IMenu;
     /**
-    * Creates a new menu, gets the actions, and then disposes of the menu.
+    * Gets the actions for the current context without creating a menu.
     */
     getMenuActions(id: MenuId, contextKeyService: IContextKeyService, options?: IMenuActionOptions): [
         string,

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -9,7 +9,7 @@ class MenuHiddenStatesReset extends Action2 {
     constructor() {
         super({
             id: "menu.resetHiddenStates",
-            title: ( localize2(1844, "Reset All Menus")),
+            title: ( localize2(1858, "Reset All Menus")),
             category: Categories.View,
             f1: true
         });

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -9,7 +9,8 @@ import { IContextKeyService } from '../../contextkey/common/contextkey.service.j
 import { Separator, toAction } from '../../../base/common/actions.js';
 import { StorageScope, StorageTarget } from '../../storage/common/storage.js';
 import { IStorageService } from '../../storage/common/storage.service.js';
-import { removeFastWithoutKeepingOrder } from '../../../base/common/arrays.js';
+import { removeFastWithoutKeepingOrder, groupAdjacentBy } from '../../../base/common/arrays.js';
+import { Iterable } from '../../../base/common/iterator.js';
 import { localize } from '../../../nls.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 
@@ -29,14 +30,14 @@ let MenuService = class MenuService extends Disposable {
         }, this._commandService, this._keybindingService, contextKeyService));
     }
     getMenuActions(id, contextKeyService, options) {
-        const menu = ( new MenuImpl(id, this._hiddenStates, {
-            emitEventsForSubmenuChanges: false,
-            eventDebounceDelay: 50,
-            ...options
-        }, this._commandService, this._keybindingService, contextKeyService));
-        const actions = menu.getActions(options);
-        menu.dispose();
-        return actions;
+        return createMenuActionGroups(
+            id,
+            options,
+            this._hiddenStates,
+            this._commandService,
+            this._keybindingService,
+            contextKeyService
+        );
     }
     getMenuContexts(id) {
         const menuInfo = ( new MenuInfoSnapshot(id, false));
@@ -159,6 +160,82 @@ let PersistedMenuHideState = class PersistedMenuHideState {
     }
 };
 PersistedMenuHideState = PersistedMenuHideState_1 = ( __decorate([( __param(0, IStorageService))], PersistedMenuHideState));
+function groupMenuItems(menuItems) {
+    return Array.from(
+        groupAdjacentBy(menuItems, (a, b) => (a.group || "") === (b.group || "")),
+        items => [items[0].group || "", items]
+    );
+}
+function createMenuActionGroups(
+    id,
+    options,
+    hiddenStates,
+    commandService,
+    keybindingService,
+    contextKeyService
+) {
+    const menuItems = MenuRegistry.getMenuItems(id).filter(item => contextKeyService.contextMatchesRules(item.when));
+    menuItems.sort(MenuInfo.compareMenuItems);
+    return createActionGroups(
+        id,
+        groupMenuItems(menuItems),
+        options,
+        hiddenStates,
+        commandService,
+        keybindingService,
+        contextKeyService
+    );
+}
+function createActionGroups(
+    menuId,
+    menuGroups,
+    options,
+    hiddenStates,
+    commandService,
+    keybindingService,
+    contextKeyService
+) {
+    const result = [];
+    for (const [id, items] of menuGroups) {
+        const activeActions = [];
+        for (const item of items) {
+            const isMenuItem = isIMenuItem(item);
+            if (isMenuItem) {
+                hiddenStates.setDefaultState(menuId, item.command.id, !!item.isHiddenByDefault);
+            }
+            const menuHide = createMenuHide(menuId, isMenuItem ? item.command : item, hiddenStates);
+            if (isMenuItem) {
+                const menuKeybinding = createConfigureKeybindingAction(commandService, keybindingService, item.command.id, item.when);
+                activeActions.push(( new MenuItemAction(
+                    item.command,
+                    item.alt,
+                    options,
+                    menuHide,
+                    menuKeybinding,
+                    contextKeyService,
+                    commandService
+                )));
+            } else {
+                const groups = createMenuActionGroups(
+                    item.submenu,
+                    options,
+                    hiddenStates,
+                    commandService,
+                    keybindingService,
+                    contextKeyService
+                );
+                const submenuActions = Separator.join(...groups.map(g => g[1]));
+                if (submenuActions.length > 0) {
+                    activeActions.push(( new SubmenuItemAction(item, menuHide, submenuActions)));
+                }
+            }
+        }
+        if (activeActions.length > 0) {
+            result.push([id, activeActions]);
+        }
+    }
+    return result;
+}
 class MenuInfoSnapshot {
     constructor(_id, _collectContextKeysForSubmenus) {
         this._id = _id;
@@ -183,20 +260,13 @@ class MenuInfoSnapshot {
         return this._toggledContextKeys;
     }
     refresh() {
-        this._menuGroups.length = 0;
         this._allMenuIds.clear();
         this._structureContextKeys.clear();
         this._preconditionContextKeys.clear();
         this._toggledContextKeys.clear();
         const menuItems = this._sort(MenuRegistry.getMenuItems(this._id));
-        let group;
+        this._menuGroups = groupMenuItems(menuItems);
         for (const item of menuItems) {
-            const groupName = item.group || "";
-            if (!group || group[0] !== groupName) {
-                group = [groupName, []];
-                this._menuGroups.push(group);
-            }
-            group[1].push(item);
             this._collectContextKeysAndSubmenuIds(item);
         }
         this._allMenuIds.add(this._id);
@@ -241,59 +311,28 @@ let MenuInfo = MenuInfo_1 = class MenuInfo extends MenuInfoSnapshot {
         this._commandService = _commandService;
         this._keybindingService = _keybindingService;
         this._contextKeyService = _contextKeyService;
-        this.refresh();
     }
     createActionGroups(options) {
-        const result = [];
-        for (const group of this._menuGroups) {
-            const [id, items] = group;
-            let activeActions;
-            for (const item of items) {
-                if (this._contextKeyService.contextMatchesRules(item.when)) {
-                    const isMenuItem = isIMenuItem(item);
-                    if (isMenuItem) {
-                        this._hiddenStates.setDefaultState(this._id, item.command.id, !!item.isHiddenByDefault);
-                    }
-                    const menuHide = createMenuHide(this._id, isMenuItem ? item.command : item, this._hiddenStates);
-                    if (isMenuItem) {
-                        const menuKeybinding = createConfigureKeybindingAction(this._commandService, this._keybindingService, item.command.id, item.when);
-                        (activeActions ??= []).push(( new MenuItemAction(
-                            item.command,
-                            item.alt,
-                            options,
-                            menuHide,
-                            menuKeybinding,
-                            this._contextKeyService,
-                            this._commandService
-                        )));
-                    } else {
-                        const groups = ( new MenuInfo_1(
-                            item.submenu,
-                            this._hiddenStates,
-                            this._collectContextKeysForSubmenus,
-                            this._commandService,
-                            this._keybindingService,
-                            this._contextKeyService
-                        )).createActionGroups(options);
-                        const submenuActions = Separator.join(...groups.map(g => g[1]));
-                        if (submenuActions.length > 0) {
-                            (activeActions ??= []).push(( new SubmenuItemAction(item, menuHide, submenuActions)));
-                        }
-                    }
-                }
-            }
-            if (activeActions && activeActions.length > 0) {
-                result.push([id, activeActions]);
-            }
-        }
-        return result;
+        const groups = Iterable.map(this._menuGroups, ([id, items]) => [
+            id,
+            items.filter(item => this._contextKeyService.contextMatchesRules(item.when))
+        ]);
+        return createActionGroups(
+            this._id,
+            groups,
+            options,
+            this._hiddenStates,
+            this._commandService,
+            this._keybindingService,
+            this._contextKeyService
+        );
     }
     _sort(menuItems) {
-        return menuItems.sort(MenuInfo_1._compareMenuItems);
+        return menuItems.sort(MenuInfo_1.compareMenuItems);
     }
-    static _compareMenuItems(a, b) {
-        const aGroup = a.group;
-        const bGroup = b.group;
+    static compareMenuItems(a, b) {
+        const aGroup = a.group || "";
+        const bGroup = b.group || "";
         if (aGroup !== bGroup) {
             if (!aGroup) {
                 return 1;
@@ -430,7 +469,7 @@ function createMenuHide(menu, command, states) {
     const title = typeof command.title === "string" ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localize(1845, "Hide '{0}'", title)),
+        label: ( localize(1859, "Hide '{0}'", title)),
         run() {
             states.updateHidden(menu, id, true);
         }
@@ -462,7 +501,7 @@ function createConfigureKeybindingAction(
 ) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: ( localize(1846, "Configure Keybinding")),
+        label: ( localize(1860, "Configure Keybinding")),
         enabled,
         run() {
             const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);

package/vscode/src/vs/platform/agentHost/browser/agentHostProtocolClient.d.ts

@@ -1,10 +1,14 @@
+import { CancellationToken } from "../../../base/common/cancellation.js";
 import { Event } from "../../../base/common/event.js";
-import { Disposable, IReference } from "../../../base/common/lifecycle.js";
+import { Disposable, IReference, IDisposable } from "../../../base/common/lifecycle.js";
 import { URI } from "../../../base/common/uri.js";
 import { ILogService } from "../../log/common/log.service.js";
 import { IConfigurationService } from "../../configuration/common/configuration.service.js";
 import { IAgentCreateChatRequestOptions, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult, IMcpNotification } from "../common/agent.js";
 import { IAgentConnection, IAgentHostManagedSettingsDiagnostics, IAgentHostNetworkDiagnosticsInfo, IAgentHostNetworkFetchResult, type AgentHostDebugLogsArtifactKind, type IAgentHostDebugLogsArtifact, type IAgentHostDebugLogsChunk } from "../common/agentService.js";
+import { type IAgentHostMcpAuthenticationRequest } from "../common/agentHostExtensionProtocol.js";
+import type { IAgentHostFirstResponseDiagnostic } from "../common/otel/agentHostTiming.js";
+import type { IChatUserInteractionTiming } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/otel/common/chatUserInteraction";
 import { type IRemoteWatchHandle } from "../common/agentHostFileSystemProvider.js";
 import { type IActiveSubscriptionInfo, type IAgentSubscription } from "../common/state/agentSubscription.js";
 import { type IAgentHostResourceUriMapper } from "../common/agentHostUri.js";
@@ -21,6 +25,7 @@ import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } f
 import type { FetchAutomationRunsParams, FetchAutomationRunsResult, ListAutomationTriggerDefinitionsParams, ListAutomationTriggerDefinitionsResult, RunAutomationParams, RunAutomationResult } from "../common/state/protocol/channels-automation/commands.js";
 import { ILoadEstimator } from "../../../base/parts/ipc/common/ipc.net.js";
 import { ITelemetryService } from "../../telemetry/common/telemetry.service.js";
+import { AgentHostClientConnectionKind } from "../common/agentHostTelemetry.js";
 import type { OtlpExportLogsParams } from "../common/state/protocol/channels-otlp/notifications.js";
 import type { Implementation, InitializeResult } from "../common/state/protocol/common/commands.js";
 import { type IObservable } from "../../../base/common/observable.js";
@@ -29,6 +34,8 @@ import type { IRemoteAgentHostProtocolClient } from "../common/remoteAgentHostSe
 import { IWorkspaceTrustRequestService } from "../../workspace/common/workspaceTrust.service.js";
 import { IWorkspaceTrustManagementService } from "../../workspace/common/workspaceTrust.service.js";
 import { IWorkspaceTrustEnablementService } from "../../workspace/common/workspaceTrust.service.js";
+import { type IConnectionDiagnosticEvent } from "../common/connectionDiagnostics.js";
+import { IDevContainerAgentHostMainService } from "../common/devContainerAgentHost.service.js";
 /**
  * High-level connection state of an {@link AgentHostProtocolClient}.
  * Exposed via {@link AgentHostProtocolClient.onDidChangeConnectionState}
@@ -56,8 +63,17 @@ export interface IAgentHostProtocolClientOptions {
     readonly clientInfo?: Implementation;
     /** How a dropped transport is restored. Defaults to {@link DEFAULT_RECONNECT_POLICY}. */
     readonly reconnectPolicy?: IRemoteAgentHostReconnectPolicy;
-    /** Resolves authentication to restore immediately after every fresh initialize. */
+    /** Paired OS power events exclude sleep from the recovery budget. */
+    readonly onDidSuspend?: Event<void>;
+    readonly onDidResume?: Event<void>;
+    /** Refresh connection prerequisites before constructing a replacement transport. */
+    readonly prepareReconnect?: () => Promise<void>;
+    /** Prepare credentials before initial authentication or restoration; transient failures remain reconnectable. */
+    readonly prepareAuthentication?: () => Promise<void>;
+    /** Resolves required authentication before initialization or transport recovery becomes ready. */
     readonly resolveInitialAuthentication?: () => Promise<AuthenticateParams | undefined>;
+    /** Releases resources owned by the logical protocol client after its final disposal. */
+    readonly onDispose?: () => void;
 }
 /** An initial authentication resolver failed after a successful initialize. */
 export declare class InitialAuthenticationError extends Error {
@@ -79,12 +95,15 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     private readonly _workspaceTrustEnablementService;
     private readonly _workspaceTrustManagementService;
     private readonly _workspaceTrustRequestService;
+    private _mcpAuthenticationHandler;
     readonly _serviceBrand: undefined;
     private readonly _clientId;
     private readonly _address;
     private readonly _resourceIdentity;
     private readonly _transportFactory;
     private _transport;
+    get clientConnectionKind(): AgentHostClientConnectionKind | undefined;
+    private _relayRootRefresh;
     /** Disposable holding the listeners attached to the current transport. */
     private readonly _transportListeners;
     private readonly _connectionAuthority;
@@ -98,6 +117,8 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
      * a fresh snapshot. `undefined` before the handshake completes.
      */
     private readonly _initializeResult;
+    private readonly _devContainerService;
+    get devContainerService(): IDevContainerAgentHostMainService | undefined;
     private readonly _subscriptionManager;
     private readonly _onDidAction;
     readonly onDidAction: Event<ActionEnvelope>;
@@ -124,8 +145,15 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     readonly onDidFatalClose: Event<ProtocolError>;
     private readonly _onDidChangeConnectionState;
     readonly onDidChangeConnectionState: Event<AgentHostClientState>;
+    private readonly _onDidReconnect;
+    readonly onDidReconnect: Event<void>;
     private readonly _onDidScheduleReconnect;
     readonly onDidScheduleReconnect: Event<void>;
+    private readonly _onDidConnectionDiagnostic;
+    readonly onDidConnectionDiagnostic: Event<IConnectionDiagnosticEvent>;
+    private _diagnosticAttemptId;
+    private _diagnostic;
+    private _traceConnection;
     /**
      * Discriminated state union. Read via narrowing (`_state.kind === ...`);
      * reconnect-only fields like the gate/outbox/attempt counter are only
@@ -151,30 +179,12 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
      */
     private _livenessDeferred;
     private _livenessDeferredSince;
-    /**
-     * Channels that owe a fresh snapshot because the host forgot this client
-     * (a host restart) and the fresh initialize did not carry their state.
-     * Entries persist across reconnect attempts until the channel is
-     * re-subscribed: a later `reconnect` resolves against the *new* host's
-     * sequence and can legitimately answer with a `replay`, which carries
-     * deltas only — so a channel dropped from this set before it was
-     * re-snapshotted would keep serving pre-restart state forever.
-     */
+    /** Channels awaiting a post-authentication snapshot. Entries survive interrupted recovery attempts. */
     private readonly _subscriptionsAwaitingRestore;
-    /**
-     * Set while an authentication-restore pass is in flight, cleared only once
-     * the whole pass completes.
-     *
-     * Authentication state on the host is process-global and survives a
-     * transport drop, so an ordinary reconnect needs no re-authentication. But
-     * a drop *during* the restore pass leaves the host holding whichever
-     * credentials happened to arrive first, and the next reconnect usually
-     * resolves to a `replay` — which never re-runs authentication. This flag
-     * carries that debt forward so the next successful attempt finishes it.
-     */
+    /** Keeps an interrupted authentication pass pending until a replacement connection finishes it. */
     private _authenticationRestorePending;
     /**
-     * Timestamp of the most recent message of any kind received from the
+     * Timestamp of the most recent data of any kind received from the
      * server. Used only for diagnostic logging when the close timer fires.
      */
     private _lastReadTime;
@@ -189,7 +199,7 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
      * has an unanswered reverse request or the local event loop has high load,
      * both timers re-arm instead. Once the deferral clears, it grants a full
      * liveness window before closing.
-     * Both are reset on every received message, so busy connections generate
+     * Both are reset on any inbound data, so busy connections generate
      * no ping traffic at all.
      *
      * Detects silently-dead transports (e.g. SSH/tunnel after laptop
@@ -197,6 +207,8 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
      * their own.
      */
     private readonly _pingTimer;
+    private readonly _relayKeepAliveTimer;
+    private _relayKeepAlivePending;
     private readonly _closeTimer;
     /**
      * Used to suppress watchdog-triggered closes when our own JS event loop
@@ -207,7 +219,14 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     private readonly _loadEstimator;
     private readonly _clientInfo;
     private readonly _reconnectPolicy;
+    private readonly _prepareReconnect;
+    private readonly _prepareAuthentication;
+    private readonly _reconnectDeadlineTimer;
+    private _isSuspended;
+    private _firstSessionRequestPending;
     private readonly _resolveInitialAuthentication;
+    private readonly _onDispose;
+    private _didDispose;
     /**
      * URIs we have already granted implicit read access for on this connection.
      * Uses URI-aware comparison to dedupe repeat sends and is cleared with the connection.
@@ -243,6 +262,11 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     private _transitionTo;
     private _newReconnectGate;
     private _newReconnectState;
+    private _armReconnectDeadline;
+    private _suspendReconnectDeadline;
+    private _resumeReconnectDeadline;
+    private _handleReconnectTimeout;
+    private _checkReconnectState;
     dispose(): void;
     /**
      * Connect to the remote agent host and perform the protocol handshake.
@@ -283,13 +307,7 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     private _scheduleReconnect;
     private _attemptReconnect;
     private _reconnectOrInitialize;
-    /**
-     * Record every active subscription the fresh initialize did not carry a
-     * snapshot for. The host forgot this client, so those channels still hold
-     * state produced by the previous host process and cannot be trusted until
-     * they have been re-subscribed. Rebuilt from scratch so a channel the
-     * host has since snapshotted stops being re-requested.
-     */
+    /** Restore subscriptions omitted from a handshake snapshot after authentication is re-established. */
     private _markSubscriptionsAwaitingRestore;
     /**
      * Re-subscribe every channel recorded by
@@ -303,9 +321,10 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
      * which would otherwise never deliver the snapshot these channels need.
      */
     private _restoreSubscriptionsAwaitingRestore;
-    private _restoreAuthenticationAfterFreshInitialize;
+    private _restoreAuthentication;
     private _clientMeta;
     private _applyInitializeResult;
+    private _hydrateInitializedRootState;
     /**
      * Push the renderer-owned config values the host mirrors (telemetry level,
      * proxy discovery, migrate flag, …) as `RootConfigChanged` actions. Called on
@@ -350,6 +369,7 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     trackSessionCreate(resource: URI, promise: Promise<unknown>): void;
     getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
     dispatch(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | ClientAutomationAction | ClientAutomationRunAction | IRootConfigChangedAction): void;
+    dispatchConfirmed<T>(channel: string, subscription: IAgentSubscription<T>, action: SessionAction | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | ClientAutomationAction | ClientAutomationRunAction | IRootConfigChangedAction, token: CancellationToken): Promise<ActionEnvelope>;
     /**
      * Subscribe to state at a URI. Returns the current state snapshot.
      *
@@ -382,7 +402,12 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
      * Create a new session on the remote agent host.
      */
     createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    reportFirstResponse(diagnostic: IAgentHostFirstResponseDiagnostic): Promise<void>;
+    reportUserInteraction(timing: IChatUserInteractionTiming): Promise<void>;
     removeSessionArtifact(session: URI, artifactId: string): Promise<void>;
+    stopBackgroundWork(chat: URI, id: string): Promise<boolean>;
+    refreshSubscription(resource: URI): Promise<void>;
+    importSession(session: URI): Promise<void>;
     createDetachedWorktree(session: URI, prompt: string): Promise<{
         handle: string;
         worktree: URI;
@@ -414,7 +439,11 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     /**
      * Authenticate with the remote agent host using a specific scheme.
      */
+    /** Registers the handler for silent host-initiated MCP authentication requests. */
+    registerMcpAuthenticationHandler(handler: (request: IAgentHostMcpAuthenticationRequest) => Promise<boolean>): IDisposable;
     authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
+    private _refreshRelayRootSnapshot;
+    private _readRelayRootSnapshot;
     private _normalizeAuthenticationParams;
     private _authenticationKey;
     /**
@@ -427,7 +456,8 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     getNetworkDiagnosticsInfo(): Promise<IAgentHostNetworkDiagnosticsInfo>;
     getManagedSettingsDiagnostics(): Promise<readonly IAgentHostManagedSettingsDiagnostics[]>;
     getSessionStateFile(session: URI, chat?: URI): Promise<URI | undefined>;
-    collectDebugLogs(session: URI | undefined, kind: AgentHostDebugLogsArtifactKind, chat?: URI): Promise<IAgentHostDebugLogsArtifact>;
+    collectDebugLogs(session: URI | undefined, kind: AgentHostDebugLogsArtifactKind, chat?: URI, progressToken?: string): Promise<IAgentHostDebugLogsArtifact>;
+    cancelDebugLogs(progressToken: string): Promise<void>;
     /**
      * Read one bounded slice of a debug-log artifact previously returned by
      * {@link collectDebugLogs}. `resource` is the agent-host URI handed out by
@@ -535,6 +565,8 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     private _sendRequest;
     /** Send a JSON-RPC request for a VS Code extension method (not in the protocol spec). */
     private _sendExtensionRequest;
+    /** Sends a host-specific extension request; its consumer must validate the response. */
+    sendHostExtensionRequest(method: `extensions/${string}` | `x-${string}`, params: unknown): Promise<unknown>;
     private _updateTelemetryLevel;
     private _effectiveTelemetryLevel;
     /** Merge a patch into the agent host's root configuration. */
@@ -558,10 +590,11 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
     private _shouldLogFailedRequest;
     private _toProtocolError;
     private _rejectPendingRequests;
+    private _recordInboundTraffic;
     /**
      * Reset the liveness timers. Called at construction for an already-open
      * passive transport, after a successful client-transport initialization,
-     * once on every received message (which is itself proof the remote is
+     * once on any inbound data (which is itself proof the remote is
      * alive), and once after a successful soft reconnect.
      *
      * Two timers cooperate:
@@ -585,13 +618,15 @@ export declare class AgentHostProtocolClient extends Disposable implements IAgen
      * any inbound message processed during the wake catch-up resets it
      * before the close handler runs.
      *
-     * No-op while {@link _state.kind} is {@link AgentHostClientState.Incompatible},
-     * {@link AgentHostClientState.Reconnecting}, or {@link AgentHostClientState.Closed}:
-     * the transport is not available for normal liveness traffic in those states.
+     * Reconnect recovery is supervised once its transport is established, so a
+     * silent handshake cannot leave subscription requests gated indefinitely.
      * An inbound message also clears any deferred liveness state.
      */
+    private _startRelayKeepAlive;
     private _resetLivenessTimers;
+    private _isWebPubSubRelay;
     private _cancelLivenessTimers;
+    private _canCheckLiveness;
     private _onPingTimer;
     /** Rechecks deferrals promptly, then force-closes only after a fresh liveness window expires. */
     private _onCloseTimer;