@codingame/monaco-vscode-chat-service-override 30.0.1 → 31.0.0

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

@@ -0,0 +1,453 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { raceTimeout, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { ConfigurationTarget } 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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { RemoteAgentHostsSettingId, RemoteAgentHostsEnabledSettingId, RemoteAgentHostEntryType, getEntryAddress, RemoteAgentHostConnectionStatus, rawEntryToEntry, entryToRawEntry } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { RemoteAgentHostProtocolClient } from './remoteAgentHostProtocolClient.js';
+import { WebSocketClientTransport } from './webSocketClientTransport.js';
+import { normalizeRemoteAgentHostAddress } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+var RemoteAgentHostService_1;
+let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
+    static {
+        RemoteAgentHostService_1 = this;
+    }
+    static {
+        this.ConnectionWaitTimeout = 10000;
+    }
+    static {
+        this.ReconnectInitialDelay = 1000;
+    }
+    static {
+        this.ReconnectMaxDelay = 30000;
+    }
+    constructor(_configurationService, _instantiationService, _logService) {
+        super();
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._onDidChangeConnections = this._register(( new Emitter()));
+        this.onDidChangeConnections = this._onDidChangeConnections.event;
+        this._entries = ( new Map());
+        this._names = ( new Map());
+        this._tokens = ( new Map());
+        this._registeredEntries = ( new Map());
+        this._pendingConnectionWaits = ( new Map());
+        this._reconnectTimeouts = ( new Map());
+        this._reconnectAttempts = ( new Map());
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(RemoteAgentHostsSettingId) || e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                this._reconcileConnections();
+            }
+        }));
+        this._reconcileConnections();
+    }
+    get connections() {
+        const result = [];
+        for (const [address, entry] of this._entries) {
+            result.push({
+                address,
+                name: this._names.get(address) ?? address,
+                clientId: entry.client.clientId,
+                defaultDirectory: entry.client.defaultDirectory,
+                status: entry.status
+            });
+        }
+        return result;
+    }
+    get configuredEntries() {
+        return ( this._getConfiguredEntries().map(e => {
+            if (e.connection.type === RemoteAgentHostEntryType.Tunnel) {
+                return e;
+            }
+            return {
+                ...e,
+                connection: {
+                    ...e.connection,
+                    address: normalizeRemoteAgentHostAddress(e.connection.address)
+                }
+            };
+        }));
+    }
+    getConnection(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        const entry = this._entries.get(normalized);
+        return entry?.connected ? entry.client : undefined;
+    }
+    getEntryByAddress(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        const registered = this._registeredEntries.get(normalized);
+        if (registered) {
+            return registered;
+        }
+        return this.configuredEntries.find(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalized);
+    }
+    reconnect(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        const configuredEntry = this._getConfiguredEntries().find(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalized);
+        if (configuredEntry && configuredEntry.connection.type !== RemoteAgentHostEntryType.WebSocket) {
+            return;
+        }
+        const token = this._tokens.get(normalized);
+        this._cancelReconnect(normalized);
+        this._reconnectAttempts.delete(normalized);
+        const entry = this._entries.get(normalized);
+        if (entry) {
+            this._entries.delete(normalized);
+            entry.store.dispose();
+        }
+        this._connectTo(normalized, token);
+    }
+    async addRemoteAgentHost(input) {
+        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
+            throw ( new Error("Remote agent host connections are not enabled."));
+        }
+        const entry = input.connection.type === RemoteAgentHostEntryType.Tunnel ? input : {
+            ...input,
+            connection: {
+                ...input.connection,
+                address: normalizeRemoteAgentHostAddress(input.connection.address)
+            }
+        };
+        const address = getEntryAddress(entry);
+        const existingConnection = this._getConnectionInfo(address);
+        await this._storeConfiguredEntries(this._upsertConfiguredEntry(entry));
+        if (existingConnection) {
+            return {
+                ...existingConnection,
+                name: entry.name
+            };
+        }
+        if (entry.connection.type === RemoteAgentHostEntryType.SSH) {
+            return {
+                address,
+                name: entry.name,
+                clientId: "",
+                status: RemoteAgentHostConnectionStatus.Disconnected
+            };
+        }
+        const connectedConnection = this._getConnectionInfo(address);
+        if (connectedConnection) {
+            return connectedConnection;
+        }
+        const wait = this._getOrCreateConnectionWait(address);
+        const connection = await raceTimeout(wait.p, RemoteAgentHostService_1.ConnectionWaitTimeout, () => {
+            this._pendingConnectionWaits.delete(address);
+        });
+        if (!connection) {
+            throw ( new Error(`Timed out connecting to ${address}`));
+        }
+        return connection;
+    }
+    async addSSHConnection(entry, connection) {
+        const address = getEntryAddress(entry);
+        const existingEntry = this._entries.get(address);
+        if (existingEntry) {
+            this._entries.delete(address);
+            existingEntry.store.dispose();
+        }
+        const store = ( new DisposableStore());
+        const protocolClient = connection;
+        store.add(protocolClient);
+        const connEntry = {
+            store,
+            client: protocolClient,
+            connected: true,
+            status: RemoteAgentHostConnectionStatus.Connected
+        };
+        this._entries.set(address, connEntry);
+        this._names.set(address, entry.name);
+        this._registeredEntries.set(address, entry);
+        if (entry.connectionToken) {
+            this._tokens.set(address, entry.connectionToken);
+        }
+        store.add(protocolClient.onDidClose(() => {
+            if (this._entries.get(address) === connEntry) {
+                connEntry.connected = false;
+                connEntry.status = RemoteAgentHostConnectionStatus.Disconnected;
+                this._onDidChangeConnections.fire();
+            }
+        }));
+        await this._storeConfiguredEntries(this._upsertConfiguredEntry(entry));
+        this._onDidChangeConnections.fire();
+        return {
+            address,
+            name: entry.name,
+            clientId: protocolClient.clientId,
+            defaultDirectory: protocolClient.defaultDirectory,
+            status: RemoteAgentHostConnectionStatus.Connected
+        };
+    }
+    async removeRemoteAgentHost(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        const entries = this._getConfiguredEntries().filter(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) !== normalized);
+        await this._storeConfiguredEntries(entries);
+        this._names.delete(normalized);
+        this._tokens.delete(normalized);
+        this._registeredEntries.delete(normalized);
+        this._cancelReconnect(normalized);
+        this._reconnectAttempts.delete(normalized);
+        this._removeConnection(normalized);
+    }
+    _removeConnection(address) {
+        const entry = this._entries.get(address);
+        if (entry) {
+            this._entries.delete(address);
+            entry.store.dispose();
+            this._rejectPendingConnectionWait(address, ( new Error(`Connection closed: ${address}`)));
+            this._onDidChangeConnections.fire();
+        }
+    }
+    _reconcileConnections() {
+        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
+            for (const address of [...( this._entries.keys())]) {
+                this._cancelReconnect(address);
+                this._removeConnection(address);
+            }
+            this._names.clear();
+            this._tokens.clear();
+            this._reconnectAttempts.clear();
+            return;
+        }
+        const rawEntries = ( (this._configurationService.getValue(RemoteAgentHostsSettingId) ?? []).map(rawEntryToEntry)).filter(isDefined);
+        const entriesWithAddress = ( rawEntries.map(e => ({
+            entry: e,
+            address: normalizeRemoteAgentHostAddress(getEntryAddress(e))
+        })));
+        const desired = ( new Set(( entriesWithAddress.map(e => e.address))));
+        this._logService.info(
+            `[RemoteAgentHost] Reconciling: desired=[${[...desired].join(", ")}], current=[${( [...( this._entries.keys())].map(a => `${a}(${this._entries.get(a).connected ? "connected" : "pending"})`)).join(", ")}]`
+        );
+        let namesChanged = false;
+        const oldNames = ( new Map(this._names));
+        this._names.clear();
+        this._tokens.clear();
+        for (const {
+            entry,
+            address
+        } of entriesWithAddress) {
+            this._names.set(address, entry.name);
+            this._tokens.set(address, entry.connectionToken);
+            if (( this._entries.has(address)) && oldNames.get(address) !== entry.name) {
+                namesChanged = true;
+            }
+        }
+        for (const address of [...( this._entries.keys())]) {
+            if (!( desired.has(address))) {
+                this._logService.info(`[RemoteAgentHost] Disconnecting from ${address}`);
+                this._cancelReconnect(address);
+                this._reconnectAttempts.delete(address);
+                this._removeConnection(address);
+            }
+        }
+        for (const {
+            entry,
+            address
+        } of entriesWithAddress) {
+            if (!( this._entries.has(address)) && entry.connection.type === RemoteAgentHostEntryType.WebSocket) {
+                this._connectTo(address, entry.connectionToken);
+            }
+        }
+        if (namesChanged) {
+            this._onDidChangeConnections.fire();
+        }
+    }
+    _connectTo(address, connectionToken) {
+        const existingEntry = this._entries.get(address);
+        if (existingEntry) {
+            this._entries.delete(address);
+            existingEntry.store.dispose();
+        }
+        const store = ( new DisposableStore());
+        const transport = store.add(( new WebSocketClientTransport(address, connectionToken)));
+        const client = store.add(
+            this._instantiationService.createInstance(RemoteAgentHostProtocolClient, address, transport)
+        );
+        const entry = {
+            store,
+            client,
+            connected: false,
+            status: RemoteAgentHostConnectionStatus.Connecting
+        };
+        this._entries.set(address, entry);
+        const isCurrentEntry = () => this._entries.get(address) === entry;
+        store.add(client.onDidClose(() => {
+            if (!isCurrentEntry()) {
+                return;
+            }
+            this._logService.warn(`[RemoteAgentHost] Connection closed: ${address}`);
+            entry.connected = false;
+            entry.status = RemoteAgentHostConnectionStatus.Disconnected;
+            this._onDidChangeConnections.fire();
+            this._scheduleReconnect(address, connectionToken);
+        }));
+        this._logService.info(`[RemoteAgentHost] Connecting to ${address}`);
+        this._onDidChangeConnections.fire();
+        client.connect().then(() => {
+            if (store.isDisposed) {
+                return;
+            }
+            this._logService.info(`[RemoteAgentHost] Connected to ${address}`);
+            entry.connected = true;
+            entry.status = RemoteAgentHostConnectionStatus.Connected;
+            this._reconnectAttempts.delete(address);
+            this._resolvePendingConnectionWait(address);
+            this._onDidChangeConnections.fire();
+        }).catch(err => {
+            if (!isCurrentEntry()) {
+                return;
+            }
+            this._logService.error(
+                `[RemoteAgentHost] Failed to connect to ${address}. Verify address and connectionToken`,
+                err
+            );
+            entry.status = RemoteAgentHostConnectionStatus.Disconnected;
+            this._entries.delete(address);
+            entry.store.dispose();
+            this._rejectPendingConnectionWait(address, err);
+            this._onDidChangeConnections.fire();
+            this._scheduleReconnect(address, connectionToken);
+        });
+    }
+    _scheduleReconnect(address, connectionToken) {
+        if (!this._isAddressConfigured(address)) {
+            this._logService.info(`[RemoteAgentHost] Not reconnecting to ${address}: no longer configured`);
+            return;
+        }
+        const attempt = (this._reconnectAttempts.get(address) ?? 0) + 1;
+        this._reconnectAttempts.set(address, attempt);
+        const delay = Math.min(
+            RemoteAgentHostService_1.ReconnectInitialDelay * Math.pow(2, attempt - 1),
+            RemoteAgentHostService_1.ReconnectMaxDelay
+        );
+        this._logService.info(
+            `[RemoteAgentHost] Scheduling reconnect to ${address} in ${delay}ms (attempt ${attempt})`
+        );
+        this._cancelReconnect(address);
+        const timeout = setTimeout(() => {
+            this._reconnectTimeouts.delete(address);
+            if (this._isAddressConfigured(address)) {
+                this._connectTo(address, connectionToken ?? this._tokens.get(address));
+            }
+        }, delay);
+        this._reconnectTimeouts.set(address, timeout);
+    }
+    _cancelReconnect(address) {
+        const timeout = this._reconnectTimeouts.get(address);
+        if (timeout !== undefined) {
+            clearTimeout(timeout);
+            this._reconnectTimeouts.delete(address);
+        }
+    }
+    _isAddressConfigured(address) {
+        const entries = this._getConfiguredEntries();
+        return ( entries.some(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === address));
+    }
+    _getConnectionInfo(address) {
+        return this.connections.find(
+            connection => connection.address === address && connection.status === RemoteAgentHostConnectionStatus.Connected
+        );
+    }
+    _getConfiguredEntries() {
+        return ( (this._configurationService.getValue(RemoteAgentHostsSettingId) ?? []).map(rawEntryToEntry)).filter(isDefined);
+    }
+    _upsertConfiguredEntry(entry) {
+        const target = this._getConfigurationTarget();
+        const inspected = this._configurationService.inspect(RemoteAgentHostsSettingId);
+        let configuredRaw;
+        switch (target) {
+        case ConfigurationTarget.USER_LOCAL:
+            configuredRaw = inspected.userLocalValue ?? [];
+            break;
+        case ConfigurationTarget.USER_REMOTE:
+            configuredRaw = inspected.userRemoteValue ?? [];
+            break;
+        default:
+            configuredRaw = inspected.userValue ?? [];
+            break;
+        }
+        const configuredEntries = ( configuredRaw.map(rawEntryToEntry)).filter(e => e !== undefined);
+        const normalizedAddress = normalizeRemoteAgentHostAddress(getEntryAddress(entry));
+        const existingIndex = configuredEntries.findIndex(
+            e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalizedAddress
+        );
+        if (existingIndex === -1) {
+            return [...configuredEntries, entry];
+        }
+        return ( configuredEntries.map((e, index) => index === existingIndex ? entry : e));
+    }
+    _getConfigurationTarget() {
+        const inspected = this._configurationService.inspect(RemoteAgentHostsSettingId);
+        if (inspected.userLocalValue !== undefined) {
+            return ConfigurationTarget.USER_LOCAL;
+        }
+        if (inspected.userRemoteValue !== undefined) {
+            return ConfigurationTarget.USER_REMOTE;
+        }
+        if (inspected.userValue !== undefined) {
+            return ConfigurationTarget.USER;
+        }
+        return ConfigurationTarget.USER;
+    }
+    async _storeConfiguredEntries(entries) {
+        const raw = ( entries.map(entryToRawEntry)).filter(isDefined);
+        await this._configurationService.updateValue(RemoteAgentHostsSettingId, raw, this._getConfigurationTarget());
+    }
+    _getOrCreateConnectionWait(address) {
+        let wait = this._pendingConnectionWaits.get(address);
+        if (wait) {
+            return wait;
+        }
+        const existingConnection = this._getConnectionInfo(address);
+        if (existingConnection) {
+            const immediateWait = ( new DeferredPromise());
+            immediateWait.complete(existingConnection);
+            return immediateWait;
+        }
+        wait = ( new DeferredPromise());
+        this._pendingConnectionWaits.set(address, wait);
+        return wait;
+    }
+    _resolvePendingConnectionWait(address) {
+        const wait = this._pendingConnectionWaits.get(address);
+        const connection = this._getConnectionInfo(address);
+        if (!wait || !connection) {
+            return;
+        }
+        this._pendingConnectionWaits.delete(address);
+        void wait.complete(connection);
+    }
+    _rejectPendingConnectionWait(address, err) {
+        const wait = this._pendingConnectionWaits.get(address);
+        if (!wait) {
+            return;
+        }
+        this._pendingConnectionWaits.delete(address);
+        void wait.error(err);
+    }
+    dispose() {
+        for (const timeout of ( this._reconnectTimeouts.values())) {
+            clearTimeout(timeout);
+        }
+        this._reconnectTimeouts.clear();
+        this._reconnectAttempts.clear();
+        for (const [address, wait] of this._pendingConnectionWaits) {
+            void wait.error(( new Error(`Remote agent host service disposed before connecting to ${address}`)));
+        }
+        this._pendingConnectionWaits.clear();
+        for (const entry of ( this._entries.values())) {
+            entry.store.dispose();
+        }
+        this._entries.clear();
+        super.dispose();
+    }
+};
+RemoteAgentHostService = RemoteAgentHostService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService))], RemoteAgentHostService));
+
+export { RemoteAgentHostService };

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

@@ -0,0 +1,28 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { IAhpServerNotification, IJsonRpcResponse, IProtocolMessage } from "../common/state/sessionProtocol.js";
+import type { IClientTransport } from "../common/state/sessionTransport.js";
+/**
+ * A WebSocket client transport that connects to a remote agent host server.
+ * Uses the native browser WebSocket API (available in Electron renderer).
+ * Implements {@link IClientTransport} with JSON serialization and URI revival.
+ */
+export declare class WebSocketClientTransport extends Disposable implements IClientTransport {
+    private readonly _address;
+    private readonly _connectionToken?;
+    private readonly _onMessage;
+    readonly onMessage: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<IProtocolMessage>;
+    private readonly _onClose;
+    readonly onClose: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly _onOpen;
+    readonly onOpen: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private _ws;
+    get isOpen(): boolean;
+    constructor(_address: string, _connectionToken?: string | undefined);
+    /**
+     * Initiate the WebSocket connection. Resolves when the connection
+     * is open, or rejects on error/timeout.
+     */
+    connect(): Promise<void>;
+    send(message: IProtocolMessage | IAhpServerNotification | IJsonRpcResponse): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,81 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { connectionTokenQueryName } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+
+class WebSocketClientTransport extends Disposable {
+    get isOpen() {
+        return this._ws?.readyState === WebSocket.OPEN;
+    }
+    constructor(_address, _connectionToken) {
+        super();
+        this._address = _address;
+        this._connectionToken = _connectionToken;
+        this._onMessage = this._register(( new Emitter()));
+        this.onMessage = this._onMessage.event;
+        this._onClose = this._register(( new Emitter()));
+        this.onClose = this._onClose.event;
+        this._onOpen = this._register(( new Emitter()));
+        this.onOpen = this._onOpen.event;
+    }
+    connect() {
+        return ( new Promise((resolve, reject) => {
+            if (this._store.isDisposed) {
+                reject(( new Error("Transport is disposed")));
+                return;
+            }
+            let url = this._address.startsWith("ws://") || this._address.startsWith("wss://") ? this._address : `ws://${this._address}`;
+            if (this._connectionToken) {
+                const separator = url.includes("?") ? "&" : "?";
+                url += `${separator}${connectionTokenQueryName}=${encodeURIComponent(this._connectionToken)}`;
+            }
+            const ws = ( new WebSocket(url));
+            this._ws = ws;
+            const onOpen = () => {
+                cleanup();
+                this._onOpen.fire();
+                resolve();
+            };
+            const onError = () => {
+                cleanup();
+                reject(( new Error(`WebSocket connection failed: ${this._address}`)));
+            };
+            const onClose = () => {
+                cleanup();
+                reject(( new Error(`WebSocket closed before connection was established: ${this._address}`)));
+            };
+            const cleanup = () => {
+                ws.removeEventListener("open", onOpen);
+                ws.removeEventListener("error", onError);
+                ws.removeEventListener("close", onClose);
+            };
+            ws.addEventListener("open", onOpen);
+            ws.addEventListener("error", onError);
+            ws.addEventListener("close", onClose);
+            ws.addEventListener("message", event => {
+                try {
+                    const text = typeof event.data === "string" ? event.data : "";
+                    const message = JSON.parse(text);
+                    this._onMessage.fire(message);
+                } catch {}
+            });
+            ws.addEventListener("close", () => {
+                this._onClose.fire();
+            });
+            ws.addEventListener("error", () => {
+                this._onClose.fire();
+            });
+        }));
+    }
+    send(message) {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify(message));
+        }
+    }
+    dispose() {
+        this._ws?.close();
+        super.dispose();
+    }
+}
+
+export { WebSocketClientTransport };

package/vscode/src/vs/platform/agentHost/common/agentHostFileSystemProvider.d.ts

@@ -0,0 +1,75 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, IFileWriteOptions, IStat } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
+import { type IResourceDeleteParams, type IResourceDeleteResult, type IResourceListResult, type IResourceMoveParams, type IResourceMoveResult, type IResourceReadResult, type IResourceWriteParams, type IResourceWriteResult } from "./state/protocol/commands.js";
+/**
+ * Interface for performing resource operations on a remote endpoint.
+ *
+ * Both {@link IAgentConnection} (client→server) and client-exposed
+ * filesystems (server→client) satisfy this contract.
+ */
+export interface IRemoteFilesystemConnection {
+    resourceList(uri: URI): Promise<IResourceListResult>;
+    resourceRead(uri: URI): Promise<IResourceReadResult>;
+    resourceWrite(params: IResourceWriteParams): Promise<IResourceWriteResult>;
+    resourceDelete(params: IResourceDeleteParams): Promise<IResourceDeleteResult>;
+    resourceMove(params: IResourceMoveParams): Promise<IResourceMoveResult>;
+}
+/**
+ * Build a {@link AGENT_HOST_SCHEME} URI for a given connection authority
+ * and remote path. Assumes the remote path is a `file://` resource.
+ */
+export declare function agentHostUri(authority: string, path: string): URI;
+/**
+ * Extract the remote filesystem path from a {@link AGENT_HOST_SCHEME} URI.
+ */
+export declare function agentHostRemotePath(uri: URI): string;
+/**
+ * {@link IFileSystemProvider} that proxies filesystem operations
+ * through a {@link IRemoteFilesystemConnection}.
+ *
+ * URIs encode the original scheme and authority in the path so any remote
+ * resource can be represented. Subclasses provide the URI decode function
+ * and scheme-specific helpers.
+ *
+ * Individual connections are identified by the URI's authority component.
+ */
+export declare abstract class AHPFileSystemProvider extends Disposable implements IFileSystemProvider {
+    readonly capabilities: number;
+    private readonly _onDidChangeCapabilities;
+    readonly onDidChangeCapabilities: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<readonly IFileChange[]>;
+    private readonly _authorityToConnection;
+    /**
+     * Register a mapping from a URI authority to a connection.
+     * Returns a disposable that unregisters the mapping.
+     */
+    registerAuthority(authority: string, connection: IRemoteFilesystemConnection): IDisposable;
+    /** Decode a provider URI back to the original URI for the remote endpoint. */
+    protected abstract _decodeUri(resource: URI): URI;
+    watch(): IDisposable;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, _opts: IFileWriteOptions): Promise<void>;
+    mkdir(): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    private _getConnection;
+    private _listDirectory;
+}
+/**
+ * Filesystem provider for accessing agent host files from the
+ * client side. Registered under the `vscode-agent-host` scheme.
+ *
+ * ```
+ * vscode-agent-host://[connectionAuthority]/[originalScheme]/[originalAuthority]/[originalPath]
+ * ```
+ */
+export declare class AgentHostFileSystemProvider extends AHPFileSystemProvider {
+    protected _decodeUri(resource: URI): URI;
+}