@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -0,0 +1,1911 @@
+
+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 '../common/state/legacyProtocolCompatibility.js';
+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 };