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

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

@@ -1,1110 +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 } 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 { 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { AgentHostCodexAgentEnabledSettingId, AgentSession } from '../common/agentService.js';
-import { createRemoteWatchHandle } from '../common/agentHostFileSystemProvider.js';
-import { AgentSubscriptionManager } from '../common/state/agentSubscription.js';
-import { agentHostAuthority, fromAgentHostUri, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { AgentHostResourcePermissionError } from '../common/agentHostResourceService.js';
-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-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
-import { ROOT_STATE_URI, isAhpRootChannel } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
-import { PROTOCOL_VERSION } 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 } from '../common/state/sessionTransport.js';
-import { AhpErrorCodes } from '../common/state/protocol/common/errors.js';
-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 '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands';
-import { encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-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 } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
-import { getTelemetryLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
-import { SESSION_SYNC_ENABLED_SETTING_ID, TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID, GLOBAL_AUTO_APPROVE_SETTING_ID, AUTO_REPLY_SETTING_ID, TERMINAL_AUTO_APPROVE_SETTING_ID, TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID, AgentHostTelemetryLevelConfigKey, telemetryLevelToAgentHostConfigValue, AgentHostSessionSyncEnabledConfigKey, AgentHostTerminalAutoApproveEnabledConfigKey, AgentHostGlobalAutoApproveEnabledConfigKey, AgentHostAutoReplyEnabledConfigKey, AgentHostCodexEnabledConfigKey, AgentHostTerminalAutoApproveRulesConfigKey, getAgentHostTerminalAutoApproveRulesConfig } from '../common/agentHostSchema.js';
-import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { isFileResourceRead } from '../common/resourceReadLogging.js';
-import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
-
-const AHP_CLIENT_CONNECTION_CLOSED = -32e3;
-const RECONNECT_INITIAL_DELAY_MS = 1_000;
-const RECONNECT_MAX_DELAY_MS = 30_000;
-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}`));
-}
-var AgentHostClientState;
-(function(AgentHostClientState) {
-    AgentHostClientState["Connecting"] = "connecting";
-    AgentHostClientState["Connected"] = "connected";
-    AgentHostClientState["Reconnecting"] = "reconnecting";
-    AgentHostClientState["Closed"] = "closed";
-})(AgentHostClientState || (AgentHostClientState = {}));
-let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends Disposable {
-    get clientId() {
-        return this._clientId;
-    }
-    get address() {
-        return this._address;
-    }
-    get defaultDirectory() {
-        return this._defaultDirectory;
-    }
-    get connectionState() {
-        return this._state.kind;
-    }
-    get initializeResult() {
-        return this._initializeResult;
-    }
-    constructor(
-        address,
-        transportOrFactory,
-        loadEstimator,
-        _logService,
-        _resourceService,
-        _configurationService
-    ) {
-        super();
-        this._logService = _logService;
-        this._resourceService = _resourceService;
-        this._configurationService = _configurationService;
-        this._clientId = generateUuid();
-        this._transportListeners = this._register(( new MutableDisposable()));
-        this._serverSeq = 0;
-        this._nextClientSeq = 1;
-        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._onDidChangeConnectionState = this._register(( new Emitter()));
-        this.onDidChangeConnectionState = this._onDidChangeConnectionState.event;
-        this._state = {
-            kind: AgentHostClientState.Connecting
-        };
-        this._pendingRequests = ( new Map());
-        this._nextRequestId = 1;
-        this._lastReadTime = Date.now();
-        this._pingTimer = this._register(new TimeoutTimer());
-        this._closeTimer = this._register(new TimeoutTimer());
-        this._grantedCustomizationUris = ( new Set());
-        this._address = address;
-        this._connectionAuthority = agentHostAuthority(address);
-        this._loadEstimator = loadEstimator ?? LoadEstimator.getInstance();
-        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(`[RemoteAgentHostProtocolClient] ${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 (e.affectsConfiguration(TELEMETRY_SETTING_ID) || e.affectsConfiguration(TELEMETRY_OLD_SETTING_ID) || e.affectsConfiguration(TELEMETRY_CRASH_REPORTER_SETTING_ID)) {
-                if (this._state.kind !== AgentHostClientState.Connected) {
-                    return;
-                }
-                this._updateTelemetryLevel();
-            }
-            if (e.affectsConfiguration(SESSION_SYNC_ENABLED_SETTING_ID)) {
-                if (this._state.kind !== AgentHostClientState.Connected) {
-                    return;
-                }
-                this._updateSessionSyncEnabled();
-            }
-            if (e.affectsConfiguration(TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID)) {
-                if (this._state.kind !== AgentHostClientState.Connected) {
-                    return;
-                }
-                this._updateTerminalAutoApproveEnabled();
-            }
-            if (e.affectsConfiguration(GLOBAL_AUTO_APPROVE_SETTING_ID)) {
-                if (this._state.kind !== AgentHostClientState.Connected) {
-                    return;
-                }
-                this._updateGlobalAutoApproveEnabled();
-            }
-            if (e.affectsConfiguration(AUTO_REPLY_SETTING_ID)) {
-                if (this._state.kind !== AgentHostClientState.Connected) {
-                    return;
-                }
-                this._updateAutoReplyEnabled();
-            }
-            if (e.affectsConfiguration(TERMINAL_AUTO_APPROVE_SETTING_ID) || e.affectsConfiguration(TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID)) {
-                if (this._state.kind !== AgentHostClientState.Connected) {
-                    return;
-                }
-                this._updateTerminalAutoApproveRules();
-            }
-            if (e.affectsConfiguration(AgentHostCodexAgentEnabledSettingId)) {
-                if (this._state.kind !== AgentHostClientState.Connected) {
-                    return;
-                }
-                this._updateCodexEnabled();
-            }
-        }));
-        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;
-        }
-        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
-        };
-    }
-    dispose() {
-        this._handleClose(connectionDisposedError(this._address));
-        super.dispose();
-    }
-    async connect() {
-        if (isClientTransport(this._transport)) {
-            await this._raceClose(this._transport.connect());
-        }
-        const result = await this._sendRequest("initialize", {
-            channel: ROOT_STATE_URI,
-            protocolVersions: [PROTOCOL_VERSION],
-            clientId: this._clientId,
-            initialSubscriptions: [ROOT_STATE_URI]
-        });
-        this._serverSeq = result.serverSeq;
-        for (const snapshot of result.snapshots ?? []) {
-            if (isAhpRootChannel(snapshot.resource)) {
-                this._subscriptionManager.handleRootSnapshot(snapshot.state, snapshot.fromSeq);
-            }
-        }
-        if (result.defaultDirectory) {
-            const dir = result.defaultDirectory;
-            if (typeof dir === "string") {
-                this._defaultDirectory = ( URI.parse(dir)).path;
-            } else {
-                this._defaultDirectory = URI.revive(dir).path;
-            }
-        }
-        this._initializeResult = result;
-        this._updateTelemetryLevel();
-        this._updateSessionSyncEnabled();
-        this._updateTerminalAutoApproveEnabled();
-        this._updateGlobalAutoApproveEnabled();
-        this._updateAutoReplyEnabled();
-        this._updateTerminalAutoApproveRules();
-        this._updateCodexEnabled();
-        this._transitionTo({
-            kind: AgentHostClientState.Connected
-        });
-    }
-    notifyTransportClosed() {
-        this._handleTransportClose();
-    }
-    _handleTransportClose() {
-        switch (this._state.kind) {
-        case AgentHostClientState.Closed:
-            return;
-        case AgentHostClientState.Connecting:
-            this._handleClose(connectionClosedError(this._address));
-            return;
-        case AgentHostClientState.Connected:
-            {
-                if (!this._transportFactory) {
-                    this._handleClose(connectionClosedError(this._address));
-                    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;
-        }
-    }
-    _scheduleReconnect() {
-        if (this._state.kind !== AgentHostClientState.Reconnecting || !this._transportFactory) {
-            return;
-        }
-        const reconnect = this._state.reconnect;
-        if (reconnect.timeoutHandle !== undefined) {
-            return;
-        }
-        const attempt = reconnect.attempt + 1;
-        const delay = Math.min(
-            RECONNECT_INITIAL_DELAY_MS * Math.pow(2, attempt - 1),
-            RECONNECT_MAX_DELAY_MS
-        );
-        this._logService.info(
-            `[RemoteAgentHostProtocol] Reconnecting to ${this._address} in ${delay}ms (attempt ${attempt}).`
-        );
-        reconnect.timeoutHandle = setTimeout(() => {
-            if (this._state.kind === AgentHostClientState.Reconnecting) {
-                this._state.reconnect.timeoutHandle = undefined;
-            }
-            void this._attemptReconnect();
-        }, delay);
-    }
-    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 = await this._dispatchRequest("reconnect", {
-                clientId: this._clientId,
-                lastSeenServerSeq,
-                subscriptions
-            }, {
-                bypassReconnectGate: true
-            });
-            if (this._state.kind !== AgentHostClientState.Reconnecting) {
-                return;
-            }
-            this._applyReconnectResult(result);
-            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;
-            }
-            const oldGate = this._state.reconnect.gate;
-            this._state.reconnect.gate = this._newReconnectGate();
-            oldGate.error(err);
-            this._scheduleReconnect();
-        }
-    }
-    _applyReconnectResult(result) {
-        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.dropPendingSessionAction(envelope.channel, envelope.origin.clientSeq);
-                }
-                if (envelope.serverSeq > maxSeq) {
-                    maxSeq = envelope.serverSeq;
-                }
-                this._onDidAction.fire(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)))));
-            }
-        } else {
-            let maxSeq = this._serverSeq;
-            for (const snapshot of result.snapshots) {
-                this._subscriptionManager.applyReconnectSnapshot(snapshot.resource, snapshot.state, snapshot.fromSeq);
-                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.getPendingSessionActions()) {
-            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);
-    }
-    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) {
-        const result = await this._sendRequest("subscribe", {
-            channel: ( resource.toString())
-        });
-        if (!result.snapshot) {
-            throw ( new Error(`subscribe to ${( resource.toString())} returned no snapshot`));
-        }
-        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()),
-            provider,
-            workingDirectory: config?.workingDirectory ? ( fromAgentHostUri(config.workingDirectory).toString()) : undefined,
-            config: config?.config,
-            activeClient: config?.activeClient
-        }).then(() => session);
-        this._subscriptionManager.trackSessionCreate(session, promise);
-        return promise;
-    }
-    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 ping() {
-        await this._sendRequest("ping", {
-            channel: ROOT_STATE_URI
-        });
-    }
-    async getCompletionTriggerCharacters() {
-        return this._initializeResult?.completionTriggerCharacters ?? [];
-    }
-    async authenticate(params) {
-        await this._sendRequest("authenticate", {
-            channel: ROOT_STATE_URI,
-            ...params
-        });
-        return {
-            authenticated: true
-        };
-    }
-    async shutdown() {
-        await this._sendExtensionRequest("shutdown");
-    }
-    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: {
-                    chat: ( options.fork.source.toString()),
-                    turnId: options.fork.turnId
-                }
-            } : {})
-        });
-    }
-    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._toLocalProjectUri(( URI.parse(s.project.uri))),
-                    displayName: s.project.displayName
-                }
-            } : {}),
-            summary: s.title,
-            status: s.status,
-            activity: s.activity,
-            workingDirectory: typeof s.workingDirectory === "string" ? toAgentHostUri(( URI.parse(s.workingDirectory)), this._connectionAuthority) : undefined,
-            isRead: !!(s.status & SessionStatus.IsRead),
-            isArchived: !!(s.status & SessionStatus.IsArchived),
-            changes: s.changes
-        })));
-    }
-    _toLocalProjectUri(uri) {
-        return uri.scheme === Schemas.file ? toAgentHostUri(uri, this._connectionAuthority) : uri;
-    }
-    _grantImplicitReadsForOutgoingAction(action) {
-        if (action.type === ActionType.SessionActiveClientSet && action.activeClient.customizations) {
-            this._grantImplicitReadsForCustomizations(action.activeClient.customizations);
-        }
-    }
-    _grantImplicitReadsForCustomizations(refs) {
-        for (const ref of refs) {
-            let uri;
-            try {
-                uri = ( URI.parse(ref.uri));
-            } catch {
-                continue;
-            }
-            const grantUri = dirname(uri);
-            const key = ( grantUri.toString());
-            if (( this._grantedCustomizationUris.has(key))) {
-                continue;
-            }
-            this._grantedCustomizationUris.add(key);
-            this._resourceService.grantImplicitRead(this._address, grantUri);
-        }
-    }
-    async resourceList(uri) {
-        return await this._sendRequest("resourceList", {
-            channel: ROOT_STATE_URI,
-            uri: ( uri.toString())
-        });
-    }
-    async resourceRead(uri) {
-        return this._sendRequest("resourceRead", {
-            channel: ROOT_STATE_URI,
-            uri: ( uri.toString())
-        });
-    }
-    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, {});
-    }
-    _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(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));
-        }
-    }
-    _handleClose(error) {
-        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);
-            }
-        }
-        this._rejectPendingRequests(error);
-        this._resourceService.connectionClosed(this._address);
-        this._grantedCustomizationUris.clear();
-        this._transitionTo({
-            kind: AgentHostClientState.Closed,
-            error
-        });
-        this._onDidClose.fire();
-    }
-    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;
-        const sendResult = result => {
-            transport.send({
-                jsonrpc: "2.0",
-                id,
-                result
-            });
-        };
-        const sendError = err => {
-            if (err instanceof AgentHostResourcePermissionError) {
-                transport.send({
-                    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;
-            }
-            transport.send({
-                jsonrpc: "2.0",
-                id,
-                error: {
-                    code,
-                    message: err instanceof Error ? err.message : String(err)
-                }
-            });
-        };
-        const p = (params ?? {});
-        const addr = this._address;
-        void (async () => {
-            try {
-                switch (method) {
-                case "resourceList":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        const result = await this._resourceService.list(addr, ( 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(addr, ( 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(addr, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceDelete":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        await this._resourceService.del(addr, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceMove":
-                    {
-                        if (!p.source || !p.destination) {
-                            throw ( new Error("Missing source or destination"));
-                        }
-                        await this._resourceService.move(addr, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceCopy":
-                    {
-                        if (!p.source || !p.destination) {
-                            throw ( new Error("Missing source or destination"));
-                        }
-                        await this._resourceService.copy(addr, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceResolve":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        const result = await this._resourceService.resolve(addr, p);
-                        sendResult(result);
-                        return;
-                    }
-                case "resourceMkdir":
-                    {
-                        if (!p.uri) {
-                            throw ( new Error("Missing uri"));
-                        }
-                        await this._resourceService.mkdir(addr, p);
-                        sendResult({});
-                        return;
-                    }
-                case "resourceRequest":
-                    {
-                        try {
-                            await this._resourceService.request(addr, 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) {
-        if (this._state.kind === AgentHostClientState.Closed) {
-            return;
-        }
-        const message = {
-            jsonrpc: "2.0",
-            method,
-            params
-        };
-        if (this._state.kind === AgentHostClientState.Reconnecting) {
-            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.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config: {
-                [AgentHostTelemetryLevelConfigKey]: telemetryLevelToAgentHostConfigValue(getTelemetryLevel(this._configurationService))
-            }
-        }, this._clientId, 0);
-    }
-    _updateSessionSyncEnabled() {
-        const enabled = !!this._configurationService.getValue(SESSION_SYNC_ENABLED_SETTING_ID);
-        this.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config: {
-                [AgentHostSessionSyncEnabledConfigKey]: enabled
-            }
-        }, this._clientId, 0);
-    }
-    _updateTerminalAutoApproveEnabled() {
-        const enabled = this._configurationService.getValue(TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID) !== false;
-        this.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config: {
-                [AgentHostTerminalAutoApproveEnabledConfigKey]: enabled
-            }
-        }, this._clientId, 0);
-    }
-    _updateGlobalAutoApproveEnabled() {
-        const enabled = this._configurationService.getValue(GLOBAL_AUTO_APPROVE_SETTING_ID) === true;
-        this.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config: {
-                [AgentHostGlobalAutoApproveEnabledConfigKey]: enabled
-            }
-        }, this._clientId, 0);
-    }
-    _updateAutoReplyEnabled() {
-        const enabled = this._configurationService.getValue(AUTO_REPLY_SETTING_ID) === true;
-        this.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config: {
-                [AgentHostAutoReplyEnabledConfigKey]: enabled
-            }
-        }, this._clientId, 0);
-    }
-    _updateCodexEnabled() {
-        const enabled = this._configurationService.getValue(AgentHostCodexAgentEnabledSettingId) === true;
-        this.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config: {
-                [AgentHostCodexEnabledConfigKey]: enabled
-            }
-        }, this._clientId, 0);
-    }
-    _updateTerminalAutoApproveRules() {
-        this.dispatchAction(ROOT_STATE_URI, {
-            type: ActionType.RootConfigChanged,
-            config: {
-                [AgentHostTerminalAutoApproveRulesConfigKey]: getAgentHostTerminalAutoApproveRulesConfig(this._configurationService)
-            }
-        }, this._clientId, 0);
-    }
-    async _dispatchRequest(method, params, options = {}) {
-        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 {}
-        }
-        if (this._state.kind === AgentHostClientState.Closed) {
-            throw this._state.error;
-        }
-        const id = this._nextRequestId++;
-        const deferred = ( new DeferredPromise());
-        this._pendingRequests.set(id, {
-            deferred,
-            suppressNotFoundWarning: isFileResourceRead(method, params),
-            sentAt: Date.now()
-        });
-        const request = {
-            jsonrpc: "2.0",
-            id,
-            method,
-            params
-        };
-        this._transport.send(request);
-        return 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() {
-        if (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();
-    }
-    _onPingTimer() {
-        if (this._state.kind === AgentHostClientState.Closed || this._state.kind === AgentHostClientState.Reconnecting) {
-            return;
-        }
-        void this.ping().catch(() => undefined);
-    }
-    _onCloseTimer() {
-        if (this._state.kind === AgentHostClientState.Closed || this._state.kind === AgentHostClientState.Reconnecting) {
-            return;
-        }
-        if (this._loadEstimator.hasHighLoad()) {
-            this._closeTimer.cancelAndSet(() => this._onCloseTimer(), PING_INTERVAL_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));
-    }
-    nextClientSeq() {
-        return this._nextClientSeq++;
-    }
-};
-RemoteAgentHostProtocolClient = ( __decorate([( __param(3, ILogService)), ( __param(4, IAgentHostResourceService)), ( __param(5, IConfigurationService))], RemoteAgentHostProtocolClient));
-
-export { AgentHostClientState, RemoteAgentHostProtocolClient };