@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

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

@@ -10,27 +10,30 @@ 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { 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 { AgentHostPermissionMode } from '../common/agentHostPermissionService.js';
-import { IAgentHostPermissionService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostPermissionService.service';
-import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
-import '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications';
-import { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+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/errors.js';
-import { ReconnectResultType, ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands';
-import { decodeBase64, VSBuffer, encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+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 { AgentHostTelemetryLevelConfigKey, telemetryLevelToAgentHostConfigValue } from '../common/agentHostSchema.js';
-import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state';
+import { SESSION_SYNC_ENABLED_SETTING_ID, AgentHostTelemetryLevelConfigKey, telemetryLevelToAgentHostConfigValue, AgentHostSessionSyncEnabledConfigKey } from '../common/agentHostSchema.js';
+import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+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;
@@ -72,29 +75,31 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     get connectionState() {
         return this._state.kind;
     }
+    get initializeResult() {
+        return this._initializeResult;
+    }
     constructor(
         address,
         transportOrFactory,
         loadEstimator,
         _logService,
-        _fileService,
-        _permissionService,
+        _resourceService,
         _configurationService
     ) {
         super();
         this._logService = _logService;
-        this._fileService = _fileService;
-        this._permissionService = _permissionService;
+        this._resourceService = _resourceService;
         this._configurationService = _configurationService;
         this._clientId = generateUuid();
         this._transportListeners = this._register(( new MutableDisposable()));
         this._serverSeq = 0;
         this._nextClientSeq = 1;
-        this._completionTriggerCharacters = [];
         this._onDidAction = this._register(( new Emitter()));
         this.onDidAction = this._onDidAction.event;
         this._onDidNotification = this._register(( new Emitter()));
         this.onDidNotification = this._onDidNotification.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()));
@@ -135,6 +140,12 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                 }
                 this._updateTelemetryLevel();
             }
+            if (e.affectsConfiguration(SESSION_SYNC_ENABLED_SETTING_ID)) {
+                if (this._state.kind !== AgentHostClientState.Connected) {
+                    return;
+                }
+                this._updateSessionSyncEnabled();
+            }
         }));
         this._resetLivenessTimers();
     }
@@ -175,13 +186,14 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             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 (snapshot.resource === ROOT_STATE_URI) {
+            if (isAhpRootChannel(snapshot.resource)) {
                 this._subscriptionManager.handleRootSnapshot(snapshot.state, snapshot.fromSeq);
             }
         }
@@ -193,12 +205,16 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                 this._defaultDirectory = URI.revive(dir).path;
             }
         }
-        this._completionTriggerCharacters = result.completionTriggerCharacters ?? [];
+        this._initializeResult = result;
         this._updateTelemetryLevel();
+        this._updateSessionSyncEnabled();
         this._transitionTo({
             kind: AgentHostClientState.Connected
         });
     }
+    notifyTransportClosed() {
+        this._handleTransportClose();
+    }
     _handleTransportClose() {
         switch (this._state.kind) {
         case AgentHostClientState.Closed:
@@ -317,10 +333,8 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         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 && hasKey(envelope.action, {
-                    session: true
-                })) {
-                    this._subscriptionManager.dropPendingSessionAction(envelope.action.session, envelope.origin.clientSeq);
+                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;
@@ -337,7 +351,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         } else {
             let maxSeq = this._serverSeq;
             for (const snapshot of result.snapshots) {
-                this._subscriptionManager.applyReconnectSnapshot(( URI.parse(snapshot.resource)), snapshot.state, snapshot.fromSeq);
+                this._subscriptionManager.applyReconnectSnapshot(snapshot.resource, snapshot.state, snapshot.fromSeq);
                 if (snapshot.fromSeq > maxSeq) {
                     maxSeq = snapshot.fromSeq;
                 }
@@ -364,6 +378,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                 jsonrpc: "2.0",
                 method: "dispatchAction",
                 params: {
+                    channel: entry.sessionUri,
                     clientSeq: entry.clientSeq,
                     action: entry.action
                 }
@@ -384,30 +399,42 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     get rootState() {
         return this._subscriptionManager.rootState;
     }
-    getSubscription(kind, resource) {
-        return this._subscriptionManager.getSubscription(kind, resource);
+    getSubscription(kind, resource, owner) {
+        return this._subscriptionManager.getSubscription(kind, resource, owner);
     }
     getSubscriptionUnmanaged(_kind, resource) {
         return this._subscriptionManager.getSubscriptionUnmanaged(resource);
     }
-    dispatch(action) {
-        const seq = this._subscriptionManager.dispatchOptimistic(action);
-        this.dispatchAction(action, this._clientId, seq);
+    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", {
-            resource: ( resource.toString())
+            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", {
-            resource: ( resource.toString())
+            channel: ( resource.toString())
         });
     }
-    dispatchAction(action, _clientId, clientSeq) {
+    dispatchAction(channel, action, _clientId, clientSeq) {
         this._grantImplicitReadsForOutgoingAction(action);
         this._sendNotification("dispatchAction", {
+            channel,
             clientSeq,
             action
         });
@@ -422,7 +449,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             this._grantImplicitReadsForCustomizations(config.activeClient.customizations);
         }
         await this._sendRequest("createSession", {
-            session: ( session.toString()),
+            channel: ( session.toString()),
             provider,
             model: config?.model,
             workingDirectory: config?.workingDirectory ? ( fromAgentHostUri(config.workingDirectory).toString()) : undefined,
@@ -433,6 +460,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     }
     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
@@ -440,6 +468,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     }
     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,
@@ -451,13 +480,18 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         return this._sendRequest("completions", params);
     }
     async ping() {
-        await this._sendRequest("ping", {});
+        await this._sendRequest("ping", {
+            channel: ROOT_STATE_URI
+        });
     }
     async getCompletionTriggerCharacters() {
-        return this._completionTriggerCharacters;
+        return this._initializeResult?.completionTriggerCharacters ?? [];
     }
     async authenticate(params) {
-        await this._sendRequest("authenticate", params);
+        await this._sendRequest("authenticate", {
+            channel: ROOT_STATE_URI,
+            ...params
+        });
         return {
             authenticated: true
         };
@@ -467,7 +501,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     }
     async disposeSession(session) {
         await this._sendRequest("disposeSession", {
-            session: ( session.toString())
+            channel: ( session.toString())
         });
     }
     async createTerminal(params) {
@@ -475,11 +509,16 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     }
     async disposeTerminal(terminal) {
         await this._sendRequest("disposeTerminal", {
-            terminal: ( terminal.toString())
+            channel: ( terminal.toString())
         });
     }
+    async invokeChangesetOperation(params) {
+        return await this._sendRequest("invokeChangesetOperation", params);
+    }
     async listSessions() {
-        const result = await this._sendRequest("listSessions", {});
+        const result = await this._sendRequest("listSessions", {
+            channel: ROOT_STATE_URI
+        });
         return ( result.items.map(s => ({
             session: ( URI.parse(s.resource)),
             startTime: s.createdAt,
@@ -496,7 +535,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             workingDirectory: typeof s.workingDirectory === "string" ? toAgentHostUri(( URI.parse(s.workingDirectory)), this._connectionAuthority) : undefined,
             isRead: !!(s.status & SessionStatus.IsRead),
             isArchived: !!(s.status & SessionStatus.IsArchived),
-            diffs: s.diffs
+            changesets: s.changesets
         })));
     }
     _toLocalProjectUri(uri) {
@@ -515,21 +554,24 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             } catch {
                 continue;
             }
-            const key = ( uri.toString());
+            const grantUri = dirname(uri);
+            const key = ( grantUri.toString());
             if (( this._grantedCustomizationUris.has(key))) {
                 continue;
             }
             this._grantedCustomizationUris.add(key);
-            this._permissionService.grantImplicitRead(this._address, uri);
+            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())
         });
     }
@@ -545,6 +587,23 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     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, {});
     }
@@ -582,13 +641,24 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                     this._onDidAction.fire(envelope);
                     break;
                 }
-            case "notification":
+            case "root/sessionAdded":
+            case "root/sessionRemoved":
+            case "root/sessionSummaryChanged":
+            case "auth/required":
                 {
-                    const notification = msg.params.notification;
-                    this._logService.trace(`[RemoteAgentHostProtocol] Notification: ${notification.type}`);
-                    this._onDidNotification.fire(notification);
+                    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:
                 this._logService.trace(`[RemoteAgentHostProtocol] Unhandled method: ${msg.method}`);
                 break;
@@ -612,7 +682,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             }
         }
         this._rejectPendingRequests(error);
-        this._permissionService.connectionClosed(this._address);
+        this._resourceService.connectionClosed(this._address);
         this._grantedCustomizationUris.clear();
         this._transitionTo({
             kind: AgentHostClientState.Closed,
@@ -646,6 +716,20 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             });
         };
         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) {
@@ -668,157 +752,109 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                 }
             });
         };
-        const sendPermissionDenied = request => {
-            transport.send({
-                jsonrpc: "2.0",
-                id,
-                error: {
-                    code: AhpErrorCodes.PermissionDenied,
-                    message: request ? `Access to ${request.uri} is not granted.` : "Access to the requested resource is not granted.",
-                    data: request ? {
-                        request
-                    } : undefined
-                }
-            });
-        };
-        const gateAndHandle = async (uri, mode, deniedRequest, fn) => {
+        const p = (params ?? {});
+        const addr = this._address;
+        void (async () => {
             try {
-                if (!(await this._permissionService.check(this._address, uri, mode))) {
-                    sendPermissionDenied(deniedRequest);
-                    return;
-                }
-                sendResult(await fn());
-            } catch (err) {
-                sendError(err);
-            }
-        };
-        const p = params;
-        switch (method) {
-        case "resourceList":
-            {
-                if (!p.uri) {
-                    sendError(( new Error("Missing uri")));
-                    return;
-                }
-                const uri = ( URI.parse(p.uri));
-                return void gateAndHandle(uri, AgentHostPermissionMode.Read, {
-                    uri: ( uri.toString()),
-                    read: true
-                }, async () => {
-                    const stat = await this._fileService.resolve(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;
-                }
-                const uri = ( URI.parse(p.uri));
-                return void gateAndHandle(uri, AgentHostPermissionMode.Read, {
-                    uri: ( uri.toString()),
-                    read: true
-                }, async () => {
-                    const content = await this._fileService.readFile(uri);
-                    return {
-                        data: encodeBase64(content.value),
-                        encoding: ContentEncoding.Base64
-                    };
-                });
-            }
-        case "resourceWrite":
-            {
-                if (!p.uri || !p.data) {
-                    sendError(( new Error("Missing uri or data")));
-                    return;
-                }
-                const writeUri = ( URI.parse(p.uri));
-                return void gateAndHandle(writeUri, AgentHostPermissionMode.Write, {
-                    uri: ( writeUri.toString()),
-                    write: true
-                }, async () => {
-                    const buf = p.encoding === ContentEncoding.Base64 ? decodeBase64(p.data) : VSBuffer.fromString(p.data);
-                    if (p.createOnly) {
-                        await this._fileService.createFile(writeUri, buf, {
-                            overwrite: false
+                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
                         });
-                    } else {
-                        await this._fileService.writeFile(writeUri, buf);
+                        return;
                     }
-                    return {};
-                });
-            }
-        case "resourceDelete":
-            {
-                if (!p.uri) {
-                    sendError(( new Error("Missing uri")));
-                    return;
-                }
-                const deleteUri = ( URI.parse(p.uri));
-                return void gateAndHandle(deleteUri, AgentHostPermissionMode.Write, {
-                    uri: ( deleteUri.toString()),
-                    write: true
-                }, () => this._fileService.del(deleteUri, {
-                    recursive: !!p.recursive
-                }).then(() => ({})));
-            }
-        case "resourceMove":
-            {
-                if (!p.source || !p.destination) {
-                    sendError(( new Error("Missing source or destination")));
-                    return;
-                }
-                const sourceUri = ( URI.parse(p.source));
-                const destUri = ( URI.parse(p.destination));
-                return void (async () => {
-                    try {
-                        const [sourceOk, destOk] = await Promise.all([
-                            this._permissionService.check(this._address, sourceUri, AgentHostPermissionMode.Write),
-                            this._permissionService.check(this._address, destUri, AgentHostPermissionMode.Write)
-                        ]);
-                        if (!sourceOk) {
-                            sendPermissionDenied({
-                                uri: ( sourceUri.toString()),
-                                write: true
-                            });
-                            return;
+                case "resourceRead":
+                    {
+                        if (!p.uri) {
+                            throw ( new Error("Missing uri"));
                         }
-                        if (!destOk) {
-                            sendPermissionDenied({
-                                uri: ( destUri.toString()),
-                                write: true
-                            });
-                            return;
+                        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._fileService.move(sourceUri, destUri, !p.failIfExists);
+                        await this._resourceService.write(addr, p);
                         sendResult({});
-                    } catch (err) {
-                        sendError(err);
+                        return;
                     }
-                })();
-            }
-        case "resourceRequest":
-            {
-                const requestParams = p;
-                this._permissionService.request(this._address, requestParams).then(() => sendResult({})).catch(err => {
-                    if (err instanceof CancellationError) {
-                        sendPermissionDenied(undefined);
-                    } else {
-                        sendError(err);
+                case "resourceDelete":
+                    {
+                        if (!p.uri) {
+                            throw ( new Error("Missing uri"));
+                        }
+                        await this._resourceService.del(addr, p);
+                        sendResult({});
+                        return;
                     }
-                });
-                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);
             }
-        default:
-            this._logService.warn(`[RemoteAgentHostProtocol] Unhandled reverse request: ${method}`);
-            sendError(( new Error(`Unknown method: ${method}`)));
-        }
+        })();
     }
     _sendNotification(method, params) {
         if (this._state.kind === AgentHostClientState.Closed) {
@@ -842,13 +878,22 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         return this._dispatchRequest(method, params);
     }
     _updateTelemetryLevel() {
-        this.dispatchAction({
+        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);
+    }
     async _dispatchRequest(method, params, options = {}) {
         while (!options.bypassReconnectGate && this._state.kind === AgentHostClientState.Reconnecting) {
             const current = this._state;
@@ -927,6 +972,6 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         return this._nextClientSeq++;
     }
 };
-RemoteAgentHostProtocolClient = ( __decorate([( __param(3, ILogService)), ( __param(4, IFileService)), ( __param(5, IAgentHostPermissionService)), ( __param(6, IConfigurationService))], RemoteAgentHostProtocolClient));
+RemoteAgentHostProtocolClient = ( __decorate([( __param(3, ILogService)), ( __param(4, IAgentHostResourceService)), ( __param(5, IConfigurationService))], RemoteAgentHostProtocolClient));
 
 export { AgentHostClientState, RemoteAgentHostProtocolClient };