@codingame/monaco-vscode-mcp-service-override 23.2.2 → 24.1.0

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

@@ -4,7 +4,7 @@ import { raceCancellationError, Sequencer, AsyncIterableProducer } from '@coding
 import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { parseTree, findNodeAtOffset, getNodePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
-import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { mapValues } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
@@ -27,12 +27,14 @@ import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
-import { mcpActivationEvent } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { mcpActivationEvent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
 import { McpDevModeServerAttache } from './mcpDevMode.js';
 import { McpIcons, parseAndValidateMcpIcon } from './mcpIcons.js';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { McpConnectionState, McpConnectionFailedError, McpServerCacheState, McpServerStaticToolAvailability, extensionMcpCollectionPrefix, UserInteractionRequiredError, McpServerTransportType, mcpPromptReplaceSpecialChars, McpCapability, McpToolName, McpResourceURI } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { McpTaskManager } from './mcpTaskManager.js';
+import { McpConnectionState, McpConnectionFailedError, McpServerCacheState, McpServerStaticToolAvailability, extensionMcpCollectionPrefix, UserInteractionRequiredError, McpServerTransportType, mcpPromptReplaceSpecialChars, McpCapability, McpToolName, MpcResponseError, ElicitationKind, McpResourceURI } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { IMcpSamplingService, IMcpElicitationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { MCP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol';
 import { UriTemplate } from './uriTemplate.js';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 import { observableValue, disposableObservableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
@@ -197,6 +199,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         this._openerService = _openerService;
         this._samplingService = _samplingService;
         this._elicitationService = _elicitationService;
+        this._taskManager = this._register(( new McpTaskManager()));
         this._connectionSequencer = ( new Sequencer());
         this._connection = this._register(disposableObservableValue(this, undefined));
         this.connection = this._connection;
@@ -271,7 +274,9 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
             const tools = m?.tools?.filter(t => t.availability === McpServerStaticToolAvailability.Initial).map(t => t.definition);
             return tools?.length ? ( new ObservablePromise(this._getValidatedTools(tools))) : undefined;
         }))
-            .map((o, reader) => o?.promiseResult.read(reader)?.data)), (entry) => entry.tools, (entry) => ( entry.map(def => ( new McpTool(this, toolPrefix, def)))).sort((a, b) => a.compare(b)), []));
+            .map((o, reader) => o?.promiseResult.read(reader)?.data)), (entry) => entry.tools, (entry) => ( entry.map(
+            def => this._instantiationService.createInstance(McpTool, this, toolPrefix, def)
+        )).sort((a, b) => a.compare(b)), []));
         this._prompts = ( new CachedPrimitive(
             this.definition.id,
             this._primitiveCache,
@@ -347,6 +352,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                     definitionRef: this.definition,
                     debug,
                     errorOnUserInteraction,
+                    taskManager: this._taskManager,
                 });
                 if (!connection) {
                     return { state: McpConnectionState.Kind.Stopped };
@@ -362,12 +368,12 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
             }
             const start = Date.now();
             let state = await connection.start({
-                createMessageRequestHandler: params => this._samplingService.sample({
+                createMessageRequestHandler: (params, token) => this._samplingService.sample({
                     isDuringToolCall: this.runningToolCalls.size > 0,
                     server: this,
                     params,
-                }).then(r => r.sample),
-                elicitationRequestHandler: req => {
+                }, token).then(r => r.sample),
+                elicitationRequestHandler: async (req, token) => {
                     const serverInfo = connection.handler.get()?.serverInfo;
                     if (serverInfo) {
                         this._telemetryService.publicLog2('mcp.elicitationRequested', {
@@ -375,7 +381,9 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                             serverVersion: serverInfo.version,
                         });
                     }
-                    return this._elicitationService.elicit(this, Iterable.first(this.runningToolCalls), req, CancellationToken.None);
+                    const r = await this._elicitationService.elicit(this, Iterable.first(this.runningToolCalls), req, token || CancellationToken.None);
+                    r.dispose();
+                    return r.value;
                 }
             });
             this._telemetryService.publicLog2('mcp/serverBootState', {
@@ -426,29 +434,29 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                     break;
             }
             const options = [{
-                    label: ( localize(8895, "Show Output")),
+                    label: ( localize(9027, "Show Output")),
                     run: () => this.showOutput(),
                 }];
             if (cnx.definition.devMode?.debug?.type === 'debugpy' && debug) {
                 this._notificationService.prompt(Severity.Error, ( localize(
-                    8896,
+                    9028,
                     'The command "{0}" was not found. You can specify the path to debugpy in the `dev.debug.debugpyPath` option.',
                     cnx.launchDefinition.command,
                     cnx.definition.label
                 )), [...options, {
-                        label: ( localize(8897, 'View Docs')),
+                        label: ( localize(9029, 'View Docs')),
                         run: () => this._openerService.open(( URI.parse('https://aka.ms/vscode-mcp-install/debugpy'))),
                     }]);
                 return;
             }
             if (docsLink) {
                 options.push({
-                    label: ( localize(8898, 'Install {0}', cnx.launchDefinition.command)),
+                    label: ( localize(9030, 'Install {0}', cnx.launchDefinition.command)),
                     run: () => this._openerService.open(( URI.parse(docsLink))),
                 });
             }
             this._notificationService.prompt(Severity.Error, ( localize(
-                8899,
+                9031,
                 'The command "{0}" needed to run {1} was not found.',
                 cnx.launchDefinition.command,
                 cnx.definition.label
@@ -456,7 +464,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         }
         else {
             this._notificationService.warn(( localize(
-                8900,
+                9032,
                 'The MCP server {0} could not be started: {1}',
                 cnx.definition.label,
                 error.message
@@ -522,7 +530,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         const validated = [];
         for (const [i, result] of validations.entries()) {
             if ('error' in result) {
-                error += ( localize(8901, 'Tool `{0}` has invalid JSON parameters:', tools[i].name)) + '\n';
+                error += ( localize(9033, 'Tool `{0}` has invalid JSON parameters:', tools[i].name)) + '\n';
                 for (const message of result.error) {
                     error += `\t- ${message}\n`;
                 }
@@ -687,35 +695,22 @@ function encodeCapabilities(cap) {
     }
     return out;
 }
-class McpTool {
+let McpTool = class McpTool {
     get definition() { return this._definition; }
-    constructor(_server, idPrefix, _definition) {
+    constructor(_server, idPrefix, _definition, _elicitationService) {
         this._server = _server;
         this._definition = _definition;
+        this._elicitationService = _elicitationService;
         this.referenceName = _definition.name.replaceAll('.', '_');
         this.id = (idPrefix + _definition.name).replaceAll('.', '_').slice(0, McpToolName.MaxLength);
         this.icons = McpIcons.fromStored(this._definition._icons);
     }
     async call(params, context, token) {
-        const name = this._definition.serverToolName ?? this._definition.name;
         if (context) {
             this._server.runningToolCalls.add(context);
         }
         try {
-            const meta = {};
-            if (context?.chatSessionId) {
-                meta['vscode.conversationId'] = context.chatSessionId;
-            }
-            if (context?.chatRequestId) {
-                meta['vscode.requestId'] = context.chatRequestId;
-            }
-            const result = await McpServer.callOn(this._server, h => h.callTool({
-                name,
-                arguments: params,
-                _meta: ( Object.keys(meta)).length > 0 ? meta : undefined
-            }, token), token);
-            await this._server.awaitToolRefresh();
-            return result;
+            return await this._callWithProgress(params, undefined, context, token);
         }
         finally {
             if (context) {
@@ -736,18 +731,21 @@ class McpTool {
             }
         }
     }
-    _callWithProgress(params, progress, context, token, allowRetry = true) {
+    _callWithProgress(params, progress, context, token = CancellationToken.None, allowRetry = true) {
         const name = this._definition.serverToolName ?? this._definition.name;
-        const progressToken = generateUuid();
+        const progressToken = progress ? generateUuid() : undefined;
+        const store = ( new DisposableStore());
         return McpServer.callOn(this._server, async (h) => {
-            const listener = h.onDidReceiveProgressNotification((e) => {
-                if (e.params.progressToken === progressToken) {
-                    progress.report({
-                        message: e.params.message,
-                        progress: e.params.total !== undefined && e.params.progress !== undefined ? e.params.progress / e.params.total : undefined,
-                    });
-                }
-            });
+            if (progress) {
+                store.add(h.onDidReceiveProgressNotification((e) => {
+                    if (e.params.progressToken === progressToken) {
+                        progress.report({
+                            message: e.params.message,
+                            progress: e.params.total !== undefined && e.params.progress !== undefined ? e.params.progress / e.params.total : undefined,
+                        });
+                    }
+                }));
+            }
             const meta = { progressToken };
             if (context?.chatSessionId) {
                 meta['vscode.conversationId'] = context.chatSessionId;
@@ -755,12 +753,24 @@ class McpTool {
             if (context?.chatRequestId) {
                 meta['vscode.requestId'] = context.chatRequestId;
             }
+            const taskHint = this._definition.execution?.taskSupport;
+            const serverSupportsTasksForTools = h.capabilities.tasks?.requests?.tools?.call !== undefined;
+            const shouldUseTask = serverSupportsTasksForTools && (taskHint === 'required' || taskHint === 'optional');
             try {
-                const result = await h.callTool({ name, arguments: params, _meta: meta }, token);
+                const result = await h.callTool({
+                    name,
+                    arguments: params,
+                    task: shouldUseTask ? {} : undefined,
+                    _meta: meta,
+                }, token);
                 await this._server.awaitToolRefresh();
                 return result;
             }
             catch (err) {
+                if (err instanceof MpcResponseError && err.code === MCP.URL_ELICITATION_REQUIRED && allowRetry) {
+                    await this._handleElicitationErr(err, context, token);
+                    return this._callWithProgress(params, progress, context, token, false);
+                }
                 const state = this._server.connectionState.get();
                 if (allowRetry && state.state === McpConnectionState.Kind.Error && state.shouldRetry) {
                     return this._callWithProgress(params, progress, context, token, false);
@@ -770,14 +780,36 @@ class McpTool {
                 }
             }
             finally {
-                listener.dispose();
+                store.dispose();
             }
         }, token);
     }
+    async _handleElicitationErr(err, context, token) {
+        const elicitations = err.data?.elicitations;
+        if (Array.isArray(elicitations) && elicitations.length > 0) {
+            for (const elicitation of elicitations) {
+                const elicitResult = await this._elicitationService.elicit(this._server, context, elicitation, token);
+                try {
+                    if (elicitResult.value.action !== 'accept') {
+                        throw err;
+                    }
+                    if (elicitResult.kind === ElicitationKind.URL) {
+                        await elicitResult.wait;
+                    }
+                }
+                finally {
+                    elicitResult.dispose();
+                }
+            }
+        }
+    }
     compare(other) {
         return this._definition.name.localeCompare(other.definition.name);
     }
-}
+};
+McpTool = ( __decorate([
+    ( __param(3, IMcpElicitationService))
+], McpTool));
 function warnInvalidTools(instaService, serverName, errorText) {
     instaService.invokeFunction((accessor) => {
         const notificationService = accessor.get(INotificationService);
@@ -785,7 +817,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
         notificationService.notify({
             severity: Severity.Warning,
             message: ( localize(
-                8902,
+                9034,
                 'MCP server `{0}` has tools with invalid parameters which will be omitted.',
                 serverName
             )),
@@ -795,7 +827,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
                         enabled: true,
                         id: 'mcpBadSchema.show',
                         tooltip: '',
-                        label: ( localize(8903, 'Show')),
+                        label: ( localize(9035, 'Show')),
                         run: () => {
                             editorService.openEditor({
                                 resource: undefined,

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

@@ -4,6 +4,7 @@ import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { ILogger } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log";
 import { IMcpHostDelegate } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
 import { McpServerRequestHandler } from "./mcpServerRequestHandler.js";
+import { McpTaskManager } from "./mcpTaskManager.js";
 import { IMcpClientMethods, 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;
@@ -12,13 +13,14 @@ export declare class McpServerConnection extends Disposable implements IMcpServe
     readonly launchDefinition: McpServerLaunch;
     private readonly _logger;
     private readonly _errorOnUserInteraction;
+    private readonly _taskManager;
     private readonly _instantiationService;
     private readonly _launch;
     private readonly _state;
     private readonly _requestHandler;
     readonly state: IObservable<McpConnectionState>;
     readonly handler: IObservable<McpServerRequestHandler | undefined>;
-    constructor(_collection: McpCollectionDefinition, definition: McpServerDefinition, _delegate: IMcpHostDelegate, launchDefinition: McpServerLaunch, _logger: ILogger, _errorOnUserInteraction: boolean | undefined, _instantiationService: IInstantiationService);
+    constructor(_collection: McpCollectionDefinition, definition: McpServerDefinition, _delegate: IMcpHostDelegate, launchDefinition: McpServerLaunch, _logger: ILogger, _errorOnUserInteraction: boolean | undefined, _taskManager: McpTaskManager, _instantiationService: IInstantiationService);
     /** @inheritdoc */
     start(methods: IMcpClientMethods): Promise<McpConnectionState>;
     private adoptLaunch;

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

@@ -13,7 +13,7 @@ import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/com
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 let McpServerConnection = class McpServerConnection extends Disposable {
-    constructor(_collection, definition, _delegate, launchDefinition, _logger, _errorOnUserInteraction, _instantiationService) {
+    constructor(_collection, definition, _delegate, launchDefinition, _logger, _errorOnUserInteraction, _taskManager, _instantiationService) {
         super();
         this._collection = _collection;
         this.definition = definition;
@@ -21,6 +21,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         this.launchDefinition = launchDefinition;
         this._logger = _logger;
         this._errorOnUserInteraction = _errorOnUserInteraction;
+        this._taskManager = _taskManager;
         this._instantiationService = _instantiationService;
         this._launch = this._register(( new MutableDisposable()));
         this._state = observableValue('mcpServerState', { state: McpConnectionState.Kind.Stopped });
@@ -35,7 +36,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         }
         this._launch.value = undefined;
         this._state.set({ state: McpConnectionState.Kind.Starting }, undefined);
-        this._logger.info(( localize(8904, 'Starting server {0}', this.definition.label)));
+        this._logger.info(( localize(9036, 'Starting server {0}', this.definition.label)));
         try {
             const launch = this._delegate.start(this._collection, this.definition, this.launchDefinition, { errorOnUserInteraction: this._errorOnUserInteraction });
             this._launch.value = this.adoptLaunch(launch, methods);
@@ -62,14 +63,15 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         store.add(autorun(reader => {
             const state = launch.state.read(reader);
             this._state.set(state, undefined);
-            this._logger.info(( localize(8905, 'Connection state: {0}', (McpConnectionState.toString(state)))));
+            this._logger.info(( localize(9037, 'Connection state: {0}', (McpConnectionState.toString(state)))));
             if (state.state === McpConnectionState.Kind.Running && !didStart) {
                 didStart = true;
                 McpServerRequestHandler.create(this._instantiationService, {
+                    ...methods,
                     launch,
                     logger: this._logger,
                     requestLogLevel: this.definition.devMode ? LogLevel.Info : LogLevel.Debug,
-                    ...methods,
+                    taskManager: this._taskManager,
                 }, cts.token).then(handler => {
                     if (!store.isDisposed) {
                         this._requestHandler.set(handler, undefined);
@@ -96,7 +98,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         return { dispose: () => store.dispose(), object: launch };
     }
     async stop() {
-        this._logger.info(( localize(8906, 'Stopping server {0}', this.definition.label)));
+        this._logger.info(( localize(9038, 'Stopping server {0}', this.definition.label)));
         this._launch.value?.object.stop();
         await this._waitForState(McpConnectionState.Kind.Stopped, McpConnectionState.Kind.Error);
     }
@@ -122,7 +124,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
     }
 };
 McpServerConnection = ( __decorate([
-    ( __param(6, IInstantiationService))
+    ( __param(7, IInstantiationService))
 ], McpServerConnection));
 
 export { McpServerConnection };

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

@@ -3,6 +3,7 @@ import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILogger, LogLevel } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log";
 import { IMcpMessageTransport } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
+import { IMcpTaskInternal, McpTaskManager } from "./mcpTaskManager.js";
 import { IMcpClientMethods } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 import { MCP } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol";
 export interface McpRoot {
@@ -16,6 +17,8 @@ export interface IMcpServerRequestHandlerOptions extends IMcpClientMethods {
     logger: ILogger;
     /** Log level MCP messages is logged at */
     requestLogLevel?: LogLevel;
+    /** Task manager for server-side MCP tasks (shared across reconnections) */
+    taskManager: McpTaskManager;
 }
 /**
  * Request handler for communicating with an MCP server.
@@ -37,6 +40,8 @@ export declare class McpServerRequestHandler extends Disposable {
     readonly onDidReceiveCancelledNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.CancelledNotification>;
     private readonly _onDidReceiveProgressNotification;
     readonly onDidReceiveProgressNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.ProgressNotification>;
+    private readonly _onDidReceiveElicitationCompleteNotification;
+    readonly onDidReceiveElicitationCompleteNotification: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.ElicitationCompleteNotification>;
     private readonly _onDidChangeResourceList;
     readonly onDidChangeResourceList: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
     private readonly _onDidUpdateResource;
@@ -55,7 +60,8 @@ export declare class McpServerRequestHandler extends Disposable {
     private readonly _requestLogLevel;
     private readonly _createMessageRequestHandler;
     private readonly _elicitationRequestHandler;
-    protected constructor({ launch, logger, createMessageRequestHandler, elicitationRequestHandler, requestLogLevel, }: IMcpServerRequestHandlerOptions);
+    private readonly _taskManager;
+    protected constructor({ launch, logger, createMessageRequestHandler, elicitationRequestHandler, requestLogLevel, taskManager, }: IMcpServerRequestHandlerOptions);
     /**
      * Send a client request to the server and return the response.
      *
@@ -158,7 +164,7 @@ export declare class McpServerRequestHandler extends Disposable {
      */
     listTools(params?: MCP.ListToolsRequest["params"], token?: CancellationToken): Promise<MCP.Tool[]>;
     /**
-     * Call a specific tool
+     * 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>;
     /**
@@ -169,4 +175,43 @@ export declare class McpServerRequestHandler extends Disposable {
      * Find completions for an argument
      */
     complete(params: MCP.CompleteRequest["params"], token?: CancellationToken): Promise<MCP.CompleteResult>;
+    /**
+     * Get task status
+     */
+    getTask(params: {
+        taskId: string;
+    }, token?: CancellationToken): Promise<MCP.GetTaskResult>;
+    /**
+     * Get task result
+     */
+    getTaskResult(params: {
+        taskId: string;
+    }, token?: CancellationToken): Promise<MCP.GetTaskPayloadResult>;
+    /**
+     * Cancel a task
+     */
+    cancelTask(params: {
+        taskId: string;
+    }, token?: CancellationToken): Promise<MCP.CancelTaskResult>;
+    /**
+     * List all tasks
+     */
+    listTasks(params?: MCP.ListTasksRequest["params"], token?: CancellationToken): Promise<MCP.Task[]>;
+}
+/**
+ * Implementation of a task that handles polling, status notifications, and handler reconnections. It implements the task polling loop internally and can also be
+ * updated externally via `onDidUpdateState`, when notifications are received
+ * for example.
+ * @internal
+ */
+export declare class McpTask<T extends MCP.Result> extends Disposable implements IMcpTaskInternal {
+    private readonly _task;
+    private readonly promise;
+    get result(): Promise<T>;
+    get id(): string;
+    private _lastTaskState;
+    private _handler;
+    constructor(_task: MCP.Task, _token?: CancellationToken);
+    onDidUpdateState(task: MCP.Task): void;
+    setHandler(handler: McpServerRequestHandler | undefined): void;
 }