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

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

@@ -1,18 +1,19 @@
 
 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, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { softAssertNever, assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { IntervalTimer, isThenable, 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 { JsonRpcProtocol, JsonRpcError } from '../../../../base/common/jsonRpcProtocol.js';
 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 { translateMcpLogMessage, 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 { MCP } from '@codingame/monaco-vscode-api/vscode/vs/platform/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';
@@ -111,8 +112,6 @@ class McpServerRequestHandler extends Disposable {
         }
     ) {
         super();
-        this._nextRequestId = 1;
-        this._pendingRequests = ( new Map());
         this._hasAnnouncedRoots = false;
         this._roots = [];
         this._onDidReceiveCancelledNotification = this._register(( new Emitter()));
@@ -135,6 +134,10 @@ class McpServerRequestHandler extends Disposable {
         this._createMessageRequestHandler = createMessageRequestHandler;
         this._elicitationRequestHandler = elicitationRequestHandler;
         this._taskManager = taskManager;
+        this._rpc = this._register(( new JsonRpcProtocol(message => this.send(message), {
+            handleRequest: (request, token) => this.handleServerRequest(request, token),
+            handleNotification: notification => this.handleServerNotification(notification)
+        })));
         this._taskManager.setHandler(this);
         this._register(this._taskManager.onDidUpdateTask(task => {
             this.send({
@@ -144,7 +147,16 @@ class McpServerRequestHandler extends Disposable {
             });
         }));
         this._register(toDisposable(() => this._taskManager.setHandler(undefined)));
-        this._register(launch.onDidReceiveMessage(message => this.handleMessage(message)));
+        this._register(launch.onDidReceiveMessage(message => {
+            if (canLog(this.logger.getLevel(), this._requestLogLevel)) {
+                log(
+                    this.logger,
+                    this._requestLogLevel,
+                    `[server -> editor] ${JSON.stringify(message)}`
+                );
+            }
+            void this._rpc.handleMessage(message);
+        }));
         this._register(autorun(reader => {
             const state = launch.state.read(reader).state;
             if (state === McpConnectionState.Kind.Error || state === McpConnectionState.Kind.Stopped) {
@@ -159,35 +171,17 @@ class McpServerRequestHandler extends Disposable {
         if (this._store.isDisposed) {
             return Promise.reject(( new CancellationError()));
         }
-        const id = this._nextRequestId++;
-        const jsonRpcRequest = {
-            jsonrpc: MCP.JSONRPC_VERSION,
-            id,
-            ...request
-        };
-        const promise = ( new DeferredPromise());
-        this._pendingRequests.set(id, {
-            promise
-        });
-        const cancelListener = token.onCancellationRequested(() => {
-            if (!promise.isSettled) {
-                this._pendingRequests.delete(id);
-                this.sendNotification({
-                    method: "notifications/cancelled",
-                    params: {
-                        requestId: id
-                    }
-                });
-                promise.cancel();
+        return this._rpc.sendRequest(request, token, id => this.sendNotification({
+            method: "notifications/cancelled",
+            params: {
+                requestId: id
             }
-            cancelListener.dispose();
-        });
-        this.send(jsonRpcRequest);
-        const ret = promise.p.finally(() => {
-            cancelListener.dispose();
-            this._pendingRequests.delete(id);
+        })).catch(error => {
+            if (error instanceof JsonRpcError) {
+                throw ( new MpcResponseError(error.message, error.code, error.data));
+            }
+            throw error;
         });
-        return ret;
     }
     send(mcp) {
         if (canLog(this.logger.getLevel(), this._requestLogLevel)) {
@@ -220,54 +214,21 @@ class McpServerRequestHandler extends Disposable {
             jsonrpc: MCP.JSONRPC_VERSION
         });
     }
-    handleMessage(message) {
-        if (canLog(this.logger.getLevel(), this._requestLogLevel)) {
-            log(
-                this.logger,
-                this._requestLogLevel,
-                `[server -> editor] ${JSON.stringify(message)}`
-            );
-        }
-        if ("id" in message) {
-            if ("result" in message) {
-                this.handleResult(message);
-            } else if ("error" in message) {
-                this.handleError(message);
-            }
-        }
-        if ("method" in message) {
-            if ("id" in message) {
-                this.handleServerRequest(message);
-            } else {
-                this.handleServerNotification(message);
-            }
-        }
-    }
-    handleResult(response) {
-        if (response.id !== undefined) {
-            const request = this._pendingRequests.get(response.id);
-            if (request) {
-                this._pendingRequests.delete(response.id);
-                request.promise.complete(response.result);
-            }
-        }
-    }
-    handleError(response) {
-        if (response.id !== undefined) {
-            const request = this._pendingRequests.get(response.id);
-            if (request) {
-                this._pendingRequests.delete(response.id);
-                request.promise.error(( new MpcResponseError(response.error.message, response.error.code, response.error.data)));
+    handleServerRequest(request, token) {
+        const mapError = error => {
+            if (error instanceof McpError) {
+                return ( new JsonRpcError(error.code, error.message, error.data));
             }
-        }
-    }
-    async handleServerRequest(request) {
+            this.logger.error(`Error handling request ${request.method}:`, error);
+            const mcpError = McpError.unknown(error instanceof Error ? error : ( new Error(String(error))));
+            return ( new JsonRpcError(mcpError.code, mcpError.message, mcpError.data));
+        };
         try {
-            let response;
+            let result;
             if (request.method === "ping") {
-                response = this.handlePing(request);
+                result = this.handlePing(request);
             } else if (request.method === "roots/list") {
-                response = this.handleRootsList(request);
+                result = this.handleRootsList(request);
             } else if (request.method === "sampling/createMessage" && this._createMessageRequestHandler) {
                 if (request.params.task) {
                     const taskResult = this._taskManager.createTask(
@@ -278,9 +239,9 @@ class McpServerRequestHandler extends Disposable {
                     taskResult._meta["io.modelcontextprotocol/related-task"] = {
                         taskId: taskResult.task.taskId
                     };
-                    response = taskResult;
+                    result = taskResult;
                 } else {
-                    response = await this._createMessageRequestHandler(request.params);
+                    result = this._createMessageRequestHandler(request.params, token);
                 }
             } else if (request.method === "elicitation/create" && this._elicitationRequestHandler) {
                 if (request.params.task) {
@@ -292,89 +253,75 @@ class McpServerRequestHandler extends Disposable {
                     taskResult._meta["io.modelcontextprotocol/related-task"] = {
                         taskId: taskResult.task.taskId
                     };
-                    response = taskResult;
+                    result = taskResult;
                 } else {
-                    response = await this._elicitationRequestHandler(request.params);
+                    result = this._elicitationRequestHandler(request.params, token);
                 }
             } else if (request.method === "tasks/get") {
-                response = this._taskManager.getTask(request.params.taskId);
+                result = this._taskManager.getTask(request.params.taskId);
             } else if (request.method === "tasks/result") {
-                response = await this._taskManager.getTaskResult(request.params.taskId);
+                result = this._taskManager.getTaskResult(request.params.taskId);
             } else if (request.method === "tasks/cancel") {
-                response = this._taskManager.cancelTask(request.params.taskId);
+                result = this._taskManager.cancelTask(request.params.taskId);
             } else if (request.method === "tasks/list") {
-                response = this._taskManager.listTasks();
+                result = this._taskManager.listTasks();
             } else {
                 throw McpError.methodNotFound(request.method);
             }
-            this.respondToRequest(request, response);
-        } catch (e) {
-            if (!(e instanceof McpError)) {
-                this.logger.error(`Error handling request ${request.method}:`, e);
-                e = McpError.unknown(e);
+            if (isThenable(result)) {
+                return result.then(undefined, error => {
+                    throw mapError(error);
+                });
             }
-            const errorResponse = {
-                jsonrpc: MCP.JSONRPC_VERSION,
-                id: request.id,
-                error: {
-                    code: e.code,
-                    message: e.message,
-                    data: e.data
-                }
-            };
-            this.send(errorResponse);
+            return result;
+        } catch (e) {
+            throw mapError(e);
         }
     }
     handleServerNotification(request) {
-        switch (request.method) {
-        case "notifications/message":
-            return this.handleLoggingNotification(request);
-        case "notifications/cancelled":
-            this._onDidReceiveCancelledNotification.fire(request);
-            return this.handleCancelledNotification(request);
-        case "notifications/progress":
-            this._onDidReceiveProgressNotification.fire(request);
-            return;
-        case "notifications/resources/list_changed":
-            this._onDidChangeResourceList.fire();
-            return;
-        case "notifications/resources/updated":
-            this._onDidUpdateResource.fire(request);
-            return;
-        case "notifications/tools/list_changed":
-            this._onDidChangeToolList.fire();
-            return;
-        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;
+        try {
+            switch (request.method) {
+            case "notifications/message":
+                return this.handleLoggingNotification(request);
+            case "notifications/cancelled":
+                this._onDidReceiveCancelledNotification.fire(request);
+                return this.handleCancelledNotification(request);
+            case "notifications/progress":
+                this._onDidReceiveProgressNotification.fire(request);
+                return;
+            case "notifications/resources/list_changed":
+                this._onDidChangeResourceList.fire();
+                return;
+            case "notifications/resources/updated":
+                this._onDidUpdateResource.fire(request);
+                return;
+            case "notifications/tools/list_changed":
+                this._onDidChangeToolList.fire();
+                return;
+            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;
+            default:
+                softAssertNever(request);
+            }
+        } catch (error) {
+            this.logger.error(`Error handling notification ${request.method}:`, error);
         }
     }
     handleCancelledNotification(request) {
         if (request.params.requestId) {
-            const pendingRequest = this._pendingRequests.get(request.params.requestId);
-            if (pendingRequest) {
-                this._pendingRequests.delete(request.params.requestId);
-                pendingRequest.promise.cancel();
-            }
+            this._rpc.cancelPendingRequest(request.params.requestId);
         }
     }
     handleLoggingNotification(request) {
         translateMcpLogMessage(this.logger, request.params);
     }
-    respondToRequest(request, result) {
-        const response = {
-            jsonrpc: MCP.JSONRPC_VERSION,
-            id: request.id,
-            result
-        };
-        this.send(response);
-    }
     handlePing(_request) {
         return {};
     }
@@ -385,8 +332,7 @@ class McpServerRequestHandler extends Disposable {
         };
     }
     cancelAllRequests() {
-        this._pendingRequests.forEach(pending => pending.promise.cancel());
-        this._pendingRequests.clear();
+        this._rpc.cancelAllRequests();
     }
     dispose() {
         this.cancelAllRequests();
@@ -458,13 +404,13 @@ class McpServerRequestHandler extends Disposable {
             this.sendRequestPaginated("tools/list", result => result.tools, params, token)
         );
     }
-    async callTool(params, token) {
+    async callTool(params, token, onStatusMessage) {
         const response = await this.sendRequest({
             method: "tools/call",
             params
         }, token);
         if (isTaskResult(response)) {
-            const task = ( new McpTask(response.task, token));
+            const task = ( new McpTask(response.task, token, onStatusMessage));
             this._taskManager.adoptClientTask(task);
             task.setHandler(this);
             return task.result.finally(() => {
@@ -519,9 +465,10 @@ class McpTask extends Disposable {
     get id() {
         return this._task.taskId;
     }
-    constructor(_task, _token = CancellationToken.None) {
+    constructor(_task, _token = CancellationToken.None, _onStatusMessage) {
         super();
         this._task = _task;
+        this._onStatusMessage = _onStatusMessage;
         this.promise = ( new DeferredPromise());
         this._handler = observableValue("mcpTaskHandler", undefined);
         const expiresAt = _task.ttl ? (Date.now() + _task.ttl) : undefined;
@@ -657,6 +604,9 @@ class McpTask extends Disposable {
     }
     onDidUpdateState(task) {
         this._lastTaskState.set(task, undefined);
+        if (task.statusMessage && this._onStatusMessage) {
+            this._onStatusMessage(task.statusMessage);
+        }
     }
     setHandler(handler) {
         this._handler.set(handler, undefined);

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

@@ -120,7 +120,7 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             numberOfRequests += ( Object.keys(accessRequest)).length;
         });
         if (numberOfRequests > 0) {
-            const badge = ( new NumberBadge(numberOfRequests, () => ( localize(14298, "Sign in requested"))));
+            const badge = ( new NumberBadge(numberOfRequests, () => ( localize(15424, "Sign in requested"))));
             this._accountBadgeDisposable.value = this.activityService.showAccountsActivity({
                 badge
             });
@@ -194,17 +194,17 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
         } = await this.dialogService.prompt({
             type: Severity.Info,
             message: ( localize(
-                14299,
+                15425,
                 "The MCP server '{0}' wants to access the {1} account '{2}'.",
                 mcpServerName,
                 provider.label,
                 accountName
             )),
             buttons: [{
-                label: ( localize(14300, "&&Allow")),
+                label: ( localize(15426, "&&Allow")),
                 run: () => SessionPromptChoice.Allow
             }, {
-                label: ( localize(14301, "&&Deny")),
+                label: ( localize(15427, "&&Deny")),
                 run: () => SessionPromptChoice.Deny
             }],
             cancelButton: {
@@ -246,17 +246,17 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             }
         });
         items.push({
-            label: ( localize(14302, "Sign in to another account"))
+            label: ( localize(15428, "Sign in to another account"))
         });
         quickPick.items = items;
         quickPick.title = ( localize(
-            14303,
+            15429,
             "The MCP server '{0}' wants to access a {1} account",
             mcpServerName,
             this._authenticationService.getProvider(providerId).label
         ));
         quickPick.placeholder = ( localize(
-            14304,
+            15430,
             "Select an account for '{0}' to use or Esc to cancel",
             mcpServerName
         ));
@@ -336,7 +336,7 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             group: "3_accessRequests",
             command: {
                 id: `${providerId}${mcpServerId}Access`,
-                title: ( localize(14305, "Grant access to {0} for {1}... (1)", provider.label, mcpServerName))
+                title: ( localize(15431, "Grant access to {0} for {1}... (1)", provider.label, mcpServerName))
             }
         }));
         const accessCommand = CommandsRegistry.registerCommand({
@@ -380,7 +380,7 @@ let AuthenticationMcpService = class AuthenticationMcpService extends Disposable
             group: "2_signInRequests",
             command: {
                 id: commandId,
-                title: ( localize(14306, "Sign in with {0} to use {1} (1)", provider.label, mcpServerName))
+                title: ( localize(15432, "Sign in with {0} to use {1} (1)", provider.label, mcpServerName))
             }
         }));
         const signInCommand = CommandsRegistry.registerCommand({

package/vscode/src/vs/workbench/services/mcp/browser/mcpWorkbenchManagementService.d.ts

@@ -5,7 +5,7 @@ import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/plat
 import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
 import { IUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
 import { IRemoteUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles.service";
-import { WorkbenchMcpManagementService as BaseWorkbenchMcpManagementService } from "../common/mcpWorkbenchManagementService.js";
+import { WorkbenchMcpManagementService as BaseWorkbenchMcpManagementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService";
 import { IAllowedMcpServersService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 export declare class WorkbenchMcpManagementService extends BaseWorkbenchMcpManagementService {

package/vscode/src/vs/workbench/services/mcp/browser/mcpWorkbenchManagementService.js

@@ -8,9 +8,9 @@ import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { IRemoteUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles.service';
-import { WorkbenchMcpManagementService as WorkbenchMcpManagementService$1 } from '../common/mcpWorkbenchManagementService.js';
+import { WorkbenchMcpManagementService as WorkbenchMcpManagementService$1 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService';
 import { IAllowedMcpServersService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service';
-import { McpManagementService } from '../../../../platform/mcp/common/mcpManagementService.js';
+import { McpManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagementService';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 
 let WorkbenchMcpManagementService = class WorkbenchMcpManagementService extends WorkbenchMcpManagementService$1 {

package/vscode/src/vs/platform/mcp/common/mcpManagementIpc.d.ts

@@ -1,42 +0,0 @@
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IURITransformer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uriIpc";
-import { IChannel, IServerChannel } from "@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { RemoteAgentConnectionContext } from "@codingame/monaco-vscode-api/vscode/vs/platform/remote/common/remoteAgentEnvironment";
-import { DidUninstallMcpServerEvent, IGalleryMcpServer, ILocalMcpServer, IInstallableMcpServer, InstallMcpServerEvent, InstallMcpServerResult, InstallOptions, UninstallMcpServerEvent, UninstallOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement";
-import { IAllowedMcpServersService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service";
-import { IMcpManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service";
-import { AbstractMcpManagementService } from "./mcpManagementService.js";
-export declare class McpManagementChannel<TContext = RemoteAgentConnectionContext | string> implements IServerChannel<TContext> {
-    private service;
-    private getUriTransformer;
-    readonly onInstallMcpServer: Event<InstallMcpServerEvent>;
-    readonly onDidInstallMcpServers: Event<readonly InstallMcpServerResult[]>;
-    readonly onDidUpdateMcpServers: Event<readonly InstallMcpServerResult[]>;
-    readonly onUninstallMcpServer: Event<UninstallMcpServerEvent>;
-    readonly onDidUninstallMcpServer: Event<DidUninstallMcpServerEvent>;
-    constructor(service: IMcpManagementService, getUriTransformer: (requestContext: TContext) => IURITransformer | null);
-    listen<T>(context: TContext, event: string): Event<T>;
-    call<T>(context: TContext, command: string, args?: unknown): Promise<T>;
-}
-export declare class McpManagementChannelClient extends AbstractMcpManagementService implements IMcpManagementService {
-    private readonly channel;
-    readonly _serviceBrand: undefined;
-    private readonly _onInstallMcpServer;
-    get onInstallMcpServer(): Event<InstallMcpServerEvent>;
-    private readonly _onDidInstallMcpServers;
-    get onDidInstallMcpServers(): Event<readonly InstallMcpServerResult[]>;
-    private readonly _onUninstallMcpServer;
-    get onUninstallMcpServer(): Event<UninstallMcpServerEvent>;
-    private readonly _onDidUninstallMcpServer;
-    get onDidUninstallMcpServer(): Event<DidUninstallMcpServerEvent>;
-    private readonly _onDidUpdateMcpServers;
-    get onDidUpdateMcpServers(): Event<InstallMcpServerResult[]>;
-    constructor(channel: IChannel, allowedMcpServersService: IAllowedMcpServersService, logService: ILogService);
-    install(server: IInstallableMcpServer, options?: InstallOptions): Promise<ILocalMcpServer>;
-    installFromGallery(extension: IGalleryMcpServer, installOptions?: InstallOptions): Promise<ILocalMcpServer>;
-    uninstall(extension: ILocalMcpServer, options?: UninstallOptions): Promise<void>;
-    getInstalled(mcpResource?: URI): Promise<ILocalMcpServer[]>;
-    updateMetadata(local: ILocalMcpServer, gallery: IGalleryMcpServer, mcpResource?: URI): Promise<ILocalMcpServer>;
-}

package/vscode/src/vs/platform/mcp/common/mcpManagementIpc.js

@@ -1,105 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { DefaultURITransformer, transformAndReviveIncomingURIs } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uriIpc';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { IAllowedMcpServersService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement.service';
-import { AbstractMcpManagementService } from './mcpManagementService.js';
-
-function transformIncomingURI(uri, transformer) {
-    return uri ? URI.revive(uri) : undefined;
-}
-function transformIncomingServer(mcpServer, transformer) {
-    transformer = transformer ? transformer : DefaultURITransformer;
-    const manifest = mcpServer.manifest;
-    const transformed = transformAndReviveIncomingURIs({
-        ...mcpServer,
-        ...{
-            manifest: undefined
-        }
-    }, transformer);
-    return {
-        ...transformed,
-        ...{
-            manifest
-        }
-    };
-}
-let McpManagementChannelClient = class McpManagementChannelClient extends AbstractMcpManagementService {
-    get onInstallMcpServer() {
-        return this._onInstallMcpServer.event;
-    }
-    get onDidInstallMcpServers() {
-        return this._onDidInstallMcpServers.event;
-    }
-    get onUninstallMcpServer() {
-        return this._onUninstallMcpServer.event;
-    }
-    get onDidUninstallMcpServer() {
-        return this._onDidUninstallMcpServer.event;
-    }
-    get onDidUpdateMcpServers() {
-        return this._onDidUpdateMcpServers.event;
-    }
-    constructor(channel, allowedMcpServersService, logService) {
-        super(allowedMcpServersService, logService);
-        this.channel = channel;
-        this._onInstallMcpServer = this._register(( new Emitter()));
-        this._onDidInstallMcpServers = this._register(( new Emitter()));
-        this._onUninstallMcpServer = this._register(( new Emitter()));
-        this._onDidUninstallMcpServer = this._register(( new Emitter()));
-        this._onDidUpdateMcpServers = this._register(( new Emitter()));
-        this._register(
-            this.channel.listen("onInstallMcpServer")(e => this._onInstallMcpServer.fire(({
-                ...e,
-                mcpResource: transformIncomingURI(e.mcpResource)
-            })))
-        );
-        this._register(
-            this.channel.listen("onDidInstallMcpServers")(results => this._onDidInstallMcpServers.fire(( results.map(e => ({
-                ...e,
-                local: e.local ? transformIncomingServer(e.local, null) : e.local,
-                mcpResource: transformIncomingURI(e.mcpResource)
-            })))))
-        );
-        this._register(
-            this.channel.listen("onDidUpdateMcpServers")(results => this._onDidUpdateMcpServers.fire(( results.map(e => ({
-                ...e,
-                local: e.local ? transformIncomingServer(e.local, null) : e.local,
-                mcpResource: transformIncomingURI(e.mcpResource)
-            })))))
-        );
-        this._register(
-            this.channel.listen("onUninstallMcpServer")(e => this._onUninstallMcpServer.fire(({
-                ...e,
-                mcpResource: transformIncomingURI(e.mcpResource)
-            })))
-        );
-        this._register(
-            this.channel.listen("onDidUninstallMcpServer")(e => this._onDidUninstallMcpServer.fire(({
-                ...e,
-                mcpResource: transformIncomingURI(e.mcpResource)
-            })))
-        );
-    }
-    install(server, options) {
-        return Promise.resolve(this.channel.call("install", [server, options])).then(local => transformIncomingServer(local, null));
-    }
-    installFromGallery(extension, installOptions) {
-        return Promise.resolve(this.channel.call("installFromGallery", [extension, installOptions])).then(local => transformIncomingServer(local, null));
-    }
-    uninstall(extension, options) {
-        return Promise.resolve(this.channel.call("uninstall", [extension, options]));
-    }
-    getInstalled(mcpResource) {
-        return Promise.resolve(this.channel.call("getInstalled", [mcpResource])).then(servers => ( servers.map(server => transformIncomingServer(server, null))));
-    }
-    updateMetadata(local, gallery, mcpResource) {
-        return Promise.resolve(this.channel.call("updateMetadata", [local, gallery, mcpResource])).then(local => transformIncomingServer(local, null));
-    }
-};
-McpManagementChannelClient = ( __decorate([( __param(1, IAllowedMcpServersService)), ( __param(2, ILogService))], McpManagementChannelClient));
-
-export { McpManagementChannelClient };