@codingame/monaco-vscode-mcp-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSandboxService.js

@@ -0,0 +1,385 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { win32, posix, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { OperatingSystem, OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ConfigurationTarget, ConfigurationTargetToString } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IMcpResourceScannerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpResourceScannerService.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { McpServerTransportType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+
+let McpSandboxService = class McpSandboxService extends Disposable {
+    constructor(
+        _fileService,
+        _environmentService,
+        _logService,
+        _mcpResourceScannerService,
+        _remoteAgentService
+    ) {
+        super();
+        this._fileService = _fileService;
+        this._environmentService = _environmentService;
+        this._logService = _logService;
+        this._mcpResourceScannerService = _mcpResourceScannerService;
+        this._remoteAgentService = _remoteAgentService;
+        this._defaultAllowedDomains = ["registry.npmjs.org"];
+        this._sandboxConfigPerConfigurationTarget = ( new Map());
+        this._pathJoin = (os, ...segments) => {
+            const path = os === OperatingSystem.Windows ? win32 : posix;
+            return path.join(...segments);
+        };
+        this._getPathDelimiter = async remoteAuthority => {
+            const os = await this._getOperatingSystem(remoteAuthority);
+            return os === OperatingSystem.Windows ? win32.delimiter : posix.delimiter;
+        };
+        this._sandboxSettingsId = generateUuid();
+        this._remoteEnvDetailsPromise = this._remoteAgentService.getEnvironment();
+    }
+    async isEnabled(serverDef, remoteAuthority) {
+        const os = await this._getOperatingSystem(remoteAuthority);
+        if (os === OperatingSystem.Windows) {
+            return false;
+        }
+        return !!serverDef.sandboxEnabled;
+    }
+    async launchInSandboxIfEnabled(serverDef, launch, remoteAuthority, configTarget) {
+        if (launch.type !== McpServerTransportType.Stdio) {
+            return launch;
+        }
+        if (await this.isEnabled(serverDef, remoteAuthority)) {
+            this._logService.trace(`McpSandboxService: Launching with config target ${configTarget}`);
+            const launchDetails = await this._resolveSandboxLaunchDetails(configTarget, remoteAuthority, launch.sandbox, launch.cwd);
+            const sandboxArgs = this._getSandboxCommandArgs(launch.command, launch.args, launchDetails.sandboxConfigPath);
+            const sandboxEnv = await this._getSandboxEnvVariables(launch.env, launchDetails.tempDir, launchDetails.rgPath, remoteAuthority);
+            if (launchDetails.srtPath) {
+                if (launchDetails.execPath) {
+                    return {
+                        ...launch,
+                        command: launchDetails.execPath,
+                        args: [launchDetails.srtPath, ...sandboxArgs],
+                        env: sandboxEnv,
+                        type: McpServerTransportType.Stdio
+                    };
+                } else {
+                    return {
+                        ...launch,
+                        command: launchDetails.srtPath,
+                        args: sandboxArgs,
+                        env: sandboxEnv,
+                        type: McpServerTransportType.Stdio
+                    };
+                }
+            }
+            if (!launchDetails.execPath) {
+                this._logService.warn(
+                    "McpSandboxService: execPath is unavailable, launching without sandbox runtime wrapper"
+                );
+            }
+            this._logService.debug(
+                `McpSandboxService: launch details for server ${serverDef.label} - command: ${launch.command}, args: ${launch.args.join(" ")}`
+            );
+        }
+        return launch;
+    }
+    getSandboxConfigSuggestionMessage(serverLabel, potentialBlocks, existingSandboxConfig) {
+        const suggestions = this._getSandboxConfigSuggestions(potentialBlocks, existingSandboxConfig);
+        if (!suggestions) {
+            return undefined;
+        }
+        const allowWriteList = suggestions.allowWrite;
+        const allowedDomainsList = suggestions.allowedDomains;
+        const suggestionLines = [];
+        if (allowedDomainsList.length) {
+            const shown = ( allowedDomainsList.map(domain => `"${domain}"`)).join(", ");
+            suggestionLines.push(( localize(10452, "Add to `sandbox.network.allowedDomains`: {0}", shown)));
+        }
+        if (allowWriteList.length) {
+            const shown = ( allowWriteList.map(path => `"${path}"`)).join(", ");
+            suggestionLines.push(( localize(10453, "Add to `sandbox.filesystem.allowWrite`: {0}", shown)));
+        }
+        const sandboxConfig = {};
+        if (allowedDomainsList.length) {
+            sandboxConfig.network = {
+                allowedDomains: [...allowedDomainsList]
+            };
+        }
+        if (allowWriteList.length) {
+            sandboxConfig.filesystem = {
+                allowWrite: [...allowWriteList]
+            };
+        }
+        return {
+            message: ( localize(
+                10454,
+                "The MCP server {0} reported potential sandbox blocks. VS Code found possible sandbox configuration updates:\n{1}",
+                serverLabel,
+                suggestionLines.join("\n")
+            )),
+            sandboxConfig
+        };
+    }
+    async applySandboxConfigSuggestion(
+        serverDef,
+        mcpResource,
+        configTarget,
+        potentialBlocks,
+        suggestedSandboxConfig
+    ) {
+        const scanTarget = this._toMcpResourceTarget(configTarget);
+        let didChange = false;
+        await this._mcpResourceScannerService.updateSandboxConfig(data => {
+            const existingSandbox = data.sandbox;
+            const suggestedAllowedDomains = suggestedSandboxConfig?.network?.allowedDomains ?? [];
+            const suggestedAllowWrite = suggestedSandboxConfig?.filesystem?.allowWrite ?? [];
+            const currentAllowedDomains = ( new Set(existingSandbox?.network?.allowedDomains ?? []));
+            for (const domain of suggestedAllowedDomains) {
+                if (domain && !( currentAllowedDomains.has(domain))) {
+                    currentAllowedDomains.add(domain);
+                }
+            }
+            const currentAllowWrite = ( new Set(existingSandbox?.filesystem?.allowWrite ?? []));
+            for (const path of suggestedAllowWrite) {
+                if (path && !( currentAllowWrite.has(path))) {
+                    currentAllowWrite.add(path);
+                }
+            }
+            if (suggestedAllowedDomains.length === 0 && suggestedAllowWrite.length === 0) {
+                return data;
+            }
+            didChange = true;
+            const nextSandboxConfig = {};
+            if (currentAllowedDomains.size > 0) {
+                nextSandboxConfig.network = {
+                    ...existingSandbox?.network,
+                    allowedDomains: [...currentAllowedDomains]
+                };
+            }
+            if (currentAllowWrite.size > 0) {
+                nextSandboxConfig.filesystem = {
+                    ...existingSandbox?.filesystem,
+                    allowWrite: [...currentAllowWrite]
+                };
+            }
+            return {
+                ...data,
+                sandbox: nextSandboxConfig
+            };
+        }, mcpResource, scanTarget);
+        return didChange;
+    }
+    _getSandboxConfigSuggestions(potentialBlocks, existingSandboxConfig) {
+        if (!potentialBlocks.length) {
+            return undefined;
+        }
+        const allowWrite = ( new Set());
+        const allowedDomains = ( new Set());
+        const existingAllowWrite = ( new Set(existingSandboxConfig?.filesystem?.allowWrite ?? []));
+        const existingAllowedDomains = ( new Set(existingSandboxConfig?.network?.allowedDomains ?? []));
+        for (const block of potentialBlocks) {
+            if (block.kind === "network" && block.host && !( existingAllowedDomains.has(block.host))) {
+                allowedDomains.add(block.host);
+            }
+            if (block.kind === "filesystem" && block.path && !( existingAllowWrite.has(block.path))) {
+                allowWrite.add(block.path);
+            }
+        }
+        if (!allowWrite.size && !allowedDomains.size) {
+            return undefined;
+        }
+        return {
+            allowWrite: [...allowWrite],
+            allowedDomains: [...allowedDomains]
+        };
+    }
+    _toMcpResourceTarget(configTarget) {
+        switch (configTarget) {
+        case ConfigurationTarget.USER:
+        case ConfigurationTarget.USER_LOCAL:
+        case ConfigurationTarget.USER_REMOTE:
+            return ConfigurationTarget.USER;
+        case ConfigurationTarget.WORKSPACE:
+            return ConfigurationTarget.WORKSPACE;
+        case ConfigurationTarget.WORKSPACE_FOLDER:
+            return ConfigurationTarget.WORKSPACE_FOLDER;
+        default:
+            return ConfigurationTarget.USER;
+        }
+    }
+    async _resolveSandboxLaunchDetails(configTarget, remoteAuthority, sandboxConfig, launchCwd) {
+        const os = await this._getOperatingSystem(remoteAuthority);
+        if (os === OperatingSystem.Windows) {
+            return {
+                execPath: undefined,
+                srtPath: undefined,
+                rgPath: undefined,
+                sandboxConfigPath: undefined,
+                tempDir: undefined
+            };
+        }
+        const appRoot = await this._getAppRoot(remoteAuthority);
+        const execPath = await this._getExecPath(os, appRoot, remoteAuthority);
+        const tempDir = await this._getTempDir(remoteAuthority);
+        const srtPath = this._pathJoin(
+            os,
+            appRoot,
+            "node_modules",
+            "@anthropic-ai",
+            "sandbox-runtime",
+            "dist",
+            "cli.js"
+        );
+        const rgPath = this._pathJoin(os, appRoot, "node_modules", "@vscode", "ripgrep", "bin", "rg");
+        const sandboxConfigPath = tempDir ? await this._updateSandboxConfig(tempDir, configTarget, sandboxConfig, launchCwd) : undefined;
+        this._logService.debug(`McpSandboxService: Updated sandbox config path: ${sandboxConfigPath}`);
+        return {
+            execPath,
+            srtPath,
+            rgPath,
+            sandboxConfigPath,
+            tempDir
+        };
+    }
+    async _getExecPath(os, appRoot, remoteAuthority) {
+        if (remoteAuthority) {
+            return this._pathJoin(os, appRoot, "node");
+        }
+        return undefined;
+    }
+    async _getSandboxEnvVariables(baseEnv, tempDir, rgPath, remoteAuthority) {
+        let env = {
+            ...baseEnv
+        };
+        if (tempDir) {
+            env = {
+                ...env,
+                TMPDIR: tempDir.path,
+                SRT_DEBUG: "true"
+            };
+        }
+        if (rgPath) {
+            env = {
+                ...env,
+                PATH: env["PATH"] ? `${env["PATH"]}${await this._getPathDelimiter(remoteAuthority)}${dirname(rgPath)}` : dirname(rgPath)
+            };
+        }
+        if (!remoteAuthority) {
+            env = {
+                ...env,
+                ELECTRON_RUN_AS_NODE: "1"
+            };
+        }
+        env["VSCODE_INSPECTOR_OPTIONS"] = null;
+        return env;
+    }
+    _getSandboxCommandArgs(command, args, sandboxConfigPath) {
+        const result = [];
+        if (sandboxConfigPath) {
+            result.push("--settings", sandboxConfigPath);
+        }
+        result.push(command, ...args);
+        return result;
+    }
+    async _getRemoteEnv(remoteAuthority) {
+        if (!remoteAuthority) {
+            return null;
+        }
+        return this._remoteEnvDetailsPromise;
+    }
+    async _getOperatingSystem(remoteAuthority) {
+        const remoteEnv = await this._getRemoteEnv(remoteAuthority);
+        if (remoteEnv) {
+            return remoteEnv.os;
+        }
+        return OS;
+    }
+    async _getAppRoot(remoteAuthority) {
+        const remoteEnv = await this._getRemoteEnv(remoteAuthority);
+        if (remoteEnv) {
+            return remoteEnv.appRoot.path;
+        }
+        return dirname(( FileAccess.asFileUri("")).path);
+    }
+    async _getTempDir(remoteAuthority) {
+        const remoteEnv = await this._getRemoteEnv(remoteAuthority);
+        if (remoteEnv) {
+            return remoteEnv.tmpDir;
+        }
+        const environmentService = this._environmentService;
+        const tempDir = environmentService.tmpDir;
+        if (!tempDir) {
+            this._logService.warn(
+                "McpSandboxService: Cannot create sandbox settings file because no tmpDir is available in this environment"
+            );
+        }
+        return tempDir;
+    }
+    async _updateSandboxConfig(tempDir, configTarget, sandboxConfig, launchCwd) {
+        const normalizedSandboxConfig = this._withDefaultSandboxConfig(sandboxConfig, launchCwd);
+        let configFileUri;
+        const configTargetKey = ConfigurationTargetToString(configTarget);
+        if (( this._sandboxConfigPerConfigurationTarget.has(configTargetKey))) {
+            configFileUri = ( URI.parse(this._sandboxConfigPerConfigurationTarget.get(configTargetKey)));
+        } else {
+            configFileUri = URI.joinPath(
+                tempDir,
+                `vscode-${configTargetKey}-mcp-sandbox-settings-${this._sandboxSettingsId}.json`
+            );
+            this._sandboxConfigPerConfigurationTarget.set(configTargetKey, ( configFileUri.toString()));
+        }
+        await this._fileService.createFile(
+            configFileUri,
+            VSBuffer.fromString(JSON.stringify(normalizedSandboxConfig, null, "\t")),
+            {
+                overwrite: true
+            }
+        );
+        return configFileUri.path;
+    }
+    _withDefaultSandboxConfig(sandboxConfig, launchCwd) {
+        const mergedAllowWrite = ( new Set(sandboxConfig?.filesystem?.allowWrite ?? []));
+        for (const defaultAllowWrite of this._getDefaultAllowWrite(launchCwd ? [launchCwd] : undefined)) {
+            if (defaultAllowWrite) {
+                mergedAllowWrite.add(defaultAllowWrite);
+            }
+        }
+        const mergedAllowedDomains = ( new Set(sandboxConfig?.network?.allowedDomains ?? []));
+        for (const defaultAllowedDomain of this._defaultAllowedDomains) {
+            if (defaultAllowedDomain) {
+                mergedAllowedDomains.add(defaultAllowedDomain);
+            }
+        }
+        return {
+            ...sandboxConfig,
+            network: {
+                allowedDomains: [...mergedAllowedDomains],
+                deniedDomains: sandboxConfig?.network?.deniedDomains ?? []
+            },
+            filesystem: {
+                allowWrite: [...mergedAllowWrite],
+                denyRead: sandboxConfig?.filesystem?.denyRead ?? [],
+                denyWrite: sandboxConfig?.filesystem?.denyWrite ?? []
+            }
+        };
+    }
+    _getDefaultAllowWrite(directories) {
+        const defaultAllowWrite = ["~/.npm"];
+        for (const launchCwd of directories ?? []) {
+            const trimmed = launchCwd.trim();
+            if (trimmed) {
+                defaultAllowWrite.push(trimmed);
+            }
+        }
+        return defaultAllowWrite;
+    }
+};
+McpSandboxService = ( __decorate([( __param(0, IFileService)), ( __param(1, IEnvironmentService)), ( __param(2, ILogService)), ( __param(3, IMcpResourceScannerService)), ( __param(4, IRemoteAgentService))], McpSandboxService));
+
+export { McpSandboxService };

package/vscode/src/vs/workbench/contrib/mcp/common/mcpServerConnection.d.ts

@@ -5,7 +5,7 @@ import { ILogger } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/com
 import { IMcpHostDelegate } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
 import { McpServerRequestHandler } from "./mcpServerRequestHandler.js";
 import { McpTaskManager } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTaskManager";
-import { IMcpClientMethods, IMcpServerConnection, McpCollectionDefinition, McpConnectionState, McpServerDefinition, McpServerLaunch } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpClientMethods, IMcpPotentialSandboxBlock, IMcpServerConnection, McpCollectionDefinition, McpConnectionState, McpServerDefinition, McpServerLaunch } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 export declare class McpServerConnection extends Disposable implements IMcpServerConnection {
     private readonly _collection;
     readonly definition: McpServerDefinition;
@@ -18,8 +18,10 @@ export declare class McpServerConnection extends Disposable implements IMcpServe
     private readonly _launch;
     private readonly _state;
     private readonly _requestHandler;
+    private readonly _onPotentialSandboxBlock;
     readonly state: IObservable<McpConnectionState>;
     readonly handler: IObservable<McpServerRequestHandler | undefined>;
+    readonly onPotentialSandboxBlock: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<IMcpPotentialSandboxBlock>;
     constructor(_collection: McpCollectionDefinition, definition: McpServerDefinition, _delegate: IMcpHostDelegate, launchDefinition: McpServerLaunch, _logger: ILogger, _errorOnUserInteraction: boolean | undefined, _taskManager: McpTaskManager, _instantiationService: IInstantiationService);
     /** @inheritdoc */
     start(methods: IMcpClientMethods): Promise<McpConnectionState>;
@@ -27,4 +29,7 @@ export declare class McpServerConnection extends Disposable implements IMcpServe
     stop(): Promise<void>;
     dispose(): void;
     private _waitForState;
+    private _toPotentialSandboxBlock;
+    private _extractSandboxPath;
+    private _extractSandboxHost;
 }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpServerConnection.js

@@ -2,6 +2,7 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -37,8 +38,10 @@ let McpServerConnection = class McpServerConnection extends Disposable {
             state: McpConnectionState.Kind.Stopped
         });
         this._requestHandler = observableValue("mcpServerRequestHandler", undefined);
+        this._onPotentialSandboxBlock = this._register(( new Emitter()));
         this.state = this._state;
         this.handler = this._requestHandler;
+        this.onPotentialSandboxBlock = this._onPotentialSandboxBlock.event;
     }
     async start(methods) {
         const currentState = this._state.get();
@@ -49,7 +52,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         this._state.set({
             state: McpConnectionState.Kind.Starting
         }, undefined);
-        this._logger.info(( localize(9571, "Starting server {0}", this.definition.label)));
+        this._logger.info(( localize(10470, "Starting server {0}", this.definition.label)));
         try {
             const launch = this._delegate.start(this._collection, this.definition, this.launchDefinition, {
                 errorOnUserInteraction: this._errorOnUserInteraction
@@ -77,12 +80,16 @@ let McpServerConnection = class McpServerConnection extends Disposable {
             }
         ) => {
             log(this._logger, level, message);
+            const potentialBlock = this._toPotentialSandboxBlock(message);
+            if (potentialBlock) {
+                this._onPotentialSandboxBlock.fire(potentialBlock);
+            }
         }));
         let didStart = false;
         store.add(autorun(reader => {
             const state = launch.state.read(reader);
             this._state.set(state, undefined);
-            this._logger.info(( localize(9572, "Connection state: {0}", (McpConnectionState.toString(state)))));
+            this._logger.info(( localize(10471, "Connection state: {0}", (McpConnectionState.toString(state)))));
             if (state.state === McpConnectionState.Kind.Running && !didStart) {
                 didStart = true;
                 McpServerRequestHandler.create(this._instantiationService, {
@@ -121,7 +128,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         };
     }
     async stop() {
-        this._logger.info(( localize(9573, "Stopping server {0}", this.definition.label)));
+        this._logger.info(( localize(10472, "Stopping server {0}", this.definition.label)));
         this._launch.value?.object.stop();
         await this._waitForState(McpConnectionState.Kind.Stopped, McpConnectionState.Kind.Error);
     }
@@ -147,6 +154,57 @@ let McpServerConnection = class McpServerConnection extends Disposable {
             });
         }));
     }
+    _toPotentialSandboxBlock(message) {
+        if (!this.definition.sandboxEnabled) {
+            return undefined;
+        }
+        if (/No matching config rule, denying:/i.test(message)) {
+            return {
+                kind: "network",
+                message,
+                host: this._extractSandboxHost(message)
+            };
+        }
+        if (/\b(?:EAI_AGAIN|ENOTFOUND)\b/i.test(message)) {
+            return {
+                kind: "network",
+                message,
+                host: this._extractSandboxHost(message)
+            };
+        }
+        if (/(?:\b(?:EACCES|EPERM|ENOENT|fail(?:ed|ure)?)\b|not accessible)/i.test(message)) {
+            return {
+                kind: "filesystem",
+                message,
+                path: this._extractSandboxPath(message)
+            };
+        }
+        return undefined;
+    }
+    _extractSandboxPath(line) {
+        const bracketedPath = line.match(/\[(\/[^\]\r\n]+)\]/);
+        if (bracketedPath?.[1]) {
+            return bracketedPath[1].trim();
+        }
+        const quotedPath = line.match(/["'](\/[^"']+)["']/);
+        if (quotedPath?.[1]) {
+            return quotedPath[1];
+        }
+        const trailingPath = line.match(/(\/[\w.\-~/ ]+)$/);
+        return trailingPath?.[1]?.trim();
+    }
+    _extractSandboxHost(value) {
+        const deniedMatch = value.match(/No matching config rule, denying:\s+(.+)$/i);
+        const matchTarget = deniedMatch?.[1] ?? value;
+        const trimmed = matchTarget.trim().replace(/^["'`]+|["'`,.;]+$/g, "");
+        if (!trimmed) {
+            return undefined;
+        }
+        const withoutProtocol = trimmed.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");
+        const firstToken = withoutProtocol.split(/[\s/]/, 1)[0] ?? "";
+        const host = firstToken.replace(/:\d+$/, "");
+        return host || undefined;
+    }
 };
 McpServerConnection = ( __decorate([( __param(7, IInstantiationService))], McpServerConnection));
 

package/vscode/src/vs/workbench/contrib/mcp/common/mcpServerRequestHandler.d.ts

@@ -27,8 +27,7 @@ export interface IMcpServerRequestHandlerOptions extends IMcpClientMethods {
  * handling of ping requests and typed client request methods.
  */
 export declare class McpServerRequestHandler extends Disposable {
-    private _nextRequestId;
-    private readonly _pendingRequests;
+    private readonly _rpc;
     private _hasAnnouncedRoots;
     private _roots;
     set roots(roots: MCP.Root[]);
@@ -83,18 +82,6 @@ export declare class McpServerRequestHandler extends Disposable {
      */
     private sendRequestPaginated;
     private sendNotification;
-    /**
-     * Handle incoming messages from the server
-     */
-    private handleMessage;
-    /**
-     * Handle successful responses
-     */
-    private handleResult;
-    /**
-     * Handle error responses
-     */
-    private handleError;
     /**
      * Handle incoming server requests
      */
@@ -105,10 +92,6 @@ export declare class McpServerRequestHandler extends Disposable {
     private handleServerNotification;
     private handleCancelledNotification;
     private handleLoggingNotification;
-    /**
-     * Send a generic response to a request
-     */
-    private respondToRequest;
     /**
      * Send a response to a ping request
      */
@@ -166,7 +149,7 @@ export declare class McpServerRequestHandler extends Disposable {
     /**
      * Call a specific tool. Supports tasks automatically if `task` is set on the request.
      */
-    callTool(params: MCP.CallToolRequest["params"] & MCP.Request["params"], token?: CancellationToken): Promise<MCP.CallToolResult>;
+    callTool(params: MCP.CallToolRequest["params"] & MCP.Request["params"], token?: CancellationToken, onStatusMessage?: (message: string) => void): Promise<MCP.CallToolResult>;
     /**
      * Set the logging level
      */
@@ -206,12 +189,13 @@ export declare class McpServerRequestHandler extends Disposable {
  */
 export declare class McpTask<T extends MCP.Result> extends Disposable implements IMcpTaskInternal {
     private readonly _task;
+    private readonly _onStatusMessage?;
     private readonly promise;
     get result(): Promise<T>;
     get id(): string;
     private _lastTaskState;
     private _handler;
-    constructor(_task: MCP.Task, _token?: CancellationToken);
+    constructor(_task: MCP.Task, _token?: CancellationToken, _onStatusMessage?: ((message: string) => void) | undefined);
     onDidUpdateState(task: MCP.Task): void;
     setHandler(handler: McpServerRequestHandler | undefined): void;
 }