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

package/index.js

@@ -80,8 +80,7 @@ import { LanguageModelsConfigurationService } from './vscode/src/vs/workbench/co
 import { ChatTipService } from './vscode/src/vs/workbench/contrib/chat/browser/chatTipService.js';
 import { ChatEditingExplanationModelManager } from './vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingExplanationModelManager.js';
 import { ChatToolOutputStateCache } from './vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolOutputStateCache.js';
-import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.service';
-import { TerminalSandboxService } from './vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.js';
+import { TerminalSandboxService } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService';
 import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
 import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
 import { AgentPluginService } from './vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginServiceImpl.js';
@@ -112,11 +111,24 @@ import { IInlineChatHistoryService } from '@codingame/monaco-vscode-api/vscode/v
 import { InlineChatHistoryService } from './vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatHistoryService.js';
 import { NullSandboxHelperService } from './vscode/src/vs/platform/sandbox/browser/sandboxHelperService.js';
 import { ISandboxHelperService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service';
+import { IPluginGitService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginGitService.service';
+import { BrowserPluginGitCommandService } from './vscode/src/vs/workbench/contrib/chat/browser/pluginGitCommandService.js';
+import { IAgentNetworkFilterService } from '@codingame/monaco-vscode-api/vscode/vs/platform/networkFilter/common/networkFilterService.service';
+import { AgentNetworkFilterService } from './vscode/src/vs/platform/networkFilter/common/networkFilterService.js';
+import { IAgentHostFileSystemService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/common/agentHostFileSystemService.service';
+import { IAgentHostSessionWorkingDirectoryResolver } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service';
+import { IAgentHostTerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service';
+import { AgentHostTerminalService } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { RemoteAgentHostService } from './vscode/src/vs/platform/agentHost/browser/remoteAgentHostServiceImpl.js';
+import { AgentHostFileSystemService } from './vscode/src/vs/workbench/services/agentHost/common/agentHostFileSystemService.js';
+import { AgentHostSessionWorkingDirectoryResolver } from './vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.js';
 import './vscode/src/vs/workbench/contrib/chat/browser/chat.contribution.js';
 import './vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/terminal.chatAgentTools.contribution.js';
 import './vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminal.chat.contribution.js';
 import './vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChat.contribution.js';
 import './vscode/src/vs/workbench/contrib/remoteCodingAgents/browser/remoteCodingAgents.contribution.js';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
 
 class DefaultAccountService {
     constructor(defaultAccount) {
@@ -193,7 +205,13 @@ function getServiceOverride({ defaultAccount } = {}) {
         [IChatArtifactsService.toString()]: new SyncDescriptor(ChatArtifactsService, [], true),
         [IWorkspacePluginSettingsService.toString()]: new SyncDescriptor(WorkspacePluginSettingsService, [], true),
         [IChatImageCarouselService.toString()]: new SyncDescriptor(ChatImageCarouselService, [], true),
-        [IInlineChatHistoryService.toString()]: new SyncDescriptor(InlineChatHistoryService, [], true)
+        [IInlineChatHistoryService.toString()]: new SyncDescriptor(InlineChatHistoryService, [], true),
+        [IPluginGitService.toString()]: new SyncDescriptor(BrowserPluginGitCommandService, [], true),
+        [IAgentNetworkFilterService.toString()]: new SyncDescriptor(AgentNetworkFilterService, [], true),
+        [IRemoteAgentHostService.toString()]: new SyncDescriptor(RemoteAgentHostService, [], true),
+        [IAgentHostFileSystemService.toString()]: new SyncDescriptor(AgentHostFileSystemService, [], true),
+        [IAgentHostSessionWorkingDirectoryResolver.toString()]: new SyncDescriptor(AgentHostSessionWorkingDirectoryResolver, [], true),
+        [IAgentHostTerminalService.toString()]: new SyncDescriptor(AgentHostTerminalService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-chat-service-override",
-  "version": "30.0.1",
+  "version": "31.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - chat service-override",
   "keywords": [],
@@ -15,10 +15,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "30.0.1",
-    "@codingame/monaco-vscode-katex-common": "30.0.1",
-    "@codingame/monaco-vscode-xterm-addons-common": "30.0.1",
-    "@codingame/monaco-vscode-xterm-common": "30.0.1"
+    "@codingame/monaco-vscode-api": "31.0.0",
+    "@codingame/monaco-vscode-katex-common": "31.0.0",
+    "@codingame/monaco-vscode-xterm-addons-common": "31.0.0",
+    "@codingame/monaco-vscode-xterm-common": "31.0.0"
   },
   "main": "index.js",
   "module": "index.js",

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

@@ -0,0 +1,125 @@
+import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IAgentConnection, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, IAuthenticateParams, IAuthenticateResult } from "../common/agentService.js";
+import { type IAgentSubscription } from "../common/state/agentSubscription.js";
+import type { ICommandMap } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/messages";
+import type { IActionEnvelope, ISessionAction, ITerminalAction } from "../common/state/sessionActions.js";
+import { StateComponents, type IRootState } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+import { type IStateSnapshot } from "../common/state/sessionProtocol.js";
+import { type IProtocolTransport } from "../common/state/sessionTransport.js";
+import { type ICreateTerminalParams, type IResolveSessionConfigResult, type ISessionConfigCompletionsResult } from "../common/state/protocol/commands.js";
+/**
+ * A protocol-level client for a single remote agent host connection.
+ * Manages the WebSocket transport, handshake, subscriptions, action dispatch,
+ * and command/response correlation.
+ *
+ * Implements {@link IAgentConnection} so consumers can program against
+ * a single interface regardless of whether the agent host is local or remote.
+ */
+export declare class RemoteAgentHostProtocolClient extends Disposable implements IAgentConnection {
+    private readonly _logService;
+    private readonly _fileService;
+    readonly _serviceBrand: undefined;
+    private readonly _clientId;
+    private readonly _address;
+    private readonly _transport;
+    private readonly _connectionAuthority;
+    private _serverSeq;
+    private _nextClientSeq;
+    private _defaultDirectory;
+    private readonly _subscriptionManager;
+    private readonly _onDidAction;
+    readonly onDidAction: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<IActionEnvelope>;
+    private readonly _onDidNotification;
+    readonly onDidNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications").IProtocolNotification>;
+    private readonly _onDidClose;
+    readonly onDidClose: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    /** Pending JSON-RPC requests keyed by request id. */
+    private readonly _pendingRequests;
+    private _nextRequestId;
+    get clientId(): string;
+    get address(): string;
+    get defaultDirectory(): string | undefined;
+    constructor(address: string, transport: IProtocolTransport, _logService: ILogService, _fileService: IFileService);
+    /**
+     * Connect to the remote agent host and perform the protocol handshake.
+     */
+    connect(): Promise<void>;
+    get rootState(): IAgentSubscription<IRootState>;
+    getSubscription<T>(kind: StateComponents, resource: URI): IReference<IAgentSubscription<T>>;
+    getSubscriptionUnmanaged<T>(_kind: StateComponents, resource: URI): IAgentSubscription<T> | undefined;
+    dispatch(action: ISessionAction | ITerminalAction): void;
+    /**
+     * Subscribe to state at a URI. Returns the current state snapshot.
+     */
+    subscribe(resource: URI): Promise<IStateSnapshot>;
+    /**
+     * Unsubscribe from state at a URI.
+     */
+    unsubscribe(resource: URI): void;
+    /**
+     * Dispatch a client action to the server. Returns the clientSeq used.
+     */
+    dispatchAction(action: ISessionAction | ITerminalAction, _clientId: string, clientSeq: number): void;
+    /**
+     * Create a new session on the remote agent host.
+     */
+    createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
+    /**
+     * Authenticate with the remote agent host using a specific scheme.
+     */
+    authenticate(params: IAuthenticateParams): Promise<IAuthenticateResult>;
+    /**
+     * Gracefully shut down all sessions on the remote host.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Dispose a session on the remote agent host.
+     */
+    disposeSession(session: URI): Promise<void>;
+    /**
+     * Create a new terminal on the remote agent host.
+     */
+    createTerminal(params: ICreateTerminalParams): Promise<void>;
+    /**
+     * Dispose a terminal on the remote agent host.
+     */
+    disposeTerminal(terminal: URI): Promise<void>;
+    /**
+     * List all sessions from the remote agent host.
+     */
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    private _toLocalProjectUri;
+    /**
+     * List the contents of a directory on the remote host's filesystem.
+     */
+    resourceList(uri: URI): Promise<ICommandMap["resourceList"]["result"]>;
+    /**
+     * Read the content of a resource on the remote host.
+     */
+    resourceRead(uri: URI): Promise<ICommandMap["resourceRead"]["result"]>;
+    resourceWrite(params: ICommandMap["resourceWrite"]["params"]): Promise<ICommandMap["resourceWrite"]["result"]>;
+    resourceCopy(params: ICommandMap["resourceCopy"]["params"]): Promise<ICommandMap["resourceCopy"]["result"]>;
+    resourceDelete(params: ICommandMap["resourceDelete"]["params"]): Promise<ICommandMap["resourceDelete"]["result"]>;
+    resourceMove(params: ICommandMap["resourceMove"]["params"]): Promise<ICommandMap["resourceMove"]["result"]>;
+    private _handleMessage;
+    /**
+     * Handles reverse RPC requests from the server (e.g. resourceList,
+     * resourceRead). Reads from the local file service and sends a response.
+     */
+    private _handleReverseRequest;
+    /** Send a typed JSON-RPC notification for a protocol-defined method. */
+    private _sendNotification;
+    /** Send a typed JSON-RPC request for a protocol-defined method. */
+    private _sendRequest;
+    /** Send a JSON-RPC request for a VS Code extension method (not in the protocol spec). */
+    private _sendExtensionRequest;
+    /**
+     * Get the next client sequence number for optimistic dispatch.
+     */
+    nextClientSeq(): number;
+}

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

@@ -0,0 +1,393 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+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 { 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 { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { AgentSession } from '../common/agentService.js';
+import { AgentSubscriptionManager } from '../common/state/agentSubscription.js';
+import { agentHostAuthority, fromAgentHostUri, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { ROOT_STATE_URI } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState';
+import { PROTOCOL_VERSION } from '../common/state/sessionCapabilities.js';
+import { isJsonRpcRequest, isJsonRpcResponse, isJsonRpcNotification } from '../common/state/sessionProtocol.js';
+import { isClientTransport } from '../common/state/sessionTransport.js';
+import { AhpErrorCodes } from '../common/state/protocol/errors.js';
+import { ContentEncoding } from '../common/state/protocol/commands.js';
+import { decodeBase64, VSBuffer, encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+
+let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends Disposable {
+    get clientId() {
+        return this._clientId;
+    }
+    get address() {
+        return this._address;
+    }
+    get defaultDirectory() {
+        return this._defaultDirectory;
+    }
+    constructor(address, transport, _logService, _fileService) {
+        super();
+        this._logService = _logService;
+        this._fileService = _fileService;
+        this._clientId = generateUuid();
+        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._onDidClose = this._register(( new Emitter()));
+        this.onDidClose = this._onDidClose.event;
+        this._pendingRequests = ( new Map());
+        this._nextRequestId = 1;
+        this._address = address;
+        this._connectionAuthority = agentHostAuthority(address);
+        this._transport = transport;
+        this._register(this._transport);
+        this._register(this._transport.onMessage(msg => this._handleMessage(msg)));
+        this._register(this._transport.onClose(() => this._onDidClose.fire()));
+        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);
+        }));
+    }
+    async connect() {
+        if (isClientTransport(this._transport)) {
+            await this._transport.connect();
+        }
+        const result = await this._sendRequest("initialize", {
+            protocolVersion: PROTOCOL_VERSION,
+            clientId: this._clientId,
+            initialSubscriptions: [ROOT_STATE_URI]
+        });
+        this._serverSeq = result.serverSeq;
+        for (const snapshot of result.snapshots ?? []) {
+            if (snapshot.resource === ROOT_STATE_URI) {
+                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;
+            }
+        }
+    }
+    get rootState() {
+        return this._subscriptionManager.rootState;
+    }
+    getSubscription(kind, resource) {
+        return this._subscriptionManager.getSubscription(kind, resource);
+    }
+    getSubscriptionUnmanaged(_kind, resource) {
+        return this._subscriptionManager.getSubscriptionUnmanaged(resource);
+    }
+    dispatch(action) {
+        const seq = this._subscriptionManager.dispatchOptimistic(action);
+        this.dispatchAction(action, this._clientId, seq);
+    }
+    async subscribe(resource) {
+        const result = await this._sendRequest("subscribe", {
+            resource: ( resource.toString())
+        });
+        return result.snapshot;
+    }
+    unsubscribe(resource) {
+        this._sendNotification("unsubscribe", {
+            resource: ( resource.toString())
+        });
+    }
+    dispatchAction(action, _clientId, clientSeq) {
+        this._sendNotification("dispatchAction", {
+            clientSeq,
+            action
+        });
+    }
+    async createSession(config) {
+        const provider = config?.provider ?? "copilot";
+        const session = AgentSession.uri(provider, generateUuid());
+        await this._sendRequest("createSession", {
+            session: ( session.toString()),
+            provider,
+            model: config?.model,
+            workingDirectory: config?.workingDirectory ? ( fromAgentHostUri(config.workingDirectory).toString()) : undefined,
+            config: config?.config
+        });
+        return session;
+    }
+    async resolveSessionConfig(params) {
+        return this._sendRequest("resolveSessionConfig", {
+            provider: params.provider,
+            workingDirectory: params.workingDirectory ? ( fromAgentHostUri(params.workingDirectory).toString()) : undefined,
+            config: params.config
+        });
+    }
+    async sessionConfigCompletions(params) {
+        return this._sendRequest("sessionConfigCompletions", {
+            provider: params.provider,
+            workingDirectory: params.workingDirectory ? ( fromAgentHostUri(params.workingDirectory).toString()) : undefined,
+            config: params.config,
+            property: params.property,
+            query: params.query
+        });
+    }
+    async authenticate(params) {
+        await this._sendRequest("authenticate", params);
+        return {
+            authenticated: true
+        };
+    }
+    async shutdown() {
+        await this._sendExtensionRequest("shutdown");
+    }
+    async disposeSession(session) {
+        await this._sendRequest("disposeSession", {
+            session: ( session.toString())
+        });
+    }
+    async createTerminal(params) {
+        await this._sendRequest("createTerminal", params);
+    }
+    async disposeTerminal(terminal) {
+        await this._sendRequest("disposeTerminal", {
+            terminal: ( terminal.toString())
+        });
+    }
+    async listSessions() {
+        const result = await this._sendRequest("listSessions", {});
+        return ( result.items.map(s => ({
+            session: ( URI.parse(s.resource)),
+            startTime: s.createdAt,
+            modifiedTime: s.modifiedAt,
+            ...(s.project ? {
+                project: {
+                    uri: this._toLocalProjectUri(( URI.parse(s.project.uri))),
+                    displayName: s.project.displayName
+                }
+            } : {}),
+            summary: s.title,
+            status: s.status,
+            workingDirectory: typeof s.workingDirectory === "string" ? toAgentHostUri(( URI.parse(s.workingDirectory)), this._connectionAuthority) : undefined,
+            isRead: s.isRead,
+            isDone: s.isDone
+        })));
+    }
+    _toLocalProjectUri(uri) {
+        return uri.scheme === Schemas.file ? toAgentHostUri(uri, this._connectionAuthority) : uri;
+    }
+    async resourceList(uri) {
+        return await this._sendRequest("resourceList", {
+            uri: ( uri.toString())
+        });
+    }
+    async resourceRead(uri) {
+        return this._sendRequest("resourceRead", {
+            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);
+    }
+    _handleMessage(msg) {
+        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
+                })) {
+                    this._logService.warn(`[RemoteAgentHostProtocol] Request ${msg.id} failed:`, msg.error);
+                    pending.error(( new Error(msg.error.message)));
+                } else {
+                    pending.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 "notification":
+                {
+                    const notification = msg.params.notification;
+                    this._logService.trace(`[RemoteAgentHostProtocol] Notification: ${notification.type}`);
+                    this._onDidNotification.fire(notification);
+                    break;
+                }
+            default:
+                this._logService.trace(`[RemoteAgentHostProtocol] Unhandled method: ${msg.method}`);
+                break;
+            }
+        } else {
+            this._logService.warn(`[RemoteAgentHostProtocol] Unrecognized message:`, JSON.stringify(msg));
+        }
+    }
+    _handleReverseRequest(id, method, params) {
+        const sendResult = result => {
+            this._transport.send({
+                jsonrpc: "2.0",
+                id,
+                result
+            });
+        };
+        const sendError = err => {
+            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;
+            }
+            this._transport.send({
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code,
+                    message: err instanceof Error ? err.message : String(err)
+                }
+            });
+        };
+        const handle = fn => {
+            fn().then(sendResult, sendError);
+        };
+        const p = params;
+        switch (method) {
+        case "resourceList":
+            if (!p.uri) {
+                sendError(( new Error("Missing uri")));
+                return;
+            }
+            return handle(async () => {
+                const stat = await this._fileService.resolve(( URI.parse(p.uri)));
+                return {
+                    entries: ( (stat.children ?? []).map(c => ({
+                        name: c.name,
+                        type: c.isDirectory ? "directory" : "file"
+                    })))
+                };
+            });
+        case "resourceRead":
+            if (!p.uri) {
+                sendError(( new Error("Missing uri")));
+                return;
+            }
+            return handle(async () => {
+                const content = await this._fileService.readFile(( URI.parse(p.uri)));
+                return {
+                    data: encodeBase64(content.value),
+                    encoding: ContentEncoding.Base64
+                };
+            });
+        case "resourceWrite":
+            if (!p.uri || !p.data) {
+                sendError(( new Error("Missing uri or data")));
+                return;
+            }
+            return handle(async () => {
+                const writeUri = ( URI.parse(p.uri));
+                const buf = p.encoding === ContentEncoding.Base64 ? decodeBase64(p.data) : VSBuffer.fromString(p.data);
+                if (p.createOnly) {
+                    await this._fileService.createFile(writeUri, buf, {
+                        overwrite: false
+                    });
+                } else {
+                    await this._fileService.writeFile(writeUri, buf);
+                }
+                return {};
+            });
+        case "resourceDelete":
+            if (!p.uri) {
+                sendError(( new Error("Missing uri")));
+                return;
+            }
+            return handle(() => this._fileService.del(( URI.parse(p.uri)), {
+                recursive: !!p.recursive
+            }).then(() => ({})));
+        case "resourceMove":
+            if (!p.source || !p.destination) {
+                sendError(( new Error("Missing source or destination")));
+                return;
+            }
+            return handle(() => this._fileService.move(( URI.parse(p.source)), ( URI.parse(p.destination)), !p.failIfExists).then(() => ({})));
+        default:
+            this._logService.warn(`[RemoteAgentHostProtocol] Unhandled reverse request: ${method}`);
+            sendError(( new Error(`Unknown method: ${method}`)));
+        }
+    }
+    _sendNotification(method, params) {
+        this._transport.send({
+            jsonrpc: "2.0",
+            method,
+            params
+        });
+    }
+    _sendRequest(method, params) {
+        const id = this._nextRequestId++;
+        const deferred = ( new DeferredPromise());
+        this._pendingRequests.set(id, deferred);
+        this._transport.send({
+            jsonrpc: "2.0",
+            id,
+            method,
+            params
+        });
+        return deferred.p;
+    }
+    _sendExtensionRequest(method, params) {
+        const id = this._nextRequestId++;
+        const deferred = ( new DeferredPromise());
+        this._pendingRequests.set(id, deferred);
+        this._transport.send({
+            jsonrpc: "2.0",
+            id,
+            method,
+            params
+        });
+        return deferred.p;
+    }
+    nextClientSeq() {
+        return this._nextClientSeq++;
+    }
+};
+RemoteAgentHostProtocolClient = ( __decorate([( __param(2, ILogService)), ( __param(3, IFileService))], RemoteAgentHostProtocolClient));
+
+export { RemoteAgentHostProtocolClient };

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

@@ -0,0 +1,65 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 type { IAgentConnection } from "../common/agentService.js";
+import { type IRemoteAgentHostConnectionInfo, type IRemoteAgentHostEntry } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService";
+import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+export declare class RemoteAgentHostService extends Disposable implements IRemoteAgentHostService {
+    private readonly _configurationService;
+    private readonly _instantiationService;
+    private readonly _logService;
+    private static readonly ConnectionWaitTimeout;
+    /** Initial reconnect delay in milliseconds. */
+    private static readonly ReconnectInitialDelay;
+    /** Maximum reconnect delay in milliseconds. */
+    private static readonly ReconnectMaxDelay;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeConnections;
+    readonly onDidChangeConnections: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly _entries;
+    private readonly _names;
+    private readonly _tokens;
+    /**
+     * Stores the original {@link IRemoteAgentHostEntry} for connections
+     * registered via {@link addSSHConnection}. This is needed because
+     * tunnel entries are not persisted to settings and therefore don't
+     * appear in {@link configuredEntries}.
+     */
+    private readonly _registeredEntries;
+    private readonly _pendingConnectionWaits;
+    /** Pending reconnect timeouts, keyed by normalized address. */
+    private readonly _reconnectTimeouts;
+    /** Current reconnect attempt count per address for exponential backoff. */
+    private readonly _reconnectAttempts;
+    constructor(_configurationService: IConfigurationService, _instantiationService: IInstantiationService, _logService: ILogService);
+    get connections(): readonly IRemoteAgentHostConnectionInfo[];
+    get configuredEntries(): readonly IRemoteAgentHostEntry[];
+    getConnection(address: string): IAgentConnection | undefined;
+    getEntryByAddress(address: string): IRemoteAgentHostEntry | undefined;
+    reconnect(address: string): void;
+    addRemoteAgentHost(input: IRemoteAgentHostEntry): Promise<IRemoteAgentHostConnectionInfo>;
+    addSSHConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection): Promise<IRemoteAgentHostConnectionInfo>;
+    removeRemoteAgentHost(address: string): Promise<void>;
+    private _removeConnection;
+    private _reconcileConnections;
+    private _connectTo;
+    /**
+     * Schedule a reconnect attempt with exponential backoff.
+     * Only reconnects if the address is still in the configured entries.
+     */
+    private _scheduleReconnect;
+    /** Cancel a pending reconnect timeout for the given address. */
+    private _cancelReconnect;
+    /** Check whether the given normalized address is still in the configured entries. */
+    private _isAddressConfigured;
+    private _getConnectionInfo;
+    private _getConfiguredEntries;
+    private _upsertConfiguredEntry;
+    private _getConfigurationTarget;
+    private _storeConfiguredEntries;
+    private _getOrCreateConnectionWait;
+    private _resolvePendingConnectionWait;
+    private _rejectPendingConnectionWait;
+    dispose(): void;
+}