@codingame/monaco-vscode-chat-service-override 33.0.8 → 34.0.0

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

@@ -6,7 +6,7 @@ import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/l
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.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 { RemoteAgentHostConnectionStatus, 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";
 import { type IVscodeUpgradeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocolUpgrade";
 export declare class RemoteAgentHostService extends Disposable implements IRemoteAgentHostService {
@@ -60,9 +60,10 @@ export declare class RemoteAgentHostService extends Disposable implements IRemot
     triggerServerUpgrade(address: string, method: string): Promise<IVscodeUpgradeResult>;
     reconnect(address: string): void;
     addRemoteAgentHost(input: IRemoteAgentHostEntry): Promise<IRemoteAgentHostConnectionInfo>;
-    addManagedConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection, transportDisposable?: IDisposable): Promise<IRemoteAgentHostConnectionInfo>;
+    addManagedConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection, transportDisposable?: IDisposable, status?: RemoteAgentHostConnectionStatus): Promise<IRemoteAgentHostConnectionInfo>;
     removeRemoteAgentHost(address: string): Promise<void>;
     private _removeConnection;
+    notifyConnectionClosed(address: string): void;
     private _reconcileConnections;
     private _connectTo;
     /**

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

@@ -201,7 +201,12 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
         return connection;
     }
-    async addManagedConnection(entry, connection, transportDisposable) {
+    async addManagedConnection(
+        entry,
+        connection,
+        transportDisposable,
+        status = RemoteAgentHostConnectionStatus.connected
+    ) {
         if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
             throw ( new Error("Remote agent host connections are not enabled."));
         }
@@ -218,8 +223,8 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             store,
             client: protocolClient,
             transportDisposable,
-            connected: true,
-            status: RemoteAgentHostConnectionStatus.connected
+            connected: RemoteAgentHostConnectionStatus.isConnected(status),
+            status
         };
         this._entries.set(address, connEntry);
         this._names.set(address, entry.name);
@@ -242,7 +247,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             name: entry.name,
             clientId: protocolClient.clientId,
             defaultDirectory: protocolClient.defaultDirectory,
-            status: RemoteAgentHostConnectionStatus.connected
+            status
         };
     }
     async removeRemoteAgentHost(address) {
@@ -266,6 +271,20 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             this._onDidChangeConnections.fire();
         }
     }
+    notifyConnectionClosed(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        const entry = this._entries.get(normalized);
+        if (entry) {
+            this._logService.info(
+                `[RemoteAgentHost] notifyConnectionClosed: notifying protocol client for ${normalized}`
+            );
+            entry.client.notifyTransportClosed();
+        } else {
+            this._logService.info(
+                `[RemoteAgentHost] notifyConnectionClosed: no entry found for ${normalized} (already removed?)`
+            );
+        }
+    }
     _reconcileConnections() {
         if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
             for (const address of [...( this._entries.keys())]) {

package/vscode/src/vs/platform/agentHost/common/agentHost.config.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/platform/agentHost/common/agentHost.config.contribution.js

@@ -0,0 +1,22 @@
+
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { AgentHostEnabledSettingId } from './agentService.js';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "chatAgentHost",
+    title: ( localize(1822, "Chat Agent Host")),
+    type: "object",
+    properties: {
+        [AgentHostEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(1823, "When enabled, some agents run in a separate agent host process.")),
+            default: !isWeb && product.quality !== "stable",
+            tags: ["experimental", "advanced"]
+        }
+    }
+});

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

@@ -1,7 +1,8 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 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 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";
+import { FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, IFileWriteOptions, IStat, IWatchOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
+import { type CreateResourceWatchParams, type ResourceCopyParams, type ResourceCopyResult, type ResourceDeleteParams, type ResourceDeleteResult, type ResourceListResult, type ResourceMkdirParams, type ResourceMkdirResult, type ResourceMoveParams, type ResourceMoveResult, type ResourceReadResult, type ResourceRequestParams, type ResourceRequestResult, type ResourceResolveParams, type ResourceResolveResult, 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.
  *
@@ -14,13 +15,68 @@ export interface IRemoteFilesystemConnection {
     resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
     resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
     resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
+    /** Copy a resource on the remote endpoint. */
+    resourceCopy(params: ResourceCopyParams): Promise<ResourceCopyResult>;
     /**
      * 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>;
+    /** Resolve (stat + realpath) a resource on the remote endpoint. */
+    resourceResolve(params: ResourceResolveParams): Promise<ResourceResolveResult>;
+    /** Create a directory on the remote endpoint (mkdir -p semantics). */
+    resourceMkdir(params: ResourceMkdirParams): Promise<ResourceMkdirResult>;
+    /**
+     * Start a file-system watcher on the remote endpoint and return a
+     * handle whose `onDidChange` event fires for every change the remote
+     * reports under the watched root. Disposing the handle unsubscribes
+     * the watch (subject to the receiver's grace window).
+     *
+     * Optional: implementations that do not have access to the AHP
+     * subscription machinery (e.g. raw IPC channels in
+     * {@link createAgentHostClientResourceConnection}) omit it; the FS
+     * provider degrades to a no-op `watch()` in that case.
+     */
+    watchResource?(params: CreateResourceWatchParams): Promise<IRemoteWatchHandle>;
+}
+/**
+ * Handle for a remote file-system watcher returned by
+ * {@link IRemoteFilesystemConnection.watchResource}. Mirrors the shape
+ * of `IFileSystemWatcher` from `../../files/common/files.js` so the FS
+ * provider can plug events straight into its own `onDidChangeFile`
+ * emitter.
+ */
+export interface IRemoteWatchHandle extends IDisposable {
+    readonly onDidChange: Event<readonly IFileChange[]>;
 }
+/**
+ * Shared implementation of {@link IAgentConnection.watchResource} —
+ * bundles `createResourceWatch` + `subscribe` + a per-channel listener
+ * on the action stream into an {@link IRemoteWatchHandle}. Used by
+ * every transport that exposes those four primitives so we don't need
+ * to duplicate the wire bookkeeping in each `IAgentConnection`
+ * implementation.
+ */
+export declare function createRemoteWatchHandle(primitives: {
+    createResourceWatch(params: CreateResourceWatchParams): Promise<{
+        channel: string;
+    }>;
+    subscribe(channel: URI): Promise<unknown>;
+    unsubscribe(channel: URI): void;
+    onDidAction: Event<{
+        channel: string;
+        action: {
+            type: string;
+            changes?: {
+                items: readonly {
+                    uri: string;
+                    type: string;
+                }[];
+            };
+        };
+    }>;
+}, params: CreateResourceWatchParams): Promise<IRemoteWatchHandle>;
 /**
  * Build a {@link AGENT_HOST_SCHEME} URI for a given connection authority
  * and remote path. Assumes the remote path is a `file://` resource.
@@ -41,20 +97,61 @@ export declare function agentHostRemotePath(uri: URI): string;
  * Individual connections are identified by the URI's authority component.
  */
 export declare abstract class AHPFileSystemProvider extends Disposable implements IFileSystemProvider {
+    private readonly _connectionGraceMs;
     readonly capabilities: number;
     private readonly _onDidChangeCapabilities;
-    readonly onDidChangeCapabilities: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    readonly onDidChangeCapabilities: Event<void>;
     private readonly _onDidChangeFile;
-    readonly onDidChangeFile: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<readonly IFileChange[]>;
-    private readonly _authorityToConnection;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    private readonly _onDidWatchError;
+    readonly onDidWatchError: Event<string>;
+    /**
+     * Per-authority registration slot. We keep the slot alive for a brief
+     * grace period after the last registration is disposed, so an
+     * operation issued during a reconnection window can wait for the
+     * replacement registration instead of failing immediately.
+     */
+    private readonly _authorities;
+    /**
+     * Fires the authority whose active connection has changed: added,
+     * replaced, fallen back to an older registration, entered the grace
+     * window (no active connection), or evicted. Long-lived consumers
+     * (e.g. {@link watch}) subscribe here so they continue to receive
+     * notifications across full entry eviction + later re-creation —
+     * something a per-entry emitter cannot offer.
+     */
+    private readonly _onDidChangeConnection;
+    /**
+     * Grace period during which {@link _getConnection} will await a new
+     * registration after the previous one is disposed. Covers the window
+     * where a transport is briefly torn down and re-registered (e.g. an
+     * agent-host client reconnect that races a plugin sync). 5s matches
+     * the typical reconnect timeout. Consumers should still implement
+     * logical retries for longer reconnection latencies, but this is a
+     * low level, best-effort mechanism.
+     *
+     * Tests can override this via the constructor parameter.
+     */
+    private static readonly _DEFAULT_CONNECTION_GRACE_MS;
+    constructor(_connectionGraceMs?: number);
     /**
      * Register a mapping from a URI authority to a connection.
-     * Returns a disposable that unregisters the mapping.
+     * Returns a disposable that unregisters the mapping. Multiple
+     * concurrent registrations for the same authority are supported;
+     * the most recent registration wins, and disposing it falls back to
+     * the previous one (if any). After the *last* registration is
+     * disposed the entry is held open for {@link _connectionGraceMs} so
+     * that a reconnect can replace it without orphaning in-flight
+     * operations.
      */
     registerAuthority(authority: string, connection: IRemoteFilesystemConnection): IDisposable;
+    private _expireAuthority;
+    dispose(): void;
     /** Decode a provider URI back to the original URI for the remote endpoint. */
     protected abstract _decodeUri(resource: URI): URI;
-    watch(): IDisposable;
+    /** Encode a remote URI back into a provider URI with the given authority. */
+    protected abstract _encodeUri(resource: URI, authority: string): URI;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
     stat(resource: URI): Promise<IStat>;
     readdir(resource: URI): Promise<[
         string,
@@ -62,9 +159,10 @@ export declare abstract class AHPFileSystemProvider extends Disposable implement
     ][]>;
     readFile(resource: URI): Promise<Uint8Array>;
     writeFile(resource: URI, content: Uint8Array, _opts: IFileWriteOptions): Promise<void>;
-    mkdir(): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
     delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
     rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    copy(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
@@ -98,4 +196,5 @@ export declare abstract class AHPFileSystemProvider extends Disposable implement
  */
 export declare class AgentHostFileSystemProvider extends AHPFileSystemProvider {
     protected _decodeUri(resource: URI): URI;
+    protected _encodeUri(resource: URI, authority: string): URI;
 }