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

package/vscode/src/vs/platform/agentHost/browser/agentHostProtocolClient.js

@@ -1,1911 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { TimeoutTimer, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { toFileSystemProviderErrorCode, FileSystemProviderErrorCode } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
-import { ConfigurationTarget, ConfigurationTargetToString } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
-import { AGENT_HOST_DEBUG_LOGS_MAX_ENTRIES, AGENT_HOST_DEBUG_LOGS_CHUNK_BYTES } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
-import { RemoveSessionArtifactExtensionMethod, CreateAgentHostDetachedWorktreeExtensionMethod, SetAgentHostDetachedWorktreeArchivedExtensionMethod, ClaimAgentHostDetachedWorktreeExtensionMethod, DeleteAgentHostDetachedWorktreeExtensionMethod, ReconcileAgentHostDetachedWorktreesExtensionMethod, supportsAgentHostChatStateFile, GetAgentHostSessionStateFileExtensionMethod, CollectAgentHostDebugLogsExtensionMethod, ReadAgentHostDebugLogsChunkExtensionMethod, RequestAgentHostWorkspaceTrustExtensionMethod } from '../common/agentHostExtensionProtocol.js';
-import { AMBIENT_AGENT_HOST_AUTHORITY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService';
-import { createRemoteWatchHandle } from '../common/agentHostFileSystemProvider.js';
-import { AgentSubscriptionManager } from '../common/state/agentSubscription.js';
-import { agentHostAuthority, identityAgentHostResourceUriMapper, createAgentHostResourceUriMapper, AGENT_HOST_SCHEME, fromAgentHostUri, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { LOCAL_AGENT_HOST_RESOURCE_IDENTITY, AgentHostResourcePermissionError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService';
-import { IAgentHostResourceService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService.service';
-import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
-import { ROOT_STATE_URI, isAhpRootChannel, StateComponents, isDefaultChatUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
-import { normalizeLegacyActionEnvelope } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/legacyProtocolCompatibility';
-import { SUPPORTED_PROTOCOL_VERSIONS } from '../common/state/protocol/version/registry.js';
-import { ProtocolError, isJsonRpcRequest, isJsonRpcResponse, isJsonRpcNotification } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
-import { isClientTransport, NonReconnectableTransportError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionTransport';
-import { AhpErrorCodes, JsonRpcErrorCodes } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/errors';
-import { ReconnectResultType, ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/commands';
-import { ChatSourceKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/commands';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands';
-import { decodeBase64, encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-import { getExpirationTime, isExpired, getRemainingTimeInSeconds } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
-import { LoadEstimator } from '@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc.net';
-import { TELEMETRY_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID, TelemetryLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
-import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
-import { getTelemetryLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
-import { GLOBAL_AUTO_APPROVE_SETTING_ID, TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID, TERMINAL_AUTO_APPROVE_SETTING_ID, TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID, DISABLE_REPO_INFO_TELEMETRY_SETTING_ID, AgentHostAutoApprovePolicyRestrictedConfigKey, AgentHostWorkspaceTrustConfigKey, AgentHostTelemetryLevelConfigKey, telemetryLevelToAgentHostConfigValue, AgentHostDisableRepoInfoTelemetryConfigKey, AgentHostTerminalAutoApproveEnabledConfigKey, AgentHostTerminalAutoApproveRulesConfigKey, getAgentHostTerminalAutoApproveRulesConfig } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
-import { getAgentHostConfigurationSyncEntries, getAgentHostConfigurationSyncTarget, resolveAgentHostConfigurationSyncValue, formatAgentHostConfigurationSyncValueForLog, resolveAgentHostConfigurationSyncPatch } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConfigurationSync';
-import { managedPermissionsConfigurationIds, resolveManagedSettingsPermissions } from '../common/agentHostManagedSettings.js';
-import { toAgentHostClientMeta, AgentHostClientConnectionKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostTelemetry';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { isFileResourceRead } from '../common/resourceReadLogging.js';
-import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { DEFAULT_RECONNECT_POLICY, hasExhaustedReconnectAttempts, computeReconnectDelay } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/reconnectPolicy';
-import { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
-import { isWorktreeUnderRepository } from '../common/worktreePaths.js';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-import { MessageAttachmentKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
-
-const AHP_CLIENT_CONNECTION_CLOSED = -32e3;
-const CLIENT_SUPPORTED_PROTOCOL_VERSIONS = SUPPORTED_PROTOCOL_VERSIONS.filter(version => version !== "0.8.0");
-const PING_INTERVAL_MS = 5_000;
-const LIVENESS_TIMEOUT_MS = 20_000;
-function connectionTimeoutError(address, silenceMs) {
-    return ( new ProtocolError(
-        AHP_CLIENT_CONNECTION_CLOSED,
-        `Connection appears dead: ${address}; no message received for ${silenceMs}ms.`
-    ));
-}
-function connectionClosedError(address) {
-    return ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, `Connection closed: ${address}`));
-}
-function connectionDisposedError(address) {
-    return ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, `Connection disposed: ${address}`));
-}
-function transportLostError(address) {
-    return ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, `Transport lost (reconnecting): ${address}`));
-}
-function isConnectionClosedError(error) {
-    return error instanceof ProtocolError && error.code === AHP_CLIENT_CONNECTION_CLOSED;
-}
-var AgentHostClientState;
-(function(AgentHostClientState) {
-    AgentHostClientState["Connecting"] = "connecting";
-    AgentHostClientState["Incompatible"] = "incompatible";
-    AgentHostClientState["Connected"] = "connected";
-    AgentHostClientState["Reconnecting"] = "reconnecting";
-    AgentHostClientState["Closed"] = "closed";
-})(AgentHostClientState || (AgentHostClientState = {}));
-class InitialAuthenticationError extends Error {
-    constructor(error) {
-        super(
-            `Initial authentication failed: ${error instanceof Error ? error.message : String(error)}`
-        );
-        this.name = "InitialAuthenticationError";
-    }
-}
-let AgentHostProtocolClient = class AgentHostProtocolClient extends Disposable {
-    get clientId() {
-        return this._clientId;
-    }
-    get address() {
-        return this._address;
-    }
-    get defaultDirectory() {
-        return this._defaultDirectory;
-    }
-    get connectionState() {
-        return this._state.kind;
-    }
-    get nextReconnectAt() {
-        return this._state.kind === AgentHostClientState.Reconnecting ? this._state.reconnect.nextAttemptAt : undefined;
-    }
-    get initializeResult() {
-        return this._initializeResult;
-    }
-    constructor(
-        identity,
-        transportOrFactory,
-        options,
-        _logService,
-        _resourceService,
-        _configurationService,
-        _telemetryService,
-        _workspaceTrustEnablementService,
-        _workspaceTrustManagementService,
-        _workspaceTrustRequestService
-    ) {
-        super();
-        this._logService = _logService;
-        this._resourceService = _resourceService;
-        this._configurationService = _configurationService;
-        this._telemetryService = _telemetryService;
-        this._workspaceTrustEnablementService = _workspaceTrustEnablementService;
-        this._workspaceTrustManagementService = _workspaceTrustManagementService;
-        this._workspaceTrustRequestService = _workspaceTrustRequestService;
-        this._transportListeners = this._register(( new MutableDisposable()));
-        this._serverSeq = 0;
-        this._nextClientSeq = 1;
-        this._initializeResult = observableValue("agentHostInitializeResult", undefined);
-        this._onDidAction = this._register(( new Emitter()));
-        this.onDidAction = this._onDidAction.event;
-        this._onDidNotification = this._register(( new Emitter()));
-        this.onDidNotification = this._onDidNotification.event;
-        this._onMcpNotification = this._register(( new Emitter()));
-        this.onMcpNotification = this._onMcpNotification.event;
-        this._onDidReceiveOtlpLogs = this._register(( new Emitter()));
-        this.onDidReceiveOtlpLogs = this._onDidReceiveOtlpLogs.event;
-        this._onDidClose = this._register(( new Emitter()));
-        this.onDidClose = this._onDidClose.event;
-        this._onDidFatalClose = this._register(( new Emitter()));
-        this.onDidFatalClose = this._onDidFatalClose.event;
-        this._onDidChangeConnectionState = this._register(( new Emitter()));
-        this.onDidChangeConnectionState = this._onDidChangeConnectionState.event;
-        this._onDidScheduleReconnect = this._register(( new Emitter()));
-        this.onDidScheduleReconnect = this._onDidScheduleReconnect.event;
-        this._state = {
-            kind: AgentHostClientState.Connecting,
-            outbox: []
-        };
-        this._pendingRequests = ( new Map());
-        this._authentication = ( new Map());
-        this._nextRequestId = 1;
-        this._pendingReverseRequests = ( new WeakMap());
-        this._livenessDeferred = false;
-        this._subscriptionsAwaitingRestore = ( new Set());
-        this._authenticationRestorePending = false;
-        this._lastReadTime = Date.now();
-        this._pingTimer = this._register(new TimeoutTimer());
-        this._closeTimer = this._register(new TimeoutTimer());
-        this._grantedImplicitReadUris = ( new ResourceSet());
-        this._implicitReadGrants = this._register(( new DisposableStore()));
-        this._resourceIdentity = identity;
-        this._address = identity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY ? AMBIENT_AGENT_HOST_AUTHORITY : identity;
-        this._clientId = options?.clientId ?? generateUuid();
-        this._connectionAuthority = identity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY ? AMBIENT_AGENT_HOST_AUTHORITY : agentHostAuthority(identity);
-        this.resourceUris = identity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY ? identityAgentHostResourceUriMapper : createAgentHostResourceUriMapper(this._connectionAuthority);
-        this._loadEstimator = options?.loadEstimator ?? LoadEstimator.getInstance();
-        this._clientInfo = options?.clientInfo;
-        this._reconnectPolicy = options?.reconnectPolicy ?? DEFAULT_RECONNECT_POLICY;
-        this._resolveInitialAuthentication = options?.resolveInitialAuthentication;
-        if (typeof transportOrFactory === "function") {
-            this._transportFactory = transportOrFactory;
-            this._installTransport(transportOrFactory());
-        } else {
-            this._transportFactory = undefined;
-            this._installTransport(transportOrFactory);
-        }
-        this._subscriptionManager = this._register(( new AgentSubscriptionManager(
-            this._clientId,
-            () => this.nextClientSeq(),
-            msg => this._logService.warn(`[AgentHostProtocolClient] ${msg}`),
-            resource => this.subscribe(resource),
-            resource => this.unsubscribe(resource)
-        )));
-        this._register(this.onDidAction(envelope => {
-            this._subscriptionManager.receiveEnvelope(envelope);
-        }));
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (this._state.kind !== AgentHostClientState.Connected) {
-                return;
-            }
-            const patch = {};
-            const mirrored = [];
-            if (e.source !== ConfigurationTarget.WORKSPACE && e.source !== ConfigurationTarget.WORKSPACE_FOLDER && e.source !== ConfigurationTarget.MEMORY) {
-                for (const entry of getAgentHostConfigurationSyncEntries(getAgentHostConfigurationSyncTarget(this._resourceIdentity))) {
-                    if (!e.affectsConfiguration(entry.settingId)) {
-                        continue;
-                    }
-                    const value = resolveAgentHostConfigurationSyncValue(this._configurationService, entry);
-                    if (value !== undefined) {
-                        patch[entry.sync.key] = value;
-                        mirrored.push(
-                            `${entry.sync.key}=${formatAgentHostConfigurationSyncValueForLog(entry.settingId, value)} (${entry.settingId})`
-                        );
-                    }
-                }
-            }
-            if (( Object.keys(patch)).length) {
-                this._logService.info(
-                    `[RemoteAgentHostProtocol] Mirroring configuration to host root config from ${ConfigurationTargetToString(e.source)}: ${mirrored.join(", ")}`
-                );
-                this._dispatchRootConfig(patch);
-            }
-            if (e.affectsConfiguration(GLOBAL_AUTO_APPROVE_SETTING_ID)) {
-                this._updateAutoApprovePolicyRestriction();
-            }
-            if (e.affectsConfiguration(TELEMETRY_SETTING_ID) || e.affectsConfiguration(TELEMETRY_OLD_SETTING_ID) || e.affectsConfiguration(TELEMETRY_CRASH_REPORTER_SETTING_ID)) {
-                this._updateTelemetryLevel();
-            }
-            if (e.affectsConfiguration(TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID)) {
-                this._updateTerminalAutoApproveEnabled();
-            }
-            if (e.affectsConfiguration(TERMINAL_AUTO_APPROVE_SETTING_ID) || e.affectsConfiguration(TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID)) {
-                this._updateTerminalAutoApproveRules();
-            }
-            if (e.affectsConfiguration(DISABLE_REPO_INFO_TELEMETRY_SETTING_ID)) {
-                this._updateDisableRepoInfoTelemetry();
-            }
-            if (( managedPermissionsConfigurationIds.some(settingId => e.affectsConfiguration(settingId)))) {
-                void this._updateManagedSettingsPermissions();
-            }
-        }));
-        this._register(Event.any(
-            this._workspaceTrustManagementService.onDidChangeTrustedFolders,
-            this._workspaceTrustManagementService.onDidChangeTrust
-        )(() => {
-            if (this._state.kind === AgentHostClientState.Connected) {
-                this._updateWorkspaceTrust();
-            }
-        }));
-        if (!isClientTransport(this._transport)) {
-            this._resetLivenessTimers();
-        }
-    }
-    _installTransport(transport) {
-        const listeners = ( new DisposableStore());
-        listeners.add(transport);
-        listeners.add(transport.onMessage(msg => this._handleMessage(msg)));
-        listeners.add(transport.onClose(() => this._handleTransportClose()));
-        this._transport = transport;
-        this._transportListeners.value = listeners;
-    }
-    _transitionTo(next) {
-        if (this._state.kind === next.kind) {
-            return;
-        }
-        if (this._state.kind === AgentHostClientState.Reconnecting) {
-            const reconnect = this._state.reconnect;
-            if (reconnect.timeoutHandle !== undefined) {
-                clearTimeout(reconnect.timeoutHandle);
-                reconnect.timeoutHandle = undefined;
-            }
-            reconnect.nextAttemptAt = undefined;
-        }
-        this._state = next;
-        this._onDidChangeConnectionState.fire(next.kind);
-    }
-    _newReconnectGate() {
-        const deferred = ( new DeferredPromise());
-        deferred.p.then(undefined, () => {});
-        return deferred;
-    }
-    _newReconnectState() {
-        return {
-            gate: this._newReconnectGate(),
-            outbox: [],
-            attempt: 0,
-            timeoutHandle: undefined,
-            nextAttemptAt: undefined
-        };
-    }
-    dispose() {
-        this._handleClose(connectionDisposedError(this._address));
-        super.dispose();
-    }
-    async connect() {
-        try {
-            if (isClientTransport(this._transport)) {
-                await this._raceClose(this._transport.connect());
-            }
-            if (this._state.kind !== AgentHostClientState.Connecting) {
-                throw transportLostError(this._address);
-            }
-            const result = await this._dispatchRequest("initialize", {
-                channel: ROOT_STATE_URI,
-                protocolVersions: [...CLIENT_SUPPORTED_PROTOCOL_VERSIONS],
-                clientId: this._clientId,
-                clientInfo: this._clientInfo,
-                _meta: this._clientMeta(),
-                initialSubscriptions: [ROOT_STATE_URI]
-            }, {
-                bypassInitializeQueue: true
-            });
-            this._applyInitializeResult(result);
-            if (this._resolveInitialAuthentication || this._authentication.size > 0) {
-                await this._restoreAuthenticationAfterFreshInitialize(AgentHostClientState.Connecting);
-                if (this._state.kind !== AgentHostClientState.Connecting) {
-                    throw transportLostError(this._address);
-                }
-            }
-            for (const snapshot of result.snapshots ?? []) {
-                if (isAhpRootChannel(snapshot.resource)) {
-                    this._subscriptionManager.handleRootSnapshot(snapshot.state, snapshot.fromSeq);
-                }
-            }
-            if (isClientTransport(this._transport) && this._state.kind === AgentHostClientState.Connecting) {
-                for (const message of this._state.outbox) {
-                    this._transport.send(message);
-                }
-                this._state.outbox.length = 0;
-            }
-            this._transitionTo({
-                kind: AgentHostClientState.Connected
-            });
-            this._resetLivenessTimers();
-        } catch (error) {
-            const protocolError = error instanceof ProtocolError ? error : ( new ProtocolError(
-                AHP_CLIENT_CONNECTION_CLOSED,
-                error instanceof Error ? error.message : String(error)
-            ));
-            if (protocolError.code === AhpErrorCodes.UnsupportedProtocolVersion || error instanceof InitialAuthenticationError) {
-                this._cancelLivenessTimers();
-                if (this._state.kind === AgentHostClientState.Connecting) {
-                    this._state.outbox.length = 0;
-                }
-                this._rejectPendingRequests(protocolError);
-                this._transitionTo({
-                    kind: AgentHostClientState.Incompatible,
-                    error: protocolError
-                });
-                throw error;
-            }
-            if (error instanceof NonReconnectableTransportError) {
-                this._handleFatalClose(protocolError, error.reason);
-                throw error;
-            }
-            if (this._state.kind === AgentHostClientState.Reconnecting) {
-                throw error;
-            }
-            if (protocolError.code === AHP_CLIENT_CONNECTION_CLOSED && this._beginReconnectFromConnecting(protocolError)) {
-                throw error;
-            }
-            this._handleClose(protocolError);
-            throw error;
-        }
-    }
-    notifyTransportClosed() {
-        this._handleTransportClose();
-    }
-    _handleTransportClose() {
-        switch (this._state.kind) {
-        case AgentHostClientState.Closed:
-            return;
-        case AgentHostClientState.Connecting:
-            if (!this._beginReconnectFromConnecting(connectionClosedError(this._address))) {
-                this._handleClose(connectionClosedError(this._address));
-            }
-            return;
-        case AgentHostClientState.Incompatible:
-            this._handleClose(connectionClosedError(this._address));
-            return;
-        case AgentHostClientState.Connected:
-            {
-                if (!this._transportFactory) {
-                    this._handleClose(connectionClosedError(this._address));
-                    return;
-                }
-                if (!this._reconnectPolicy.autoRestore) {
-                    const error = connectionClosedError(this._address);
-                    this._logService.info(
-                        `[RemoteAgentHostProtocol] Transport lost for ${this._address}; automatic reconnect is disabled.`
-                    );
-                    this._handleFatalClose(error);
-                    return;
-                }
-                this._logService.info(
-                    `[RemoteAgentHostProtocol] Transport lost for ${this._address}; scheduling reconnect.`
-                );
-                this._transitionTo({
-                    kind: AgentHostClientState.Reconnecting,
-                    reconnect: this._newReconnectState()
-                });
-                this._cancelLivenessTimers();
-                this._rejectPendingRequests(transportLostError(this._address));
-                this._scheduleReconnect();
-                return;
-            }
-        case AgentHostClientState.Reconnecting:
-            this._logService.info(
-                `[RemoteAgentHostProtocol] Transport lost for ${this._address} mid-reconnect; aborting the current attempt.`
-            );
-            this._cancelLivenessTimers();
-            this._rejectPendingRequests(transportLostError(this._address));
-            return;
-        }
-    }
-    _beginReconnectFromConnecting(error) {
-        if (this._state.kind !== AgentHostClientState.Connecting || !this._transportFactory) {
-            return false;
-        }
-        if (!this._reconnectPolicy.autoRestore) {
-            this._logService.info(
-                `[RemoteAgentHostProtocol] Transport lost while connecting to ${this._address}; automatic reconnect is disabled.`
-            );
-            this._handleFatalClose(error);
-            return true;
-        }
-        this._logService.info(
-            `[RemoteAgentHostProtocol] Transport lost while connecting to ${this._address}; scheduling a fresh initialize.`
-        );
-        const outbox = this._state.outbox;
-        this._rejectPendingRequests(error);
-        this._grantedImplicitReadUris.clear();
-        this._implicitReadGrants.clear();
-        this._transitionTo({
-            kind: AgentHostClientState.Reconnecting,
-            reconnect: {
-                ...this._newReconnectState(),
-                outbox
-            }
-        });
-        this._cancelLivenessTimers();
-        this._scheduleReconnect();
-        return true;
-    }
-    reconnectFromClosed() {
-        if (this._state.kind !== AgentHostClientState.Closed || !this._transportFactory || this._store.isDisposed) {
-            return false;
-        }
-        this._transitionTo({
-            kind: AgentHostClientState.Reconnecting,
-            reconnect: this._newReconnectState()
-        });
-        this._scheduleReconnect(true);
-        return true;
-    }
-    reconnectNow() {
-        if (this._state.kind !== AgentHostClientState.Reconnecting || this._state.reconnect.timeoutHandle === undefined) {
-            return false;
-        }
-        const reconnect = this._state.reconnect;
-        clearTimeout(reconnect.timeoutHandle);
-        reconnect.timeoutHandle = undefined;
-        reconnect.nextAttemptAt = undefined;
-        reconnect.attempt = 0;
-        this._onDidScheduleReconnect.fire();
-        void this._attemptReconnect();
-        return true;
-    }
-    _scheduleReconnect(userInitiated = false) {
-        if (this._state.kind !== AgentHostClientState.Reconnecting || !this._transportFactory) {
-            return;
-        }
-        const reconnect = this._state.reconnect;
-        if (reconnect.timeoutHandle !== undefined) {
-            return;
-        }
-        if (!userInitiated && !this._reconnectPolicy.autoRestore) {
-            const error = connectionClosedError(this._address);
-            this._logService.info(
-                `[RemoteAgentHostProtocol] Automatic reconnect to ${this._address} is disabled.`
-            );
-            this._handleFatalClose(error);
-            return;
-        }
-        if (!userInitiated && hasExhaustedReconnectAttempts(this._reconnectPolicy, reconnect.attempt)) {
-            const error = ( new ProtocolError(
-                AHP_CLIENT_CONNECTION_CLOSED,
-                `Automatic reconnect gave up after ${reconnect.attempt} attempts.`
-            ));
-            this._logService.warn(
-                `[RemoteAgentHostProtocol] Automatic reconnect to ${this._address} gave up after ${reconnect.attempt} attempts.`
-            );
-            this._handleFatalClose(error);
-            return;
-        }
-        const attempt = reconnect.attempt + 1;
-        const delay = computeReconnectDelay(this._reconnectPolicy, attempt);
-        this._logService.info(
-            `[RemoteAgentHostProtocol] Reconnecting to ${this._address} in ${delay}ms (attempt ${attempt}).`
-        );
-        reconnect.nextAttemptAt = Date.now() + delay;
-        reconnect.timeoutHandle = setTimeout(() => {
-            if (this._state.kind === AgentHostClientState.Reconnecting) {
-                this._state.reconnect.timeoutHandle = undefined;
-                this._state.reconnect.nextAttemptAt = undefined;
-            }
-            void this._attemptReconnect();
-        }, delay);
-        this._onDidScheduleReconnect.fire();
-    }
-    async _attemptReconnect() {
-        if (this._state.kind !== AgentHostClientState.Reconnecting || !this._transportFactory) {
-            return;
-        }
-        const reconnect = this._state.reconnect;
-        reconnect.attempt++;
-        let transport;
-        try {
-            transport = this._transportFactory();
-            this._installTransport(transport);
-            if (isClientTransport(transport)) {
-                await transport.connect();
-            }
-            if (this._state.kind !== AgentHostClientState.Reconnecting) {
-                return;
-            }
-            const subscriptions = ( this._subscriptionManager.currentSubscriptionUris().map(u => ( u.toString())));
-            if (!subscriptions.includes(ROOT_STATE_URI)) {
-                subscriptions.unshift(ROOT_STATE_URI);
-            }
-            const lastSeenServerSeq = this._serverSeq;
-            const {
-                result,
-                freshInitialize
-            } = await this._reconnectOrInitialize(lastSeenServerSeq, subscriptions);
-            if (this._state.kind !== AgentHostClientState.Reconnecting) {
-                return;
-            }
-            this._applyReconnectResult(result, freshInitialize);
-            this._updateManagedSettingsPermissions(true);
-            if ((freshInitialize && result.type === ReconnectResultType.Snapshot) || this._authenticationRestorePending) {
-                if (freshInitialize && result.type === ReconnectResultType.Snapshot) {
-                    this._markSubscriptionsAwaitingRestore(result.snapshots);
-                }
-                await this._restoreAuthenticationAfterFreshInitialize(AgentHostClientState.Reconnecting);
-                if (this._state.kind !== AgentHostClientState.Reconnecting) {
-                    return;
-                }
-            }
-            if (this._subscriptionsAwaitingRestore.size > 0) {
-                await this._restoreSubscriptionsAwaitingRestore();
-                if (this._state.kind !== AgentHostClientState.Reconnecting) {
-                    return;
-                }
-            }
-            this._forwardClientConfig(false);
-            const {
-                gate
-            } = reconnect;
-            this._drainAfterReconnect(reconnect.outbox);
-            this._lastReadTime = Date.now();
-            this._resetLivenessTimers();
-            this._transitionTo({
-                kind: AgentHostClientState.Connected
-            });
-            gate.complete();
-            this._logService.info(`[RemoteAgentHostProtocol] Reconnected to ${this._address}.`);
-        } catch (err) {
-            this._logService.warn(
-                `[RemoteAgentHostProtocol] Reconnect attempt failed for ${this._address}: ${err instanceof Error ? err.message : String(err)}`
-            );
-            transport?.dispose();
-            if (this._state.kind !== AgentHostClientState.Reconnecting) {
-                return;
-            }
-            if (err instanceof NonReconnectableTransportError) {
-                const protocolError = ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, err.message));
-                this._handleFatalClose(protocolError, err.reason);
-                return;
-            }
-            if (err instanceof InitialAuthenticationError) {
-                const protocolError = ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, err.message));
-                this._cancelLivenessTimers();
-                this._rejectPendingRequests(protocolError);
-                reconnect.gate.error(err);
-                this._transitionTo({
-                    kind: AgentHostClientState.Incompatible,
-                    error: protocolError
-                });
-                return;
-            }
-            const oldGate = this._state.reconnect.gate;
-            this._state.reconnect.gate = this._newReconnectGate();
-            oldGate.error(err);
-            this._scheduleReconnect();
-        }
-    }
-    async _reconnectOrInitialize(lastSeenServerSeq, subscriptions) {
-        try {
-            const result = await this._dispatchRequest("reconnect", {
-                clientId: this._clientId,
-                lastSeenServerSeq,
-                subscriptions,
-                _meta: this._clientMeta()
-            }, {
-                bypassReconnectGate: true
-            });
-            return {
-                result,
-                freshInitialize: false
-            };
-        } catch (error) {
-            if (!(error instanceof ProtocolError) || error.code !== AhpErrorCodes.NotFound) {
-                throw error;
-            }
-        }
-        this._logService.info(
-            `[RemoteAgentHostProtocol] Server forgot client ${this._clientId}; initializing a fresh connection.`
-        );
-        const initializeResult = await this._dispatchRequest("initialize", {
-            channel: ROOT_STATE_URI,
-            protocolVersions: [...CLIENT_SUPPORTED_PROTOCOL_VERSIONS],
-            clientId: this._clientId,
-            clientInfo: this._clientInfo,
-            _meta: this._clientMeta(),
-            initialSubscriptions: subscriptions
-        }, {
-            bypassReconnectGate: true
-        });
-        this._applyInitializeResult(initializeResult, false);
-        return {
-            result: {
-                type: ReconnectResultType.Snapshot,
-                snapshots: initializeResult.snapshots ?? []
-            },
-            freshInitialize: true
-        };
-    }
-    _markSubscriptionsAwaitingRestore(initialSnapshots) {
-        const restored = ( new Set(( initialSnapshots.map(snapshot => snapshot.resource))));
-        this._subscriptionsAwaitingRestore.clear();
-        for (const subscription of this._subscriptionManager.getActiveSubscriptions()) {
-            const resource = ( subscription.resource.toString());
-            if (!( restored.has(resource))) {
-                this._subscriptionsAwaitingRestore.add(resource);
-            }
-        }
-    }
-    async _restoreSubscriptionsAwaitingRestore() {
-        if (this._subscriptionsAwaitingRestore.size === 0) {
-            return;
-        }
-        const pending = this._subscriptionManager.getActiveSubscriptions().filter(subscription => ( this._subscriptionsAwaitingRestore.has(( subscription.resource.toString()))));
-        this._subscriptionsAwaitingRestore.clear();
-        for (const subscription of pending) {
-            this._subscriptionsAwaitingRestore.add(( subscription.resource.toString()));
-            this._subscriptionManager.beginSnapshotRefresh(subscription.resource);
-        }
-        const restoreGroup = async subscriptions => {
-            await Promise.all(( subscriptions.map(async subscription => {
-                const resource = ( subscription.resource.toString());
-                try {
-                    const result = await this._dispatchRequest("subscribe", {
-                        channel: resource
-                    }, {
-                        bypassReconnectGate: true
-                    });
-                    if (!result.snapshot) {
-                        throw ( new Error(`subscribe returned no snapshot for ${resource}`));
-                    }
-                    this._subscriptionManager.applyReconnectSnapshot(
-                        result.snapshot.resource,
-                        result.snapshot.state,
-                        result.snapshot.fromSeq,
-                        true
-                    );
-                    this._serverSeq = Math.max(this._serverSeq, result.snapshot.fromSeq);
-                    this._subscriptionsAwaitingRestore.delete(resource);
-                } catch (error) {
-                    if (error instanceof ProtocolError && error.code === AHP_CLIENT_CONNECTION_CLOSED) {
-                        this._subscriptionManager.cancelSnapshotRefresh(subscription.resource);
-                        throw error;
-                    }
-                    this._logService.warn(
-                        `[AgentHostProtocolClient] Failed to restore subscription ${resource} after host restart: ${error instanceof Error ? error.message : String(error)}`
-                    );
-                    this._subscriptionManager.cancelSnapshotRefresh(subscription.resource);
-                    this._subscriptionManager.markSubscriptionsMissing([subscription.resource]);
-                    this._subscriptionsAwaitingRestore.delete(resource);
-                }
-            })));
-        };
-        await restoreGroup(
-            pending.filter(subscription => subscription.kind === StateComponents.Session)
-        );
-        await Promise.all([
-            restoreGroup(pending.filter(subscription => subscription.kind === StateComponents.Chat)),
-            restoreGroup(pending.filter(
-                subscription => subscription.kind !== StateComponents.Session && subscription.kind !== StateComponents.Chat
-            ))
-        ]);
-    }
-    async _restoreAuthenticationAfterFreshInitialize(expectedState) {
-        this._authenticationRestorePending = true;
-        let initialAuthenticationKey;
-        if (this._resolveInitialAuthentication) {
-            try {
-                const initialAuthentication = await this._resolveInitialAuthentication();
-                if (initialAuthentication) {
-                    const normalizedParams = this._normalizeAuthenticationParams(initialAuthentication);
-                    initialAuthenticationKey = this._authenticationKey(normalizedParams);
-                    const expiresAt = getExpirationTime(normalizedParams.expiresIn);
-                    this._authentication.set(initialAuthenticationKey, {
-                        params: normalizedParams,
-                        expiresAt
-                    });
-                }
-            } catch (error) {
-                throw ( new InitialAuthenticationError(error));
-            }
-            if (this._state.kind !== expectedState) {
-                return;
-            }
-        }
-        await Promise.all(( [...this._authentication.entries()].map(async ([key, authentication]) => {
-            const now = Date.now();
-            if (isExpired(authentication.expiresAt, now)) {
-                this._authentication.delete(key);
-                return;
-            }
-            const expiresIn = getRemainingTimeInSeconds(authentication.expiresAt, now);
-            const params = authentication.params;
-            try {
-                await this._dispatchRequest("authenticate", {
-                    channel: ROOT_STATE_URI,
-                    ...params,
-                    scopes: params.scopes ? [...params.scopes] : undefined,
-                    ...(expiresIn === undefined ? {} : {
-                        expiresIn
-                    })
-                }, this._state.kind === AgentHostClientState.Connecting ? {
-                    bypassInitializeQueue: true,
-                    bypassReconnectGate: true
-                } : {
-                    bypassReconnectGate: true
-                });
-            } catch (error) {
-                if (isConnectionClosedError(error)) {
-                    throw error;
-                }
-                if (key === initialAuthenticationKey) {
-                    throw ( new InitialAuthenticationError(error));
-                }
-                this._logService.warn(
-                    `[AgentHostProtocolClient] Failed to restore authentication for ${params.resource} after host restart: ${error instanceof Error ? error.message : String(error)}`
-                );
-            }
-        })));
-        this._authenticationRestorePending = false;
-    }
-    _clientMeta() {
-        const telemetryLevel = this._effectiveTelemetryLevel();
-        const sendIdentity = telemetryLevel >= TelemetryLevel.USAGE;
-        return toAgentHostClientMeta(
-            this._transport.clientConnectionKind,
-            telemetryLevel,
-            sendIdentity ? this._telemetryService.machineId : undefined,
-            sendIdentity ? this._telemetryService.devDeviceId : undefined
-        );
-    }
-    _applyInitializeResult(result, forwardClientConfig = true) {
-        this._initializeResult.set(result, undefined);
-        this._serverSeq = result.serverSeq;
-        if (result.defaultDirectory) {
-            const directory = result.defaultDirectory;
-            this._defaultDirectory = typeof directory === "string" ? ( URI.parse(directory)).path : URI.revive(directory).path;
-        }
-        if (forwardClientConfig) {
-            this._forwardClientConfig();
-        }
-    }
-    _forwardClientConfig(includeManagedSettings = true) {
-        this._dispatchRootConfig(resolveAgentHostConfigurationSyncPatch(
-            this._configurationService,
-            getAgentHostConfigurationSyncTarget(this._resourceIdentity)
-        ));
-        this._updateTelemetryLevel();
-        this._updateTerminalAutoApproveEnabled();
-        this._updateTerminalAutoApproveRules();
-        this._updateAutoApprovePolicyRestriction();
-        this._updateWorkspaceTrust();
-        this._updateDisableRepoInfoTelemetry();
-        if (includeManagedSettings) {
-            void this._updateManagedSettingsPermissions();
-        }
-    }
-    _updateAutoApprovePolicyRestriction() {
-        const policyRestricted = this._configurationService.inspect(GLOBAL_AUTO_APPROVE_SETTING_ID)?.policyValue === false;
-        this._dispatchRootConfig({
-            [AgentHostAutoApprovePolicyRestrictedConfigKey]: policyRestricted
-        });
-    }
-    _updateWorkspaceTrust() {
-        const remoteAuthority = typeof this._resourceIdentity === "string" && this._resourceIdentity.startsWith(`${Schemas.vscodeRemote}://`) ? ( URI.parse(this._resourceIdentity)).authority : undefined;
-        const trustedUris = ( ( this._workspaceTrustManagementService.getTrustedUris().filter(
-            uri => this._resourceIdentity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY ? uri.scheme === Schemas.file : (uri.scheme === AGENT_HOST_SCHEME && uri.authority === this._connectionAuthority) || (remoteAuthority !== undefined && uri.scheme === Schemas.vscodeRemote && uri.authority === remoteAuthority)
-        ).map(uri => uri.scheme === Schemas.vscodeRemote ? uri.with({
-            scheme: Schemas.file,
-            authority: ""
-        }) : this.resourceUris.toAgentHost(uri))).filter(uri => uri.scheme === Schemas.file).map(uri => ( uri.toString())));
-        this._dispatchRootConfig({
-            [AgentHostWorkspaceTrustConfigKey]: {
-                enabled: this._workspaceTrustEnablementService.isWorkspaceTrustEnabled(),
-                trustedUris
-            }
-        });
-    }
-    _applyReconnectResult(result, preservePending = false) {
-        if (result.type === ReconnectResultType.Replay) {
-            let maxSeq = this._serverSeq;
-            for (const envelope of result.actions) {
-                if (envelope.origin?.clientId === this._clientId && envelope.origin.clientSeq !== undefined && !envelope.rejectionReason) {
-                    this._subscriptionManager.dropPendingAction(envelope.channel, envelope.origin.clientSeq);
-                }
-                if (envelope.serverSeq > maxSeq) {
-                    maxSeq = envelope.serverSeq;
-                }
-                this._onDidAction.fire(normalizeLegacyActionEnvelope(envelope));
-            }
-            this._serverSeq = maxSeq;
-            if (result.missing.length > 0) {
-                this._logService.info(
-                    `[RemoteAgentHostProtocol] Server cannot resume ${result.missing.length} subscription(s) after reconnect.`
-                );
-                this._subscriptionManager.markSubscriptionsMissing(( result.missing.map(u => ( URI.parse(u)))));
-                for (const resource of result.missing) {
-                    this._subscriptionsAwaitingRestore.delete(resource);
-                }
-            }
-        } else {
-            let maxSeq = this._serverSeq;
-            for (const snapshot of result.snapshots) {
-                this._subscriptionManager.applyReconnectSnapshot(snapshot.resource, snapshot.state, snapshot.fromSeq, preservePending);
-                this._subscriptionsAwaitingRestore.delete(snapshot.resource);
-                if (snapshot.fromSeq > maxSeq) {
-                    maxSeq = snapshot.fromSeq;
-                }
-            }
-            this._serverSeq = maxSeq;
-        }
-    }
-    _drainAfterReconnect(outbox) {
-        const queuedSeqs = ( new Set());
-        for (const msg of outbox) {
-            if (hasKey(msg, {
-                method: true
-            }) && msg.method === "dispatchAction") {
-                queuedSeqs.add(msg.params.clientSeq);
-            }
-        }
-        const replays = [];
-        for (const entry of this._subscriptionManager.getPendingActions()) {
-            if (( queuedSeqs.has(entry.clientSeq))) {
-                continue;
-            }
-            this._grantImplicitReadsForOutgoingAction(entry.action);
-            replays.push({
-                jsonrpc: "2.0",
-                method: "dispatchAction",
-                params: {
-                    channel: entry.channel,
-                    clientSeq: entry.clientSeq,
-                    action: entry.action
-                }
-            });
-        }
-        if (replays.length > 0) {
-            this._logService.info(
-                `[RemoteAgentHostProtocol] Replaying ${replays.length} pending action(s) after reconnect to ${this._address}.`
-            );
-        }
-        for (const msg of replays) {
-            this._transport.send(msg);
-        }
-        for (const msg of outbox) {
-            this._transport.send(msg);
-        }
-    }
-    get rootState() {
-        return this._subscriptionManager.rootState;
-    }
-    getSubscription(kind, resource, owner) {
-        return this._subscriptionManager.getSubscription(kind, resource, owner);
-    }
-    getSubscriptionUnmanaged(_kind, resource) {
-        return this._subscriptionManager.getSubscriptionUnmanaged(resource);
-    }
-    getInflightSessionCreate(resource) {
-        return this._subscriptionManager.getInflightSessionCreate(resource);
-    }
-    trackSessionCreate(resource, promise) {
-        this._subscriptionManager.trackSessionCreate(resource, promise);
-    }
-    getActiveSubscriptions() {
-        return this._subscriptionManager.getActiveSubscriptions();
-    }
-    dispatch(channel, action) {
-        const seq = this._subscriptionManager.dispatchOptimistic(channel, action);
-        this.dispatchAction(channel, action, this._clientId, seq);
-    }
-    async subscribe(resource) {
-        this._logService.trace(`[RemoteAgentHostProtocol] subscribe start: ${( resource.toString())}`);
-        const result = await this._sendRequest("subscribe", {
-            channel: ( resource.toString())
-        });
-        if (!result.snapshot) {
-            throw ( new Error(`subscribe to ${( resource.toString())} returned no snapshot`));
-        }
-        this._logService.trace(`[RemoteAgentHostProtocol] subscribe done: ${( resource.toString())}`);
-        return result.snapshot;
-    }
-    async subscribeStateless(resource) {
-        await this._sendRequest("subscribe", {
-            channel: ( resource.toString())
-        });
-    }
-    unsubscribe(resource) {
-        this._sendNotification("unsubscribe", {
-            channel: ( resource.toString())
-        });
-    }
-    dispatchAction(channel, action, _clientId, clientSeq) {
-        this._grantImplicitReadsForOutgoingAction(action);
-        this._sendNotification("dispatchAction", {
-            channel,
-            clientSeq,
-            action
-        });
-    }
-    createSession(config) {
-        const provider = config?.provider;
-        if (!provider) {
-            throw ( new Error("Cannot create remote agent host session without a provider."));
-        }
-        const session = config?.session ?? AgentSession.uri(provider, generateUuid());
-        if (config?.activeClient?.customizations) {
-            this._grantImplicitReadsForCustomizations(config.activeClient.customizations);
-        }
-        const promise = this._sendRequest("createSession", {
-            channel: ( session.toString()),
-            _meta: config?._meta,
-            provider,
-            workingDirectories: config?.workingDirectories?.map(d => ( fromAgentHostUri(d).toString())),
-            config: config?.config,
-            activeClient: config?.activeClient,
-            progressToken: config?.progressToken
-        }).then(() => session);
-        this._subscriptionManager.trackSessionCreate(session, promise);
-        return promise;
-    }
-    async removeSessionArtifact(session, artifactId) {
-        await this._sendExtensionRequest(RemoveSessionArtifactExtensionMethod, {
-            session: ( session.toString()),
-            artifactId
-        });
-    }
-    async createDetachedWorktree(session, prompt) {
-        const result = await this._sendExtensionRequest(CreateAgentHostDetachedWorktreeExtensionMethod, {
-            session: ( session.toString()),
-            prompt
-        });
-        if (!result) {
-            throw ( new Error("Agent Host does not support detached worktrees."));
-        }
-        return {
-            handle: result.handle,
-            worktree: ( URI.parse(result.resource))
-        };
-    }
-    async setDetachedWorktreeArchived(handle, archived) {
-        await this._sendExtensionRequest(SetAgentHostDetachedWorktreeArchivedExtensionMethod, {
-            handle,
-            archived
-        });
-    }
-    async claimDetachedWorktree(handle) {
-        await this._sendExtensionRequest(ClaimAgentHostDetachedWorktreeExtensionMethod, {
-            handle
-        });
-    }
-    async deleteDetachedWorktree(handle) {
-        await this._sendExtensionRequest(DeleteAgentHostDetachedWorktreeExtensionMethod, {
-            handle
-        });
-    }
-    async reconcileDetachedWorktrees(scope, activeHandles) {
-        await this._sendExtensionRequest(ReconcileAgentHostDetachedWorktreesExtensionMethod, {
-            scope,
-            activeHandles: [...activeHandles]
-        });
-    }
-    async resolveSessionConfig(params) {
-        return this._sendRequest("resolveSessionConfig", {
-            channel: ROOT_STATE_URI,
-            provider: params.provider,
-            workingDirectory: params.workingDirectory ? ( fromAgentHostUri(params.workingDirectory).toString()) : undefined,
-            config: params.config
-        });
-    }
-    async sessionConfigCompletions(params) {
-        return this._sendRequest("sessionConfigCompletions", {
-            channel: ROOT_STATE_URI,
-            provider: params.provider,
-            workingDirectory: params.workingDirectory ? ( fromAgentHostUri(params.workingDirectory).toString()) : undefined,
-            config: params.config,
-            property: params.property,
-            query: params.query
-        });
-    }
-    async completions(params) {
-        return this._sendRequest("completions", params);
-    }
-    async listAutomationTriggerDefinitions(params) {
-        return this._sendRequest("listAutomationTriggerDefinitions", params);
-    }
-    async runAutomation(params) {
-        return this._sendRequest("runAutomation", params);
-    }
-    async fetchAutomationRuns(params) {
-        return this._sendRequest("fetchAutomationRuns", params);
-    }
-    async ping() {
-        await this._sendRequest("ping", {
-            channel: ROOT_STATE_URI
-        });
-    }
-    async getCompletionTriggerCharacters() {
-        while (this._state.kind === AgentHostClientState.Connecting) {
-            await Event.toPromise(this.onDidChangeConnectionState);
-        }
-        switch (this._state.kind) {
-        case AgentHostClientState.Incompatible:
-        case AgentHostClientState.Closed:
-            throw this._state.error;
-        case AgentHostClientState.Connected:
-        case AgentHostClientState.Reconnecting:
-            return this._initializeResult.get()?.completionTriggerCharacters ?? [];
-        }
-    }
-    async authenticate(params) {
-        const normalizedParams = this._normalizeAuthenticationParams(params);
-        const expiresAt = getExpirationTime(params.expiresIn);
-        await this._sendRequest("authenticate", {
-            channel: ROOT_STATE_URI,
-            ...normalizedParams,
-            scopes: normalizedParams.scopes ? [...normalizedParams.scopes] : undefined
-        });
-        const key = this._authenticationKey(normalizedParams);
-        if (params.token) {
-            this._authentication.set(key, {
-                params: normalizedParams,
-                expiresAt
-            });
-        } else {
-            this._authentication.delete(key);
-        }
-        return {
-            authenticated: true
-        };
-    }
-    _normalizeAuthenticationParams(params) {
-        return {
-            ...params,
-            scopes: params.scopes ? [...( new Set(params.scopes))].sort() : undefined
-        };
-    }
-    _authenticationKey(params) {
-        return `${params.resource}\0${JSON.stringify(params.scopes ?? [])}`;
-    }
-    async shutdown() {
-        await this._sendExtensionRequest("shutdown");
-    }
-    async getNetworkDiagnosticsInfo() {
-        return this._sendExtensionRequest("getNetworkDiagnosticsInfo");
-    }
-    async getManagedSettingsDiagnostics() {
-        return this._sendExtensionRequest("getManagedSettingsDiagnostics");
-    }
-    async getSessionStateFile(session, chat) {
-        const targetChat = chat && !isDefaultChatUri(chat) ? chat : undefined;
-        if (targetChat && !supportsAgentHostChatStateFile(this._initializeResult.get())) {
-            return undefined;
-        }
-        const result = await this._sendExtensionRequest(GetAgentHostSessionStateFileExtensionMethod, {
-            session: ( session.toString()),
-            chat: targetChat?.toString()
-        });
-        if (!result.resource) {
-            return undefined;
-        }
-        const resource = ( URI.parse(result.resource, true));
-        if (resource.scheme !== Schemas.file) {
-            throw ( new ProtocolError(
-                JsonRpcErrorCodes.InvalidParams,
-                `Agent Host returned a non-file session state resource: ${( resource.toString())}`
-            ));
-        }
-        return toAgentHostUri(resource, this._connectionAuthority);
-    }
-    async collectDebugLogs(session, kind, chat) {
-        const result = await this._sendExtensionRequest(CollectAgentHostDebugLogsExtensionMethod, {
-            session: session?.toString(),
-            chat: chat?.toString(),
-            kind
-        });
-        if (result.kind !== kind) {
-            throw ( new ProtocolError(
-                JsonRpcErrorCodes.InvalidParams,
-                `Agent Host returned ${result.kind} debug logs for a ${kind} request`
-            ));
-        }
-        const resource = ( URI.parse(result.resource, true));
-        if (resource.scheme !== Schemas.file) {
-            throw ( new ProtocolError(
-                JsonRpcErrorCodes.InvalidParams,
-                `Agent Host returned a non-file debug log resource: ${( resource.toString())}`
-            ));
-        }
-        if (!Number.isSafeInteger(result.size) || result.size < 0 || !Number.isSafeInteger(result.uncompressedSize) || result.uncompressedSize < 0) {
-            throw ( new ProtocolError(
-                JsonRpcErrorCodes.InvalidParams,
-                "Agent Host returned invalid debug log artifact sizes"
-            ));
-        }
-        if (!Array.isArray(result.entries) || result.entries.length > AGENT_HOST_DEBUG_LOGS_MAX_ENTRIES) {
-            throw ( new ProtocolError(
-                JsonRpcErrorCodes.InvalidParams,
-                "Agent Host returned an invalid debug log artifact manifest"
-            ));
-        }
-        const entryPaths = ( new Set());
-        let manifestSize = 0;
-        for (const entry of result.entries) {
-            const segments = entry.path.split("/");
-            if (!entry.path || entry.path.includes("\\") || ( segments.some(segment => !segment || segment === "." || segment === "..")) || !Number.isSafeInteger(entry.size) || entry.size < 0 || ( entryPaths.has(entry.path))) {
-                throw ( new ProtocolError(
-                    JsonRpcErrorCodes.InvalidParams,
-                    "Agent Host returned an invalid debug log artifact manifest entry"
-                ));
-            }
-            entryPaths.add(entry.path);
-            manifestSize += entry.size;
-        }
-        if (!Number.isSafeInteger(manifestSize) || manifestSize !== result.uncompressedSize) {
-            throw ( new ProtocolError(
-                JsonRpcErrorCodes.InvalidParams,
-                "Agent Host debug log artifact manifest size does not match its declared size"
-            ));
-        }
-        return {
-            kind: result.kind,
-            resource: toAgentHostUri(resource, this._connectionAuthority),
-            providerLogsIncluded: result.providerLogsIncluded,
-            size: result.size,
-            uncompressedSize: result.uncompressedSize,
-            entries: result.entries
-        };
-    }
-    async readDebugLogsChunk(resource, position) {
-        const result = await this._sendExtensionRequest(ReadAgentHostDebugLogsChunkExtensionMethod, {
-            resource: ( fromAgentHostUri(resource).toString()),
-            position
-        });
-        const data = decodeBase64(result.data);
-        if (data.byteLength > AGENT_HOST_DEBUG_LOGS_CHUNK_BYTES) {
-            throw ( new ProtocolError(
-                JsonRpcErrorCodes.InvalidParams,
-                "Agent Host returned an oversized debug log chunk"
-            ));
-        }
-        return {
-            data,
-            eof: result.eof === true
-        };
-    }
-    async diagnosticsFetch(url) {
-        return this._sendExtensionRequest("diagnosticsFetch", {
-            url
-        });
-    }
-    async disposeSession(session) {
-        await this._sendRequest("disposeSession", {
-            channel: ( session.toString())
-        });
-    }
-    async createChat(session, chat, options) {
-        await this._sendRequest("createChat", {
-            channel: ( session.toString()),
-            chat: ( chat.toString()),
-            ...(options?.fork ? {
-                source: {
-                    kind: ChatSourceKind.Fork,
-                    chat: ( options.fork.source.toString()),
-                    turnId: options.fork.turnId
-                }
-            } : {}),
-            ...(options?.sideChat ? {
-                source: {
-                    kind: ChatSourceKind.SideChat,
-                    chat: ( options.sideChat.source.toString()),
-                    turnId: options.sideChat.turnId,
-                    ...(options.sideChat.selection ? {
-                        selection: options.sideChat.selection
-                    } : {})
-                }
-            } : {})
-        });
-    }
-    async disposeChat(chat) {
-        await this._sendRequest("disposeChat", {
-            channel: ( chat.toString())
-        });
-    }
-    async createTerminal(params) {
-        await this._sendRequest("createTerminal", params);
-    }
-    async disposeTerminal(terminal) {
-        await this._sendRequest("disposeTerminal", {
-            channel: ( terminal.toString())
-        });
-    }
-    async invokeChangesetOperation(params) {
-        return await this._sendRequest("invokeChangesetOperation", params);
-    }
-    async handleMcpRequest(channel, method, params) {
-        return await this._dispatchRequest(method, {
-            ...(params ?? {}),
-            channel
-        });
-    }
-    async listSessions() {
-        const result = await this._sendRequest("listSessions", {
-            channel: ROOT_STATE_URI
-        });
-        return ( result.items.map(s => ({
-            session: ( URI.parse(s.resource)),
-            startTime: Date.parse(s.createdAt),
-            modifiedTime: Date.parse(s.modifiedAt),
-            ...(s.project ? {
-                project: {
-                    uri: this._toClientUri(( URI.parse(s.project.uri))),
-                    displayName: s.project.displayName
-                }
-            } : {}),
-            summary: s.title,
-            status: s.status,
-            activity: s.activity,
-            workingDirectory: typeof s.workingDirectories?.[0] === "string" ? this._toClientUri(( URI.parse(s.workingDirectories[0]))) : undefined,
-            workingDirectories: s.workingDirectories?.map(d => this._toClientUri(( URI.parse(d)))),
-            changes: s.changes,
-            ...(s._meta !== undefined ? {
-                _meta: s._meta
-            } : {})
-        })));
-    }
-    _toClientUri(uri) {
-        return uri.scheme === Schemas.file ? toAgentHostUri(uri, this._connectionAuthority) : uri;
-    }
-    _grantImplicitReadsForOutgoingAction(action) {
-        switch (action.type) {
-        case ActionType.SessionActiveClientSet:
-            if (action.activeClient.customizations) {
-                this._grantImplicitReadsForCustomizations(action.activeClient.customizations);
-            }
-            break;
-        case ActionType.ChatTurnStarted:
-        case ActionType.ChatPendingMessageSet:
-            this._grantImplicitReadsForMessage(action.message);
-            break;
-        }
-    }
-    _grantImplicitReadsForMessage(message) {
-        for (const attachment of message.attachments ?? []) {
-            if (attachment.type !== MessageAttachmentKind.Resource) {
-                continue;
-            }
-            try {
-                this._grantImplicitRead(( URI.parse(attachment.uri)));
-            } catch {
-                continue;
-            }
-        }
-    }
-    _grantImplicitReadsForCustomizations(refs) {
-        for (const ref of refs) {
-            let uri;
-            try {
-                uri = ( URI.parse(ref.uri));
-            } catch {
-                continue;
-            }
-            this._grantImplicitRead(uri);
-        }
-    }
-    _grantImplicitRead(uri) {
-        if (( this._grantedImplicitReadUris.has(uri))) {
-            return;
-        }
-        this._grantedImplicitReadUris.add(uri);
-        this._implicitReadGrants.add(this._resourceService.grantImplicitRead(this._resourceIdentity, uri));
-    }
-    async resourceList(uri) {
-        return await this._sendRequest("resourceList", {
-            channel: ROOT_STATE_URI,
-            uri: ( uri.toString())
-        });
-    }
-    async resourceRead(uri, encoding) {
-        return this._sendRequest("resourceRead", {
-            channel: ROOT_STATE_URI,
-            uri: ( uri.toString()),
-            encoding
-        });
-    }
-    async resourceWrite(params) {
-        return this._sendRequest("resourceWrite", params);
-    }
-    async resourceCopy(params) {
-        return this._sendRequest("resourceCopy", params);
-    }
-    async resourceDelete(params) {
-        return this._sendRequest("resourceDelete", params);
-    }
-    async resourceMove(params) {
-        return this._sendRequest("resourceMove", params);
-    }
-    async resourceResolve(params) {
-        return this._sendRequest("resourceResolve", params);
-    }
-    async resourceMkdir(params) {
-        return this._sendRequest("resourceMkdir", params);
-    }
-    async createResourceWatch(params) {
-        return this._sendRequest("createResourceWatch", params);
-    }
-    watchResource(params) {
-        return createRemoteWatchHandle({
-            createResourceWatch: p => this.createResourceWatch(p),
-            subscribe: uri => this.subscribe(uri),
-            unsubscribe: uri => this.unsubscribe(uri),
-            onDidAction: this.onDidAction
-        }, params);
-    }
-    triggerVscodeUpgrade(method) {
-        return this._dispatchRequest(method, {}, {
-            allowIncompatibleUpgrade: true
-        });
-    }
-    _handleMessage(msg) {
-        if (this._state.kind === AgentHostClientState.Closed) {
-            return;
-        }
-        this._lastReadTime = Date.now();
-        this._resetLivenessTimers();
-        if (isJsonRpcRequest(msg)) {
-            this._handleReverseRequest(msg.id, msg.method, msg.params);
-        } else if (isJsonRpcResponse(msg)) {
-            const pending = this._pendingRequests.get(msg.id);
-            if (pending) {
-                this._pendingRequests.delete(msg.id);
-                if (hasKey(msg, {
-                    error: true
-                })) {
-                    if (this._shouldLogFailedRequest(pending, msg.error)) {
-                        this._logService.warn(`[RemoteAgentHostProtocol] Request ${msg.id} failed:`, msg.error);
-                    }
-                    pending.deferred.error(this._toProtocolError(msg.error));
-                } else {
-                    pending.deferred.complete(msg.result);
-                }
-            } else {
-                this._logService.warn(
-                    `[RemoteAgentHostProtocol] Received response for unknown request id ${msg.id}`
-                );
-            }
-        } else if (isJsonRpcNotification(msg)) {
-            switch (msg.method) {
-            case "action":
-                {
-                    const envelope = msg.params;
-                    this._serverSeq = Math.max(this._serverSeq, envelope.serverSeq);
-                    this._onDidAction.fire(normalizeLegacyActionEnvelope(envelope));
-                    break;
-                }
-            case "root/sessionAdded":
-            case "root/sessionRemoved":
-            case "root/sessionSummaryChanged":
-            case "root/progress":
-            case "auth/required":
-                {
-                    this._logService.trace(`[RemoteAgentHostProtocol] Notification: ${msg.method}`);
-                    this._onDidNotification.fire({
-                        type: msg.method,
-                        ...msg.params
-                    });
-                    break;
-                }
-            case "otlp/exportLogs":
-                this._onDidReceiveOtlpLogs.fire(msg.params);
-                break;
-            case "otlp/exportTraces":
-            case "otlp/exportMetrics":
-                break;
-            default:
-                {
-                    const rawChannel = msg.params && typeof msg.params === "object" ? msg.params.channel : undefined;
-                    if (typeof rawChannel === "string" && rawChannel.toLowerCase().startsWith("mcp:/")) {
-                        const {
-                            channel: _channel,
-                            ...rest
-                        } = msg.params;
-                        this._onMcpNotification.fire({
-                            channel: rawChannel,
-                            method: msg.method,
-                            params: rest
-                        });
-                        break;
-                    }
-                    this._logService.trace(`[RemoteAgentHostProtocol] Unhandled method: ${msg.method}`);
-                    break;
-                }
-            }
-        } else {
-            this._logService.warn(`[RemoteAgentHostProtocol] Unrecognized message:`, JSON.stringify(msg));
-        }
-    }
-    _handleFatalClose(error, reason) {
-        this._onDidFatalClose.fire(error);
-        this._handleClose(error, reason);
-    }
-    _handleClose(error, reason) {
-        if (this._state.kind === AgentHostClientState.Closed) {
-            return;
-        }
-        this._cancelLivenessTimers();
-        if (this._state.kind === AgentHostClientState.Reconnecting) {
-            const reconnect = this._state.reconnect;
-            if (reconnect.timeoutHandle !== undefined) {
-                clearTimeout(reconnect.timeoutHandle);
-            }
-            if (!reconnect.gate.isSettled) {
-                reconnect.gate.error(error);
-            }
-        }
-        if (this._state.kind === AgentHostClientState.Connecting) {
-            this._state.outbox.length = 0;
-        }
-        this._rejectPendingRequests(error);
-        this._grantedImplicitReadUris.clear();
-        this._implicitReadGrants.clear();
-        this._resourceService.connectionClosed(this._resourceIdentity);
-        this._transitionTo({
-            kind: AgentHostClientState.Closed,
-            error
-        });
-        this._onDidClose.fire(reason);
-    }
-    async _raceClose(promise) {
-        if (this._state.kind === AgentHostClientState.Closed) {
-            return Promise.reject(this._state.error);
-        }
-        let closeListener = Disposable.None;
-        const closePromise = ( new Promise((_resolve, reject) => {
-            closeListener = this.onDidClose(() => reject(
-                this._state.kind === AgentHostClientState.Closed ? this._state.error : connectionClosedError(this._address)
-            ));
-        }));
-        try {
-            return await Promise.race([promise, closePromise]);
-        } finally {
-            closeListener.dispose();
-        }
-    }
-    _handleReverseRequest(id, method, params) {
-        const transport = this._transport;
-        this._pendingReverseRequests.set(transport, (this._pendingReverseRequests.get(transport) ?? 0) + 1);
-        const sendResponse = response => {
-            try {
-                transport.send(response);
-            } finally {
-                const pending = this._pendingReverseRequests.get(transport);
-                if (pending === 1) {
-                    this._pendingReverseRequests.delete(transport);
-                    if (transport === this._transport) {
-                        this._resetLivenessTimers();
-                    }
-                } else if (pending !== undefined) {
-                    this._pendingReverseRequests.set(transport, pending - 1);
-                }
-            }
-        };
-        const sendResult = result => {
-            sendResponse({
-                jsonrpc: "2.0",
-                id,
-                result
-            });
-        };
-        const sendError = err => {
-            if (err instanceof AgentHostResourcePermissionError) {
-                sendResponse({
-                    jsonrpc: "2.0",
-                    id,
-                    error: {
-                        code: AhpErrorCodes.PermissionDenied,
-                        message: err.message,
-                        data: err.request ? {
-                            request: err.request
-                        } : undefined
-                    }
-                });
-                return;
-            }
-            const fsCode = toFileSystemProviderErrorCode(err instanceof Error ? err : undefined);
-            let code = -32e3;
-            switch (fsCode) {
-            case FileSystemProviderErrorCode.FileNotFound:
-                code = AhpErrorCodes.NotFound;
-                break;
-            case FileSystemProviderErrorCode.NoPermissions:
-                code = AhpErrorCodes.PermissionDenied;
-                break;
-            case FileSystemProviderErrorCode.FileExists:
-                code = AhpErrorCodes.AlreadyExists;
-                break;
-            }
-            sendResponse({
-                jsonrpc: "2.0",
-                id,
-                error: {
-                    code,
-                    message: err instanceof Error ? err.message : String(err)
-                }
-            });
-        };
-        const p = (params ?? {});
-        const identity = this._resourceIdentity;
-        void (async () => {
-            try {
-                switch (method) {
-                case RequestAgentHostWorkspaceTrustExtensionMethod:
-                    {
-                        if (typeof p.workspace !== "string") {
-                            throw ( new Error("Missing workspace"));
-                        }
-                        const hostWorkspace = ( URI.parse(p.workspace, true));
-                        if (hostWorkspace.scheme !== Schemas.file || !hostWorkspace.path.startsWith("/")) {
-                            throw ( new Error("Workspace must be an absolute file URI"));
-                        }
-                        const workspace = this.resourceUris.fromAgentHost(hostWorkspace);
-                        if (p.trustedParent !== undefined) {
-                            if (typeof p.trustedParent !== "string") {
-                                throw ( new Error("Invalid trustedParent"));
-                            }
-                            const hostParent = ( URI.parse(p.trustedParent, true));
-                            if (hostParent.scheme !== Schemas.file || !hostParent.path.startsWith("/")) {
-                                throw ( new Error("Trusted parent must be an absolute file URI"));
-                            }
-                            if (!isWorktreeUnderRepository(hostWorkspace, hostParent)) {
-                                throw ( new Error("Workspace is not a managed worktree under the trusted parent"));
-                            }
-                            const parent = this.resourceUris.fromAgentHost(hostParent);
-                            const parentTrust = await this._workspaceTrustManagementService.getUriTrustInfo(parent);
-                            if (parentTrust.trusted) {
-                                const workspaceTrust = await this._workspaceTrustManagementService.getUriTrustInfo(workspace);
-                                if (!workspaceTrust.trusted) {
-                                    await this._workspaceTrustManagementService.setUrisTrust([workspace], true);
-                                }
-                                sendResult({
-                                    trusted: true
-                                });
-                                return;
-                            }
-                        }
-                        const trusted = await this._workspaceTrustRequestService.requestResourcesTrust({
-                            uri: workspace,
-                            message: ( localize(
-                                1847,
-                                "An agent session will be able to read files, run commands, and make changes in this folder."
-                            ))
-                        });
-                        sendResult({
-                            trusted: trusted === true
-                        });
-                        return;
-                    }
-                case "resourceList":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        const result = await this._resourceService.list(identity, ( URI.parse(p.uri)));
-                        sendResult({
-                            entries: result.entries
-                        });
-                        return;
-                    }
-                case "resourceRead":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        const result = await this._resourceService.read(identity, ( URI.parse(p.uri)));
-                        sendResult({
-                            data: encodeBase64(result.bytes),
-                            encoding: ContentEncoding.Base64
-                        });
-                        return;
-                    }
-                case "resourceWrite":
-                    {
-                        if (!p.uri || p.data === undefined) {
-                            throw ( new Error("Missing uri or data"));
-                        }
-                        await this._resourceService.write(identity, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceDelete":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        await this._resourceService.del(identity, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceMove":
-                    {
-                        if (!p.source || !p.destination) {
-                            throw ( new Error("Missing source or destination"));
-                        }
-                        await this._resourceService.move(identity, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceCopy":
-                    {
-                        if (!p.source || !p.destination) {
-                            throw ( new Error("Missing source or destination"));
-                        }
-                        await this._resourceService.copy(identity, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceResolve":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        const result = await this._resourceService.resolve(identity, p);
-                        sendResult(result);
-                        return;
-                    }
-                case "resourceMkdir":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        await this._resourceService.mkdir(identity, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceRequest":
-                    {
-                        try {
-                            await this._resourceService.request(identity, p);
-                            sendResult({});
-                        } catch (err) {
-                            if (err instanceof CancellationError) {
-                                throw ( new AgentHostResourcePermissionError(undefined));
-                            }
-                            throw err;
-                        }
-                        return;
-                    }
-                default:
-                    this._logService.warn(`[RemoteAgentHostProtocol] Unhandled reverse request: ${method}`);
-                    throw ( new Error(`Unknown method: ${method}`));
-                }
-            } catch (err) {
-                sendError(err);
-            }
-        })();
-    }
-    _sendNotification(method, params) {
-        this._sendNotificationMessage(method, params);
-    }
-    _sendExtensionNotification(method, params, sendDuringReconnect = false) {
-        this._sendNotificationMessage(method, params, sendDuringReconnect);
-    }
-    _sendNotificationMessage(method, params, sendDuringReconnect = false) {
-        if (this._state.kind === AgentHostClientState.Closed || this._state.kind === AgentHostClientState.Incompatible) {
-            return;
-        }
-        const message = {
-            jsonrpc: "2.0",
-            method,
-            params
-        };
-        if (isClientTransport(this._transport) && this._state.kind === AgentHostClientState.Connecting) {
-            this._state.outbox.push(message);
-            return;
-        }
-        if (this._state.kind === AgentHostClientState.Reconnecting && !sendDuringReconnect) {
-            this._state.reconnect.outbox.push(message);
-            return;
-        }
-        this._transport.send(message);
-    }
-    _sendRequest(method, params) {
-        return this._dispatchRequest(method, params);
-    }
-    _sendExtensionRequest(method, params) {
-        return this._dispatchRequest(method, params);
-    }
-    _updateTelemetryLevel() {
-        this._dispatchRootConfig({
-            [AgentHostTelemetryLevelConfigKey]: telemetryLevelToAgentHostConfigValue(this._effectiveTelemetryLevel())
-        });
-    }
-    _effectiveTelemetryLevel() {
-        return Math.min(
-            getTelemetryLevel(this._configurationService),
-            this._telemetryService.telemetryLevel
-        );
-    }
-    _dispatchRootConfig(config) {
-        this.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config
-        }, this._clientId, 0);
-    }
-    _updateDisableRepoInfoTelemetry() {
-        const disabled = this._configurationService.getValue(DISABLE_REPO_INFO_TELEMETRY_SETTING_ID) === true;
-        this._dispatchRootConfig({
-            [AgentHostDisableRepoInfoTelemetryConfigKey]: disabled
-        });
-    }
-    _updateTerminalAutoApproveEnabled() {
-        const enabled = this._configurationService.getValue(TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID) !== false;
-        this._dispatchRootConfig({
-            [AgentHostTerminalAutoApproveEnabledConfigKey]: enabled
-        });
-    }
-    _updateTerminalAutoApproveRules() {
-        this._dispatchRootConfig({
-            [AgentHostTerminalAutoApproveRulesConfigKey]: getAgentHostTerminalAutoApproveRulesConfig(this._configurationService)
-        });
-    }
-    _updateManagedSettingsPermissions(sendDuringReconnect = false) {
-        const permissions = this._resourceIdentity === LOCAL_AGENT_HOST_RESOURCE_IDENTITY ? resolveManagedSettingsPermissions(this._configurationService) : {};
-        this._sendExtensionNotification("setClientManagedSettingsPermissions", {
-            permissions
-        }, sendDuringReconnect);
-    }
-    async _dispatchRequest(method, params, options = {}) {
-        if (this._state.kind === AgentHostClientState.Closed) {
-            throw this._state.error;
-        }
-        if (this._state.kind === AgentHostClientState.Incompatible) {
-            if (!options.allowIncompatibleUpgrade) {
-                throw this._state.error;
-            }
-            const {
-                request,
-                result
-            } = this._createRequest(method, params);
-            this._transport.send(request);
-            return result;
-        }
-        if (!options.bypassInitializeQueue && isClientTransport(this._transport) && this._state.kind === AgentHostClientState.Connecting) {
-            const {
-                request,
-                result
-            } = this._createRequest(method, params);
-            this._state.outbox.push(request);
-            return result;
-        }
-        while (!options.bypassReconnectGate && this._state.kind === AgentHostClientState.Reconnecting) {
-            const current = this._state;
-            if (current.kind !== AgentHostClientState.Reconnecting) {
-                break;
-            }
-            try {
-                await current.reconnect.gate.p;
-            } catch {}
-        }
-        const current = this._state;
-        if (current.kind === AgentHostClientState.Closed || current.kind === AgentHostClientState.Incompatible) {
-            throw current.error;
-        }
-        const {
-            request,
-            result
-        } = this._createRequest(method, params);
-        this._transport.send(request);
-        return result;
-    }
-    _createRequest(method, params) {
-        const id = this._nextRequestId++;
-        const deferred = ( new DeferredPromise());
-        this._pendingRequests.set(id, {
-            deferred,
-            suppressNotFoundWarning: isFileResourceRead(method, params),
-            sentAt: Date.now()
-        });
-        return {
-            request: {
-                jsonrpc: "2.0",
-                id,
-                method,
-                params
-            },
-            result: deferred.p
-        };
-    }
-    _shouldLogFailedRequest(request, error) {
-        if (error.code === AhpErrorCodes.NotFound && request.suppressNotFoundWarning) {
-            return false;
-        }
-        return true;
-    }
-    _toProtocolError(error) {
-        return ( new ProtocolError(error.code, error.message, error.data));
-    }
-    _rejectPendingRequests(error) {
-        for (const pending of ( this._pendingRequests.values())) {
-            pending.deferred.error(error);
-        }
-        this._pendingRequests.clear();
-    }
-    _resetLivenessTimers() {
-        this._cancelLivenessTimers();
-        if (this._state.kind === AgentHostClientState.Incompatible || this._state.kind === AgentHostClientState.Reconnecting || this._state.kind === AgentHostClientState.Closed) {
-            return;
-        }
-        this._pingTimer.cancelAndSet(() => this._onPingTimer(), PING_INTERVAL_MS);
-        this._closeTimer.cancelAndSet(() => this._onCloseTimer(), PING_INTERVAL_MS + LIVENESS_TIMEOUT_MS);
-    }
-    _cancelLivenessTimers() {
-        this._pingTimer.cancel();
-        this._closeTimer.cancel();
-        this._livenessDeferred = false;
-        this._livenessDeferredSince = undefined;
-    }
-    _onPingTimer() {
-        if (this._state.kind === AgentHostClientState.Incompatible || this._state.kind === AgentHostClientState.Closed || this._state.kind === AgentHostClientState.Reconnecting) {
-            return;
-        }
-        void this.ping().catch(() => undefined);
-    }
-    _onCloseTimer() {
-        if (this._state.kind === AgentHostClientState.Incompatible || this._state.kind === AgentHostClientState.Closed || this._state.kind === AgentHostClientState.Reconnecting) {
-            return;
-        }
-        if (this._transport.clientConnectionKind === AgentHostClientConnectionKind.Local) {
-            return;
-        }
-        const pendingReverseRequests = this._pendingReverseRequests.get(this._transport) ?? 0;
-        if (pendingReverseRequests > 0 || this._loadEstimator.hasHighLoad()) {
-            this._deferLivenessCheck(pendingReverseRequests);
-            return;
-        }
-        if (this._livenessDeferred) {
-            this._livenessDeferred = false;
-            this._livenessDeferredSince = undefined;
-            this._pingTimer.cancelAndSet(() => this._onPingTimer(), PING_INTERVAL_MS);
-            this._closeTimer.cancelAndSet(() => this._onCloseTimer(), PING_INTERVAL_MS + LIVENESS_TIMEOUT_MS);
-            return;
-        }
-        const silence = Date.now() - this._lastReadTime;
-        this._logService.info(
-            `[RemoteAgentHostProtocol] Liveness: no message from ${this._address} for ${silence}ms; forcing close to trigger reconnect.`
-        );
-        this._transportListeners.clear();
-        if (this._transportFactory) {
-            this._rejectPendingRequests(connectionTimeoutError(this._address, silence));
-            this._handleTransportClose();
-            return;
-        }
-        this._handleClose(connectionTimeoutError(this._address, silence));
-    }
-    _deferLivenessCheck(pendingReverseRequests) {
-        const now = Date.now();
-        if (!this._livenessDeferred) {
-            this._livenessDeferred = true;
-            this._livenessDeferredSince = now;
-        }
-        const deferredSince = this._livenessDeferredSince ?? now;
-        this._logService.trace(
-            `[RemoteAgentHostProtocol] Liveness: deferring close for ${now - deferredSince}ms; ${pendingReverseRequests} reverse request(s) outstanding.`
-        );
-        this._pingTimer.cancelAndSet(() => this._onPingTimer(), PING_INTERVAL_MS);
-        this._closeTimer.cancelAndSet(() => this._onCloseTimer(), PING_INTERVAL_MS);
-    }
-    nextClientSeq() {
-        return this._nextClientSeq++;
-    }
-};
-AgentHostProtocolClient = ( __decorate([( __param(3, ILogService)), ( __param(4, IAgentHostResourceService)), ( __param(5, IConfigurationService)), ( __param(6, ITelemetryService)), ( __param(7, IWorkspaceTrustEnablementService)), ( __param(8, IWorkspaceTrustManagementService)), ( __param(9, IWorkspaceTrustRequestService))], AgentHostProtocolClient));
-
-export { AgentHostClientState, AgentHostProtocolClient, InitialAuthenticationError };