@codingame/monaco-vscode-chat-service-override 31.0.1 → 32.0.1

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

@@ -5,15 +5,23 @@ import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode
 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 { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { AgentHostAhpJsonlLoggingSettingId } from '../common/agentService.js';
 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 { normalizeRemoteAgentHostAddress, AGENT_HOST_LABEL_FORMATTER, agentHostAuthority, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { PROTOCOL_VERSION } from '../common/state/protocol/version/registry.js';
 
 var RemoteAgentHostService_1;
+function disposeEntry(entry) {
+    entry.store.dispose();
+    entry.transportDisposable?.dispose();
+}
 let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     static {
         RemoteAgentHostService_1 = this;
@@ -27,11 +35,19 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     static {
         this.ReconnectMaxDelay = 30000;
     }
-    constructor(_configurationService, _instantiationService, _logService) {
+    constructor(
+        _configurationService,
+        _instantiationService,
+        _logService,
+        _labelService,
+        _environmentService
+    ) {
         super();
         this._configurationService = _configurationService;
         this._instantiationService = _instantiationService;
         this._logService = _logService;
+        this._labelService = _labelService;
+        this._environmentService = _environmentService;
         this._onDidChangeConnections = this._register(( new Emitter()));
         this.onDidChangeConnections = this._onDidChangeConnections.event;
         this._entries = ( new Map());
@@ -41,6 +57,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         this._pendingConnectionWaits = ( new Map());
         this._reconnectTimeouts = ( new Map());
         this._reconnectAttempts = ( new Map());
+        this._labelFormatters = ( new Map());
         this._register(this._configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(RemoteAgentHostsSettingId) || e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
                 this._reconcileConnections();
@@ -129,7 +146,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
                 address,
                 name: entry.name,
                 clientId: "",
-                status: RemoteAgentHostConnectionStatus.Disconnected
+                status: RemoteAgentHostConnectionStatus.disconnected
             };
         }
         const connectedConnection = this._getConnectionInfo(address);
@@ -145,7 +162,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
         return connection;
     }
-    async addSSHConnection(entry, connection) {
+    async addManagedConnection(entry, connection, transportDisposable) {
         const address = getEntryAddress(entry);
         const existingEntry = this._entries.get(address);
         if (existingEntry) {
@@ -158,19 +175,21 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         const connEntry = {
             store,
             client: protocolClient,
+            transportDisposable,
             connected: true,
-            status: RemoteAgentHostConnectionStatus.Connected
+            status: RemoteAgentHostConnectionStatus.connected
         };
         this._entries.set(address, connEntry);
         this._names.set(address, entry.name);
         this._registeredEntries.set(address, entry);
+        this._updateHostLabelFormatter(address, entry.name);
         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;
+                connEntry.status = RemoteAgentHostConnectionStatus.disconnected;
                 this._onDidChangeConnections.fire();
             }
         }));
@@ -181,7 +200,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             name: entry.name,
             clientId: protocolClient.clientId,
             defaultDirectory: protocolClient.defaultDirectory,
-            status: RemoteAgentHostConnectionStatus.Connected
+            status: RemoteAgentHostConnectionStatus.connected
         };
     }
     async removeRemoteAgentHost(address) {
@@ -191,6 +210,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         this._names.delete(normalized);
         this._tokens.delete(normalized);
         this._registeredEntries.delete(normalized);
+        this._clearHostLabelFormatter(normalized);
         this._cancelReconnect(normalized);
         this._reconnectAttempts.delete(normalized);
         this._removeConnection(normalized);
@@ -199,7 +219,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         const entry = this._entries.get(address);
         if (entry) {
             this._entries.delete(address);
-            entry.store.dispose();
+            disposeEntry(entry);
             this._rejectPendingConnectionWait(address, ( new Error(`Connection closed: ${address}`)));
             this._onDidChangeConnections.fire();
         }
@@ -213,6 +233,11 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             this._names.clear();
             this._tokens.clear();
             this._reconnectAttempts.clear();
+            for (const address of [...( this._labelFormatters.keys())]) {
+                if (!( this._registeredEntries.has(address))) {
+                    this._clearHostLabelFormatter(address);
+                }
+            }
             return;
         }
         const rawEntries = ( (this._configurationService.getValue(RemoteAgentHostsSettingId) ?? []).map(rawEntryToEntry)).filter(isDefined);
@@ -234,10 +259,16 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         } of entriesWithAddress) {
             this._names.set(address, entry.name);
             this._tokens.set(address, entry.connectionToken);
+            this._updateHostLabelFormatter(address, entry.name);
             if (( this._entries.has(address)) && oldNames.get(address) !== entry.name) {
                 namesChanged = true;
             }
         }
+        for (const address of [...( this._labelFormatters.keys())]) {
+            if (!( desired.has(address)) && !( this._registeredEntries.has(address))) {
+                this._clearHostLabelFormatter(address);
+            }
+        }
         for (const address of [...( this._entries.keys())]) {
             if (!( desired.has(address))) {
                 this._logService.info(`[RemoteAgentHost] Disconnecting from ${address}`);
@@ -265,7 +296,14 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             existingEntry.store.dispose();
         }
         const store = ( new DisposableStore());
-        const transport = store.add(( new WebSocketClientTransport(address, connectionToken)));
+        const ahpLoggingEnabled = !!this._configurationService.getValue(AgentHostAhpJsonlLoggingSettingId);
+        const transport = store.add(
+            this._instantiationService.createInstance(WebSocketClientTransport, address, connectionToken, ahpLoggingEnabled ? {
+                logsHome: this._environmentService.logsHome,
+                connectionId: address,
+                transport: "websocket"
+            } : undefined)
+        );
         const client = store.add(
             this._instantiationService.createInstance(RemoteAgentHostProtocolClient, address, transport)
         );
@@ -273,7 +311,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             store,
             client,
             connected: false,
-            status: RemoteAgentHostConnectionStatus.Connecting
+            status: RemoteAgentHostConnectionStatus.connecting
         };
         this._entries.set(address, entry);
         const isCurrentEntry = () => this._entries.get(address) === entry;
@@ -283,7 +321,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             }
             this._logService.warn(`[RemoteAgentHost] Connection closed: ${address}`);
             entry.connected = false;
-            entry.status = RemoteAgentHostConnectionStatus.Disconnected;
+            entry.status = RemoteAgentHostConnectionStatus.disconnected;
             this._onDidChangeConnections.fire();
             this._scheduleReconnect(address, connectionToken);
         }));
@@ -295,7 +333,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             }
             this._logService.info(`[RemoteAgentHost] Connected to ${address}`);
             entry.connected = true;
-            entry.status = RemoteAgentHostConnectionStatus.Connected;
+            entry.status = RemoteAgentHostConnectionStatus.connected;
             this._reconnectAttempts.delete(address);
             this._resolvePendingConnectionWait(address);
             this._onDidChangeConnections.fire();
@@ -303,11 +341,22 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             if (!isCurrentEntry()) {
                 return;
             }
+            const incompatible = RemoteAgentHostConnectionStatus.fromConnectError(err, [PROTOCOL_VERSION]);
+            if (incompatible) {
+                this._logService.warn(
+                    `[RemoteAgentHost] Incompatible with ${address}: ${incompatible.kind === "incompatible" ? incompatible.message : ""}`
+                );
+                entry.status = incompatible;
+                this._reconnectAttempts.delete(address);
+                this._rejectPendingConnectionWait(address, err);
+                this._onDidChangeConnections.fire();
+                return;
+            }
             this._logService.error(
                 `[RemoteAgentHost] Failed to connect to ${address}. Verify address and connectionToken`,
                 err
             );
-            entry.status = RemoteAgentHostConnectionStatus.Disconnected;
+            entry.status = RemoteAgentHostConnectionStatus.disconnected;
             this._entries.delete(address);
             entry.store.dispose();
             this._rejectPendingConnectionWait(address, err);
@@ -351,7 +400,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     }
     _getConnectionInfo(address) {
         return this.connections.find(
-            connection => connection.address === address && connection.status === RemoteAgentHostConnectionStatus.Connected
+            connection => connection.address === address && RemoteAgentHostConnectionStatus.isConnected(connection.status)
         );
     }
     _getConfiguredEntries() {
@@ -431,6 +480,26 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         this._pendingConnectionWaits.delete(address);
         void wait.error(err);
     }
+    _updateHostLabelFormatter(address, name) {
+        this._clearHostLabelFormatter(address);
+        const handle = this._labelService.registerFormatter({
+            scheme: AGENT_HOST_SCHEME,
+            authority: agentHostAuthority(address),
+            priority: true,
+            formatting: {
+                ...AGENT_HOST_LABEL_FORMATTER.formatting,
+                workspaceSuffix: name
+            }
+        });
+        this._labelFormatters.set(address, handle);
+    }
+    _clearHostLabelFormatter(address) {
+        const existing = this._labelFormatters.get(address);
+        if (existing) {
+            existing.dispose();
+            this._labelFormatters.delete(address);
+        }
+    }
     dispose() {
         for (const timeout of ( this._reconnectTimeouts.values())) {
             clearTimeout(timeout);
@@ -442,12 +511,16 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
         this._pendingConnectionWaits.clear();
         for (const entry of ( this._entries.values())) {
-            entry.store.dispose();
+            disposeEntry(entry);
         }
         this._entries.clear();
+        for (const handle of ( this._labelFormatters.values())) {
+            handle.dispose();
+        }
+        this._labelFormatters.clear();
         super.dispose();
     }
 };
-RemoteAgentHostService = RemoteAgentHostService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService))], RemoteAgentHostService));
+RemoteAgentHostService = RemoteAgentHostService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService)), ( __param(3, ILabelService)), ( __param(4, IEnvironmentService))], RemoteAgentHostService));
 
 export { RemoteAgentHostService };

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

@@ -1,5 +1,7 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import type { IAhpServerNotification, IJsonRpcResponse, IProtocolMessage } from "../common/state/sessionProtocol.js";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IAhpJsonlLoggerOptions } from "../common/ahpJsonlLogger.js";
+import type { AhpServerNotification, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ProtocolMessage } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
 import type { IClientTransport } from "../common/state/sessionTransport.js";
 /**
  * A WebSocket client transport that connects to a remote agent host server.
@@ -8,21 +10,31 @@ import type { IClientTransport } from "../common/state/sessionTransport.js";
  */
 export declare class WebSocketClientTransport extends Disposable implements IClientTransport {
     private readonly _address;
-    private readonly _connectionToken?;
+    private readonly _connectionToken;
     private readonly _onMessage;
-    readonly onMessage: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<IProtocolMessage>;
+    readonly onMessage: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ProtocolMessage>;
     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;
+    private _malformedFrames;
+    /** Guards against firing onClose more than once. */
+    private _closeFired;
     get isOpen(): boolean;
-    constructor(_address: string, _connectionToken?: string | undefined);
+    private readonly _ahpLogger?;
+    constructor(_address: string, _connectionToken: string | undefined, ahpLogOptions: IAhpJsonlLoggerOptions | undefined, instantiationService: IInstantiationService);
     /**
      * Initiate the WebSocket connection. Resolves when the connection
      * is open, or rejects on error/timeout.
      */
     connect(): Promise<void>;
-    send(message: IProtocolMessage | IAhpServerNotification | IJsonRpcResponse): void;
+    /**
+     * Send a message to the remote end. Returns `true` if the message was
+     * sent, `false` if it was dropped (socket not open). On failure, the
+     * transport is force-closed so reconnection is triggered immediately
+     * rather than silently losing messages.
+     */
+    send(message: ProtocolMessage | AhpServerNotification | JsonRpcNotification | JsonRpcResponse | JsonRpcRequest): boolean;
     dispose(): void;
 }

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

@@ -1,13 +1,17 @@
 
+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 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { connectionTokenQueryName } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { AhpJsonlLogger, getAhpLogByteLength } from '../common/ahpJsonlLogger.js';
+import { MALFORMED_FRAMES_LOG_CAP, MALFORMED_FRAMES_FORCE_CLOSE_THRESHOLD } from '../common/transportConstants.js';
 
-class WebSocketClientTransport extends Disposable {
+let WebSocketClientTransport = class WebSocketClientTransport extends Disposable {
     get isOpen() {
         return this._ws?.readyState === WebSocket.OPEN;
     }
-    constructor(_address, _connectionToken) {
+    constructor(_address, _connectionToken, ahpLogOptions, instantiationService) {
         super();
         this._address = _address;
         this._connectionToken = _connectionToken;
@@ -17,6 +21,11 @@ class WebSocketClientTransport extends Disposable {
         this.onClose = this._onClose.event;
         this._onOpen = this._register(( new Emitter()));
         this.onOpen = this._onOpen.event;
+        this._malformedFrames = 0;
+        this._closeFired = false;
+        if (ahpLogOptions) {
+            this._ahpLogger = this._register(instantiationService.createInstance(AhpJsonlLogger, ahpLogOptions));
+        }
     }
     connect() {
         return ( new Promise((resolve, reject) => {
@@ -53,29 +62,83 @@ class WebSocketClientTransport extends Disposable {
             ws.addEventListener("error", onError);
             ws.addEventListener("close", onClose);
             ws.addEventListener("message", event => {
+                if (typeof event.data !== "string") {
+                    this._malformedFrames++;
+                    if (this._malformedFrames <= MALFORMED_FRAMES_LOG_CAP) {
+                        const dataType = event.data instanceof ArrayBuffer ? "ArrayBuffer" : event.data instanceof Blob ? "Blob" : typeof event.data;
+                        const byteLen = event.data instanceof ArrayBuffer ? event.data.byteLength : event.data instanceof Blob ? event.data.size : 0;
+                        console.warn(
+                            `[WebSocketClientTransport] Non-string frame #${this._malformedFrames} (type=${dataType}, bytes=${byteLen})`
+                        );
+                    }
+                    if (this._malformedFrames > MALFORMED_FRAMES_FORCE_CLOSE_THRESHOLD) {
+                        console.warn(
+                            `[WebSocketClientTransport] Malformed frame threshold exceeded; forcing close of ${this._address}.`
+                        );
+                        this._ws?.close(4002, "malformed-frames");
+                    }
+                    return;
+                }
+                const text = event.data;
+                let message;
                 try {
-                    const text = typeof event.data === "string" ? event.data : "";
-                    const message = JSON.parse(text);
-                    this._onMessage.fire(message);
-                } catch {}
+                    message = JSON.parse(text);
+                } catch (err) {
+                    this._malformedFrames++;
+                    if (this._malformedFrames <= MALFORMED_FRAMES_LOG_CAP) {
+                        const preview = text.length > 80 ? text.slice(0, 80) + "…" : text;
+                        console.warn(
+                            `[WebSocketClientTransport] Malformed frame #${this._malformedFrames} (len=${text.length}): ${preview}`,
+                            err instanceof Error ? err.message : String(err)
+                        );
+                    }
+                    if (this._malformedFrames > MALFORMED_FRAMES_FORCE_CLOSE_THRESHOLD) {
+                        console.warn(
+                            `[WebSocketClientTransport] Malformed frame threshold exceeded; forcing close of ${this._address}.`
+                        );
+                        this._ws?.close(4002, "malformed-frames");
+                    }
+                    return;
+                }
+                this._ahpLogger?.log(message, "s2c", getAhpLogByteLength(text));
+                this._onMessage.fire(message);
             });
             ws.addEventListener("close", () => {
-                this._onClose.fire();
+                if (!this._closeFired) {
+                    this._closeFired = true;
+                    this._onClose.fire();
+                }
             });
             ws.addEventListener("error", () => {
-                this._onClose.fire();
+                if (!this._closeFired) {
+                    this._closeFired = true;
+                    this._onClose.fire();
+                }
             });
         }));
     }
     send(message) {
         if (this._ws?.readyState === WebSocket.OPEN) {
-            this._ws.send(JSON.stringify(message));
+            const text = JSON.stringify(message);
+            this._ahpLogger?.log(message, "c2s", getAhpLogByteLength(text));
+            this._ws.send(text);
+            return true;
+        }
+        console.warn(
+            `[WebSocketClientTransport] Message dropped: readyState=${this._ws?.readyState ?? "no-socket"}`
+        );
+        this._ws?.close(4001, "send-on-dead-socket");
+        if (!this._closeFired) {
+            this._closeFired = true;
+            this._onClose.fire();
         }
+        return false;
     }
     dispose() {
         this._ws?.close();
         super.dispose();
     }
-}
+};
+WebSocketClientTransport = ( __decorate([( __param(3, IInstantiationService))], WebSocketClientTransport));
 
 export { WebSocketClientTransport };

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

@@ -1,7 +1,7 @@
 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";
+import { type ResourceDeleteParams, type ResourceDeleteResult, type ResourceListResult, type ResourceMoveParams, type ResourceMoveResult, type ResourceReadResult, type ResourceRequestParams, type ResourceRequestResult, type ResourceWriteParams, type ResourceWriteResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
 /**
  * Interface for performing resource operations on a remote endpoint.
  *
@@ -9,11 +9,17 @@ import { type IResourceDeleteParams, type IResourceDeleteResult, type IResourceL
  * 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>;
+    resourceList(uri: URI): Promise<ResourceListResult>;
+    resourceRead(uri: URI): Promise<ResourceReadResult>;
+    resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
+    resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
+    resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
+    /**
+     * Negotiate access to a resource the receiver mediates. Optional because
+     * not every connection in the codebase carries one — only the agent-host
+     * server-to-client direction needs to send `resourceRequest` today.
+     */
+    resourceRequest?(params: ResourceRequestParams): Promise<ResourceRequestResult>;
 }
 /**
  * Build a {@link AGENT_HOST_SCHEME} URI for a given connection authority
@@ -59,7 +65,27 @@ export declare abstract class AHPFileSystemProvider extends Disposable implement
     mkdir(): Promise<void>;
     delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
     rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    /**
+     * Negotiate access to {@link resource} with the receiver, asking for the
+     * granted modes in {@link opts}. Used after a `NoPermissions` failure to
+     * prompt the receiver to grant access; the caller can then retry.
+     *
+     * Resolves on success. Rejects if the receiver denies, the connection
+     * is missing, or the connection doesn't implement `resourceRequest`.
+     */
+    requestResourceAccess(resource: URI, opts: {
+        readonly read?: boolean;
+        readonly write?: boolean;
+    }): Promise<void>;
     private _getConnection;
+    /**
+     * Translate a thrown error from a {@link IRemoteFilesystemConnection}
+     * into a {@link FileSystemProviderError}. Preserves `PermissionDenied`
+     * (-32009) as `NoPermissions` so callers can distinguish a
+     * permission failure from `NotFound` and decide whether to negotiate
+     * via {@link requestResourceAccess}.
+     */
+    private _mapError;
     private _listDirectory;
 }
 /**

package/vscode/src/vs/platform/agentHost/common/agentHostFileSystemProvider.js

@@ -9,7 +9,9 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { FileSystemProviderCapabilities, FilePermission, FileType, createFileSystemProviderError, FileSystemProviderErrorCode } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { ContentEncoding } from './state/protocol/commands.js';
+import { ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands';
+import { AhpErrorCodes } from './state/protocol/errors.js';
+import { ProtocolError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
 
 class AHPFileSystemProvider extends Disposable {
     constructor() {
@@ -40,7 +42,7 @@ class AHPFileSystemProvider extends Disposable {
             };
         }
         const decoded = this._decodeUri(resource);
-        if (decoded.scheme === "session-db") {
+        if (decoded.scheme === "session-db" || decoded.scheme === "git-blob") {
             return {
                 type: FileType.File,
                 mtime: 0,
@@ -87,10 +89,7 @@ class AHPFileSystemProvider extends Disposable {
             }
             return VSBuffer.fromString(result.data).buffer;
         } catch (err) {
-            throw createFileSystemProviderError(
-                err instanceof Error ? err.message : String(err),
-                FileSystemProviderErrorCode.FileNotFound
-            );
+            throw this._mapError(err, FileSystemProviderErrorCode.FileNotFound);
         }
     }
     async writeFile(resource, content, _opts) {
@@ -103,10 +102,7 @@ class AHPFileSystemProvider extends Disposable {
                 encoding: ContentEncoding.Utf8
             });
         } catch (err) {
-            throw createFileSystemProviderError(
-                err instanceof Error ? err.message : String(err),
-                FileSystemProviderErrorCode.NoPermissions
-            );
+            throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
         }
     }
     async mkdir() {
@@ -124,10 +120,7 @@ class AHPFileSystemProvider extends Disposable {
                 recursive: opts.recursive
             });
         } catch (err) {
-            throw createFileSystemProviderError(
-                err instanceof Error ? err.message : String(err),
-                FileSystemProviderErrorCode.NoPermissions
-            );
+            throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
         }
     }
     async rename(from, to, opts) {
@@ -141,11 +134,27 @@ class AHPFileSystemProvider extends Disposable {
                 failIfExists: !opts.overwrite
             });
         } catch (err) {
+            throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
+        }
+    }
+    async requestResourceAccess(resource, opts) {
+        const connection = this._getConnection(resource.authority);
+        if (!connection.resourceRequest) {
             throw createFileSystemProviderError(
-                err instanceof Error ? err.message : String(err),
-                FileSystemProviderErrorCode.NoPermissions
+                `Connection for ${resource.authority} does not support resourceRequest`,
+                FileSystemProviderErrorCode.Unavailable
             );
         }
+        const originalUri = this._decodeUri(resource);
+        try {
+            await connection.resourceRequest({
+                uri: ( originalUri.toString()),
+                read: opts.read,
+                write: opts.write
+            });
+        } catch (err) {
+            throw this._mapError(err, FileSystemProviderErrorCode.NoPermissions);
+        }
     }
     _getConnection(authority) {
         const connection = this._authorityToConnection.get(authority);
@@ -157,6 +166,12 @@ class AHPFileSystemProvider extends Disposable {
         }
         return connection;
     }
+    _mapError(err, defaultCode) {
+        if (err instanceof ProtocolError && err.code === AhpErrorCodes.PermissionDenied) {
+            return createFileSystemProviderError(err.message, FileSystemProviderErrorCode.NoPermissions);
+        }
+        return createFileSystemProviderError(err instanceof Error ? err.message : String(err), defaultCode);
+    }
     async _listDirectory(authority, resource) {
         const connection = this._getConnection(authority);
         try {
@@ -164,10 +179,7 @@ class AHPFileSystemProvider extends Disposable {
             const result = await connection.resourceList(originalUri);
             return result.entries;
         } catch (err) {
-            throw createFileSystemProviderError(
-                err instanceof Error ? err.message : String(err),
-                FileSystemProviderErrorCode.Unavailable
-            );
+            throw this._mapError(err, FileSystemProviderErrorCode.Unavailable);
         }
     }
 }

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

@@ -0,0 +1,37 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/** Configuration key for persisted per-host filesystem grants. */
+export declare const AgentHostLocalFilePermissionsSettingId = "chat.agentHost.localFilePermissions";
+/** Persisted access mode for a granted URI. */
+export declare enum AgentHostAccessMode {
+    Read = "r",
+    ReadWrite = "rw"
+}
+/**
+ * Persisted shape of {@link AgentHostLocalFilePermissionsSettingId}:
+ * `{ [normalizedAddress]: { [uriString]: 'r' | 'rw' } }`.
+ */
+export type AgentHostPermissionsSetting = Record<string, Record<string, AgentHostAccessMode>>;
+/**
+ * Capability a request needs from the user. The protocol-level `read` and
+ * `write` flags are split into one or two of these requests.
+ */
+export declare enum AgentHostPermissionMode {
+    Read = "read",
+    Write = "write"
+}
+/** A single pending permission request awaiting user input. */
+export interface IPendingResourceRequest {
+    readonly id: string;
+    readonly address: string;
+    readonly uri: URI;
+    readonly mode: AgentHostPermissionMode;
+    /** Approve and remember the grant in user settings. */
+    allowAlways(): void;
+    /**
+     * Approve the request and remember it in memory for the lifetime of the
+     * connection (cleared on connection close or window reload).
+     */
+    allow(): void;
+    /** Reject this request. */
+    deny(): void;
+}

package/vscode/src/vs/platform/agentHost/common/agentHostPermissionService.js

@@ -0,0 +1,15 @@
+
+
+const AgentHostLocalFilePermissionsSettingId = 'chat.agentHost.localFilePermissions';
+var AgentHostAccessMode;
+(function (AgentHostAccessMode) {
+    AgentHostAccessMode["Read"] = "r";
+    AgentHostAccessMode["ReadWrite"] = "rw";
+})(AgentHostAccessMode || (AgentHostAccessMode = {}));
+var AgentHostPermissionMode;
+(function (AgentHostPermissionMode) {
+    AgentHostPermissionMode["Read"] = "read";
+    AgentHostPermissionMode["Write"] = "write";
+})(AgentHostPermissionMode || (AgentHostPermissionMode = {}));
+
+export { AgentHostAccessMode, AgentHostLocalFilePermissionsSettingId, AgentHostPermissionMode };