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

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

@@ -1,18 +1,22 @@
 
 import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
-import { IntervalTimer, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { IntervalTimer, DeferredPromise, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken, 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 { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { LogLevel, canLog, log } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { McpConnectionState, MpcResponseError, McpError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { isTaskResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
 import { MCP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
 
 class McpServerRequestHandler extends Disposable {
     set roots(roots) {
@@ -50,7 +54,15 @@ class McpServerRequestHandler extends Disposable {
                         capabilities: {
                             roots: { listChanged: true },
                             sampling: opts.createMessageRequestHandler ? {} : undefined,
-                            elicitation: opts.elicitationRequestHandler ? {} : undefined,
+                            elicitation: opts.elicitationRequestHandler ? { form: {}, url: {} } : undefined,
+                            tasks: {
+                                list: {},
+                                cancel: {},
+                                requests: {
+                                    sampling: opts.createMessageRequestHandler ? { createMessage: {} } : undefined,
+                                    elicitation: opts.elicitationRequestHandler ? { create: {} } : undefined,
+                                },
+                            },
                         },
                         clientInfo: {
                             name: productService.nameLong,
@@ -74,7 +86,7 @@ class McpServerRequestHandler extends Disposable {
             store.dispose();
         }
     }
-    constructor({ launch, logger, createMessageRequestHandler, elicitationRequestHandler, requestLogLevel = LogLevel.Debug, }) {
+    constructor({ launch, logger, createMessageRequestHandler, elicitationRequestHandler, requestLogLevel = LogLevel.Debug, taskManager, }) {
         super();
         this._nextRequestId = 1;
         this._pendingRequests = ( new Map());
@@ -84,6 +96,8 @@ class McpServerRequestHandler extends Disposable {
         this.onDidReceiveCancelledNotification = this._onDidReceiveCancelledNotification.event;
         this._onDidReceiveProgressNotification = this._register(( new Emitter()));
         this.onDidReceiveProgressNotification = this._onDidReceiveProgressNotification.event;
+        this._onDidReceiveElicitationCompleteNotification = this._register(( new Emitter()));
+        this.onDidReceiveElicitationCompleteNotification = this._onDidReceiveElicitationCompleteNotification.event;
         this._onDidChangeResourceList = this._register(( new Emitter()));
         this.onDidChangeResourceList = this._onDidChangeResourceList.event;
         this._onDidUpdateResource = this._register(( new Emitter()));
@@ -97,6 +111,16 @@ class McpServerRequestHandler extends Disposable {
         this._requestLogLevel = requestLogLevel;
         this._createMessageRequestHandler = createMessageRequestHandler;
         this._elicitationRequestHandler = elicitationRequestHandler;
+        this._taskManager = taskManager;
+        this._taskManager.setHandler(this);
+        this._register(this._taskManager.onDidUpdateTask(task => {
+            this.send({
+                jsonrpc: MCP.JSONRPC_VERSION,
+                method: 'notifications/tasks/status',
+                params: task
+            });
+        }));
+        this._register(toDisposable(() => this._taskManager.setHandler(undefined)));
         this._register(launch.onDidReceiveMessage(message => this.handleMessage(message)));
         this._register(autorun(reader => {
             const state = launch.state.read(reader).state;
@@ -201,10 +225,38 @@ class McpServerRequestHandler extends Disposable {
                 response = this.handleRootsList(request);
             }
             else if (request.method === 'sampling/createMessage' && this._createMessageRequestHandler) {
-                response = await this._createMessageRequestHandler(request.params);
+                if (request.params.task) {
+                    const taskResult = this._taskManager.createTask(request.params.task.ttl ?? null, (token) => this._createMessageRequestHandler(request.params, token));
+                    taskResult._meta ??= {};
+                    taskResult._meta['io.modelcontextprotocol/related-task'] = { taskId: taskResult.task.taskId };
+                    response = taskResult;
+                }
+                else {
+                    response = await this._createMessageRequestHandler(request.params);
+                }
             }
             else if (request.method === 'elicitation/create' && this._elicitationRequestHandler) {
-                response = await this._elicitationRequestHandler(request.params);
+                if (request.params.task) {
+                    const taskResult = this._taskManager.createTask(request.params.task.ttl ?? null, (token) => this._elicitationRequestHandler(request.params, token));
+                    taskResult._meta ??= {};
+                    taskResult._meta['io.modelcontextprotocol/related-task'] = { taskId: taskResult.task.taskId };
+                    response = taskResult;
+                }
+                else {
+                    response = await this._elicitationRequestHandler(request.params);
+                }
+            }
+            else if (request.method === 'tasks/get') {
+                response = this._taskManager.getTask(request.params.taskId);
+            }
+            else if (request.method === 'tasks/result') {
+                response = await this._taskManager.getTaskResult(request.params.taskId);
+            }
+            else if (request.method === 'tasks/cancel') {
+                response = this._taskManager.cancelTask(request.params.taskId);
+            }
+            else if (request.method === 'tasks/list') {
+                response = this._taskManager.listTasks();
             }
             else {
                 throw McpError.methodNotFound(request.method);
@@ -250,13 +302,21 @@ class McpServerRequestHandler extends Disposable {
             case 'notifications/prompts/list_changed':
                 this._onDidChangePromptList.fire();
                 return;
+            case 'notifications/elicitation/complete':
+                this._onDidReceiveElicitationCompleteNotification.fire(request);
+                return;
+            case 'notifications/tasks/status':
+                this._taskManager.getClientTask(request.params.taskId)?.onDidUpdateState(request.params);
+                return;
         }
     }
     handleCancelledNotification(request) {
-        const pendingRequest = this._pendingRequests.get(request.params.requestId);
-        if (pendingRequest) {
-            this._pendingRequests.delete(request.params.requestId);
-            pendingRequest.promise.cancel();
+        if (request.params.requestId) {
+            const pendingRequest = this._pendingRequests.get(request.params.requestId);
+            if (pendingRequest) {
+                this._pendingRequests.delete(request.params.requestId);
+                pendingRequest.promise.cancel();
+            }
         }
     }
     handleLoggingNotification(request) {
@@ -350,8 +410,17 @@ class McpServerRequestHandler extends Disposable {
     listTools(params, token) {
         return Iterable.asyncToArrayFlat(this.sendRequestPaginated('tools/list', result => result.tools, params, token));
     }
-    callTool(params, token) {
-        return this.sendRequest({ method: 'tools/call', params }, token);
+    async callTool(params, token) {
+        const response = await this.sendRequest({ method: 'tools/call', params }, token);
+        if (isTaskResult(response)) {
+            const task = ( new McpTask(response.task, token));
+            this._taskManager.adoptClientTask(task);
+            task.setHandler(this);
+            return task.result.finally(() => {
+                this._taskManager.abandonClientTask(task.id);
+            });
+        }
+        return response;
     }
     setLevel(params, token) {
         return this.sendRequest({ method: 'logging/setLevel', params }, token);
@@ -359,6 +428,152 @@ class McpServerRequestHandler extends Disposable {
     complete(params, token) {
         return this.sendRequest({ method: 'completion/complete', params }, token);
     }
+    getTask(params, token) {
+        return this.sendRequest({ method: 'tasks/get', params }, token);
+    }
+    getTaskResult(params, token) {
+        return this.sendRequest({ method: 'tasks/result', params }, token);
+    }
+    cancelTask(params, token) {
+        return this.sendRequest({ method: 'tasks/cancel', params }, token);
+    }
+    listTasks(params, token) {
+        return Iterable.asyncToArrayFlat(this.sendRequestPaginated('tasks/list', result => result.tasks, params, token));
+    }
+}
+function isTaskInTerminalState(task) {
+    return task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled';
+}
+class McpTask extends Disposable {
+    get result() {
+        return this.promise.p;
+    }
+    get id() {
+        return this._task.taskId;
+    }
+    constructor(_task, _token = CancellationToken.None) {
+        super();
+        this._task = _task;
+        this.promise = ( new DeferredPromise());
+        this._handler = observableValue('mcpTaskHandler', undefined);
+        const expiresAt = _task.ttl ? (Date.now() + _task.ttl) : undefined;
+        this._lastTaskState = observableValue('lastTaskState', this._task);
+        const store = this._register(( new DisposableStore()));
+        if (_token.isCancellationRequested) {
+            this._lastTaskState.set({ ...this._task, status: 'cancelled' }, undefined);
+        }
+        else {
+            store.add(_token.onCancellationRequested(() => {
+                const current = this._lastTaskState.get();
+                if (!isTaskInTerminalState(current)) {
+                    this._lastTaskState.set({ ...current, status: 'cancelled' }, undefined);
+                }
+            }));
+        }
+        if (expiresAt) {
+            const ttlTimeout = expiresAt - Date.now();
+            if (ttlTimeout <= 0) {
+                this._lastTaskState.set({ ...this._task, status: 'cancelled', statusMessage: 'Task timed out.' }, undefined);
+            }
+            else {
+                store.add(disposableTimeout(() => {
+                    const current = this._lastTaskState.get();
+                    if (!isTaskInTerminalState(current)) {
+                        this._lastTaskState.set({ ...current, status: 'cancelled', statusMessage: 'Task timed out.' }, undefined);
+                    }
+                }, ttlTimeout));
+            }
+        }
+        const inputRequiredLookup = observableValue('activeResultLookup', undefined);
+        store.add(autorun(reader => {
+            const current = this._lastTaskState.read(reader);
+            if (isTaskInTerminalState(current)) {
+                return;
+            }
+            const lookup = inputRequiredLookup.read(reader);
+            if (lookup) {
+                const result = lookup.promiseResult.read(reader);
+                return transaction(tx => {
+                    if (!result) {
+                    }
+                    else if (result.data) {
+                        inputRequiredLookup.set(undefined, tx);
+                        this._lastTaskState.set(result.data, tx);
+                    }
+                    else {
+                        inputRequiredLookup.set(undefined, tx);
+                        if (result.error instanceof McpError && result.error.code === MCP.INVALID_PARAMS) {
+                            this._lastTaskState.set({ ...current, status: 'cancelled' }, undefined);
+                        }
+                        else {
+                            this._lastTaskState.set({ ...current, status: 'working' }, undefined);
+                        }
+                    }
+                });
+            }
+            const handler = this._handler.read(reader);
+            if (!handler) {
+                return;
+            }
+            const pollInterval = _task.pollInterval ?? 2000;
+            const cts = ( new CancellationTokenSource(_token));
+            reader.store.add(toDisposable(() => cts.dispose(true)));
+            reader.store.add(disposableTimeout(() => {
+                handler.getTask({ taskId: current.taskId }, cts.token)
+                    .catch((e) => {
+                    if (e instanceof McpError && e.code === MCP.INVALID_PARAMS) {
+                        return { ...current, status: 'cancelled' };
+                    }
+                    else {
+                        return { ...current };
+                    }
+                })
+                    .then(r => {
+                    if (r && !cts.token.isCancellationRequested) {
+                        this._lastTaskState.set(r, undefined);
+                    }
+                });
+            }, pollInterval));
+        }));
+        const lastStatus = ( this._lastTaskState.map(task => task.status));
+        store.add(autorun(reader => {
+            const status = lastStatus.read(reader);
+            if (status === 'failed') {
+                const current = this._lastTaskState.read(undefined);
+                this.promise.error(( new Error(
+                    `Task ${current.taskId} failed: ${current.statusMessage ?? 'unknown error'}`
+                )));
+                store.dispose();
+            }
+            else if (status === 'cancelled') {
+                this.promise.cancel();
+                store.dispose();
+            }
+            else if (status === 'input_required') {
+                const handler = this._handler.read(reader);
+                if (handler) {
+                    const current = this._lastTaskState.read(undefined);
+                    const cts = ( new CancellationTokenSource(_token));
+                    reader.store.add(toDisposable(() => cts.dispose(true)));
+                    inputRequiredLookup.set(( new ObservablePromise(handler.getTask({ taskId: current.taskId }, cts.token))), undefined);
+                }
+            }
+            else if (status === 'completed') {
+                const handler = this._handler.read(reader);
+                if (handler) {
+                    this.promise.settleWith(handler.getTaskResult({ taskId: _task.taskId }, _token));
+                    store.dispose();
+                }
+            }
+            else ;
+        }));
+    }
+    onDidUpdateState(task) {
+        this._lastTaskState.set(task, undefined);
+    }
+    setHandler(handler) {
+        this._handler.set(handler, undefined);
+    }
 }
 function mapLogLevelToMcp(logLevel) {
     switch (logLevel) {
@@ -379,4 +594,4 @@ function mapLogLevelToMcp(logLevel) {
     }
 }
 
-export { McpServerRequestHandler };
+export { McpServerRequestHandler, McpTask };

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

@@ -7,12 +7,12 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { mcpAutoStartConfig, McpAutoStartValue } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/platform/mcp/common/mcpManagement';
+import { mcpAutoStartConfig, McpAutoStartValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement';
 import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
 import { McpServerMetadataCache, McpServer } from './mcpServer.js';
 import { IAutostartResult, McpConnectionState, McpServerCacheState, McpStartServerInteraction, UserInteractionRequiredError, McpServerDefinition, McpToolName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
-import { startServerAndWaitForLiveTools } from '@codingame/monaco-vscode-08fd81c0-7fd8-5f7c-9776-f918dd532714-common/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
+import { startServerAndWaitForLiveTools } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';

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

@@ -0,0 +1,68 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { McpServerRequestHandler } from "./mcpServerRequestHandler.js";
+import { MCP } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol";
+export interface IMcpTaskInternal extends IDisposable {
+    readonly id: string;
+    onDidUpdateState(task: MCP.Task): void;
+    setHandler(handler: McpServerRequestHandler | undefined): void;
+}
+/**
+ * Manages in-memory task state for server-side MCP tasks (sampling and elicitation).
+ * Also tracks client-side tasks to survive handler reconnections.
+ * Lifecycle is tied to the McpServer instance.
+ */
+export declare class McpTaskManager extends Disposable {
+    private readonly _serverTasks;
+    private readonly _clientTasks;
+    private readonly _onDidUpdateTask;
+    readonly onDidUpdateTask: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<MCP.Task>;
+    /**
+     * Attach a new handler to this task manager.
+     * Updates all client tasks to use the new handler.
+     */
+    setHandler(handler: McpServerRequestHandler | undefined): void;
+    /**
+     * Get a client task by ID for status notification handling.
+     */
+    getClientTask(taskId: string): IMcpTaskInternal | undefined;
+    /**
+     * Track a new client task.
+     */
+    adoptClientTask(task: IMcpTaskInternal): void;
+    /**
+     * Untracks a client task.
+     */
+    abandonClientTask(taskId: string): void;
+    /**
+     * Create a new task and execute it asynchronously.
+     * Returns the task immediately while execution continues in the background.
+     */
+    createTask<TResult extends MCP.Result>(ttl: number | null, executor: (token: CancellationToken) => Promise<TResult>): MCP.CreateTaskResult;
+    /**
+     * Execute a task asynchronously and update its state.
+     */
+    private _executeTask;
+    /**
+     * Update task status and optionally store result or error.
+     */
+    private _updateTaskStatus;
+    /**
+     * Get the current state of a task.
+     * Returns an error if the task doesn't exist or has expired.
+     */
+    getTask(taskId: string): MCP.GetTaskResult;
+    /**
+     * Get the result of a completed task.
+     * Blocks until the task completes if it's still in progress.
+     */
+    getTaskResult(taskId: string): Promise<MCP.GetTaskPayloadResult>;
+    /**
+     * Cancel a task.
+     */
+    cancelTask(taskId: string): MCP.CancelTaskResult;
+    /**
+     * List all tasks.
+     */
+    listTasks(): MCP.ListTasksResult;
+}

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

@@ -0,0 +1,168 @@
+
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+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, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { McpError } 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';
+
+class McpTaskManager extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._serverTasks = this._register(( new DisposableMap()));
+        this._clientTasks = this._register(( new DisposableMap()));
+        this._onDidUpdateTask = this._register(( new Emitter()));
+        this.onDidUpdateTask = this._onDidUpdateTask.event;
+    }
+    setHandler(handler) {
+        for (const task of ( this._clientTasks.values())) {
+            task.setHandler(handler);
+        }
+    }
+    getClientTask(taskId) {
+        return this._clientTasks.get(taskId);
+    }
+    adoptClientTask(task) {
+        this._clientTasks.set(task.id, task);
+    }
+    abandonClientTask(taskId) {
+        this._clientTasks.deleteAndDispose(taskId);
+    }
+    createTask(ttl, executor) {
+        const taskId = generateUuid();
+        const createdAt = ( new Date()).toISOString();
+        const createdAtTime = Date.now();
+        const task = {
+            taskId,
+            status: 'working',
+            createdAt,
+            ttl,
+            pollInterval: 1000,
+        };
+        const store = ( new DisposableStore());
+        const cts = ( new CancellationTokenSource());
+        store.add(toDisposable(() => cts.dispose(true)));
+        const executionPromise = this._executeTask(taskId, executor, cts.token);
+        if (ttl) {
+            store.add(disposableTimeout(() => this._serverTasks.deleteAndDispose(taskId), ttl));
+        }
+        else {
+            executionPromise.finally(() => {
+                const timeout = this._register(disposableTimeout(() => {
+                    this._serverTasks.deleteAndDispose(taskId);
+                    this._store.delete(timeout);
+                }, 60_000));
+            });
+        }
+        this._serverTasks.set(taskId, {
+            task,
+            cts,
+            dispose: () => store.dispose(),
+            createdAtTime,
+            executionPromise,
+        });
+        return { task };
+    }
+    async _executeTask(taskId, executor, token) {
+        try {
+            const result = await executor(token);
+            this._updateTaskStatus(taskId, 'completed', undefined, result);
+        }
+        catch (error) {
+            if (error instanceof CancellationError) {
+                this._updateTaskStatus(taskId, 'cancelled', 'Task was cancelled by the client');
+            }
+            else if (error instanceof McpError) {
+                this._updateTaskStatus(taskId, 'failed', error.message, undefined, {
+                    code: error.code,
+                    message: error.message,
+                    data: error.data,
+                });
+            }
+            else if (error instanceof Error) {
+                this._updateTaskStatus(taskId, 'failed', error.message, undefined, {
+                    code: MCP.INTERNAL_ERROR,
+                    message: error.message,
+                });
+            }
+            else {
+                this._updateTaskStatus(taskId, 'failed', 'Unknown error', undefined, {
+                    code: MCP.INTERNAL_ERROR,
+                    message: 'Unknown error',
+                });
+            }
+        }
+    }
+    _updateTaskStatus(taskId, status, statusMessage, result, error) {
+        const entry = this._serverTasks.get(taskId);
+        if (!entry) {
+            return;
+        }
+        entry.task.status = status;
+        if (statusMessage !== undefined) {
+            entry.task.statusMessage = statusMessage;
+        }
+        if (result !== undefined) {
+            entry.result = result;
+        }
+        if (error !== undefined) {
+            entry.error = error;
+        }
+        this._onDidUpdateTask.fire({ ...entry.task });
+    }
+    getTask(taskId) {
+        const entry = this._serverTasks.get(taskId);
+        if (!entry) {
+            throw ( new McpError(MCP.INVALID_PARAMS, `Task not found: ${taskId}`));
+        }
+        return { ...entry.task };
+    }
+    async getTaskResult(taskId) {
+        const entry = this._serverTasks.get(taskId);
+        if (!entry) {
+            throw ( new McpError(MCP.INVALID_PARAMS, `Task not found: ${taskId}`));
+        }
+        if (entry.task.status === 'working' || entry.task.status === 'input_required') {
+            await entry.executionPromise;
+        }
+        const updatedEntry = this._serverTasks.get(taskId);
+        if (!updatedEntry) {
+            throw ( new McpError(MCP.INVALID_PARAMS, `Task not found: ${taskId}`));
+        }
+        if (updatedEntry.error) {
+            throw ( new McpError(
+                updatedEntry.error.code,
+                updatedEntry.error.message,
+                updatedEntry.error.data
+            ));
+        }
+        if (!updatedEntry.result) {
+            throw ( new McpError(MCP.INTERNAL_ERROR, 'Task completed but no result available'));
+        }
+        return updatedEntry.result;
+    }
+    cancelTask(taskId) {
+        const entry = this._serverTasks.get(taskId);
+        if (!entry) {
+            throw ( new McpError(MCP.INVALID_PARAMS, `Task not found: ${taskId}`));
+        }
+        if (entry.task.status === 'completed' || entry.task.status === 'failed' || entry.task.status === 'cancelled') {
+            throw ( new McpError(MCP.INVALID_PARAMS, `Cannot cancel task in ${entry.task.status} status`));
+        }
+        entry.task.status = 'cancelled';
+        entry.task.statusMessage = 'Task was cancelled by the client';
+        entry.cts.cancel();
+        return { ...entry.task };
+    }
+    listTasks() {
+        const tasks = [];
+        for (const entry of ( this._serverTasks.values())) {
+            tasks.push({ ...entry.task });
+        }
+        return { tasks };
+    }
+}
+
+export { McpTaskManager };

package/vscode/src/vs/workbench/services/authentication/browser/authenticationMcpService.js

@@ -11,7 +11,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/noti
 import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { NumberBadge } from '@codingame/monaco-vscode-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-common/vscode/vs/workbench/services/activity/common/activity';
+import { NumberBadge } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity';
 import { IActivityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity.service';
 import { IAuthenticationMcpAccessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/browser/authenticationMcpAccessService.service';
 import { IAuthenticationMcpUsageService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/browser/authenticationMcpUsageService.service';
@@ -112,7 +112,7 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             numberOfRequests += ( Object.keys(accessRequest)).length;
         });
         if (numberOfRequests > 0) {
-            const badge = ( new NumberBadge(numberOfRequests, () => ( localize(13527, "Sign in requested"))));
+            const badge = ( new NumberBadge(numberOfRequests, () => ( localize(13669, "Sign in requested"))));
             this._accountBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
         }
     }
@@ -173,7 +173,7 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
         const { result } = await this.dialogService.prompt({
             type: Severity.Info,
             message: ( localize(
-                13528,
+                13670,
                 "The MCP server '{0}' wants to access the {1} account '{2}'.",
                 mcpServerName,
                 provider.label,
@@ -181,11 +181,11 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             )),
             buttons: [
                 {
-                    label: ( localize(13529, "&&Allow")),
+                    label: ( localize(13671, "&&Allow")),
                     run: () => SessionPromptChoice.Allow
                 },
                 {
-                    label: ( localize(13530, "&&Deny")),
+                    label: ( localize(13672, "&&Deny")),
                     run: () => SessionPromptChoice.Deny
                 }
             ],
@@ -221,16 +221,16 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
                 items.push({ label: account.label, account });
             }
         });
-        items.push({ label: ( localize(13531, "Sign in to another account")) });
+        items.push({ label: ( localize(13673, "Sign in to another account")) });
         quickPick.items = items;
         quickPick.title = ( localize(
-            13532,
+            13674,
             "The MCP server '{0}' wants to access a {1} account",
             mcpServerName,
             this._authenticationService.getProvider(providerId).label
         ));
         quickPick.placeholder = ( localize(
-            13533,
+            13675,
             "Select an account for '{0}' to use or Esc to cancel",
             mcpServerName
         ));
@@ -302,7 +302,7 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             group: '3_accessRequests',
             command: {
                 id: `${providerId}${mcpServerId}Access`,
-                title: ( localize(13534, "Grant access to {0} for {1}... (1)", provider.label, mcpServerName))
+                title: ( localize(13676, "Grant access to {0} for {1}... (1)", provider.label, mcpServerName))
             }
         }));
         const accessCommand = CommandsRegistry.registerCommand({
@@ -346,7 +346,7 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             group: '2_signInRequests',
             command: {
                 id: commandId,
-                title: ( localize(13535, "Sign in with {0} to use {1} (1)", provider.label, mcpServerName))
+                title: ( localize(13677, "Sign in with {0} to use {1} (1)", provider.label, mcpServerName))
             }
         }));
         const signInCommand = CommandsRegistry.registerCommand({