@codingame/monaco-vscode-mcp-service-override 17.2.0 → 18.0.0

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

@@ -0,0 +1,256 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { mapFindFirst } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ConfigurationTarget, getConfigValueInTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { McpCommandIds } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
+import { mcpServerSamplingSection } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { McpSamplingLog } from './mcpSamplingLog.js';
+import { McpError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+
+var ModelMatch;
+(function (ModelMatch) {
+    ModelMatch[ModelMatch["UnsureAllowedDuringChat"] = 0] = "UnsureAllowedDuringChat";
+    ModelMatch[ModelMatch["UnsureAllowedOutsideChat"] = 1] = "UnsureAllowedOutsideChat";
+    ModelMatch[ModelMatch["NotAllowed"] = 2] = "NotAllowed";
+    ModelMatch[ModelMatch["NoMatchingModel"] = 3] = "NoMatchingModel";
+})(ModelMatch || (ModelMatch = {}));
+let McpSamplingService = class McpSamplingService extends Disposable {
+    constructor(_languageModelsService, _configurationService, _dialogService, _notificationService, _commandService, instaService) {
+        super();
+        this._languageModelsService = _languageModelsService;
+        this._configurationService = _configurationService;
+        this._dialogService = _dialogService;
+        this._notificationService = _notificationService;
+        this._commandService = _commandService;
+        this._sessionSets = {
+            allowedDuringChat: ( new Map()),
+            allowedOutsideChat: ( new Map()),
+        };
+        this._logs = this._register(instaService.createInstance(McpSamplingLog));
+    }
+    async sample(opts, token = CancellationToken.None) {
+        const messages = ( opts.params.messages.map((message) => {
+            const content = message.content.type === 'text'
+                ? { type: 'text', value: message.content.text }
+                : message.content.type === 'image' || message.content.type === 'audio'
+                    ? { type: 'image_url', value: { mimeType: message.content.mimeType, data: decodeBase64(message.content.data) } }
+                    : undefined;
+            if (!content) {
+                return undefined;
+            }
+            return {
+                role: message.role === 'assistant' ? ChatMessageRole.Assistant : ChatMessageRole.User,
+                content: [content]
+            };
+        })).filter(isDefined);
+        const model = await this._getMatchingModel(opts);
+        const response = await this._languageModelsService.sendChatRequest(model, ( new ExtensionIdentifier('Github.copilot-chat')), messages, {}, token);
+        let responseText = '';
+        const streaming = (async () => {
+            for await (const part of response.stream) {
+                if (Array.isArray(part)) {
+                    for (const p of part) {
+                        if (p.part.type === 'text') {
+                            responseText += p.part.value;
+                        }
+                    }
+                }
+                else if (part.part.type === 'text') {
+                    responseText += part.part.value;
+                }
+            }
+        })();
+        try {
+            await Promise.all([response.result, streaming]);
+            this._logs.add(opts.server, opts.params.messages, responseText, model);
+            return {
+                sample: {
+                    model,
+                    content: { type: 'text', text: responseText },
+                    role: 'assistant',
+                },
+            };
+        }
+        catch (err) {
+            throw McpError.unknown(err);
+        }
+    }
+    hasLogs(server) {
+        return ( this._logs.has(server));
+    }
+    getLogText(server) {
+        return this._logs.getAsText(server);
+    }
+    async _getMatchingModel(opts) {
+        const model = await this._getMatchingModelInner(opts.server, opts.isDuringToolCall, opts.params.modelPreferences);
+        if (model === ModelMatch.UnsureAllowedDuringChat) {
+            const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
+                7957,
+                'Allow MCP tools from "{0}" to make LLM requests?',
+                opts.server.definition.label
+            )), ( localize(
+                7958,
+                'The MCP server "{0}" has issued a request to make an language model call. Do you want to allow it to make requests during chat?',
+                opts.server.definition.label
+            )), this.allowButtons(opts.server, 'allowedDuringChat'));
+            if (retry) {
+                return this._getMatchingModel(opts);
+            }
+            throw McpError.notAllowed();
+        }
+        else if (model === ModelMatch.UnsureAllowedOutsideChat) {
+            const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
+                7959,
+                'Allow MCP server "{0}" to make LLM requests?',
+                opts.server.definition.label
+            )), ( localize(
+                7960,
+                'The MCP server "{0}" has issued a request to make an language model call. Do you want to allow it to make requests, outside of tool calls during chat?',
+                opts.server.definition.label
+            )), this.allowButtons(opts.server, 'allowedOutsideChat'));
+            if (retry) {
+                return this._getMatchingModel(opts);
+            }
+            throw McpError.notAllowed();
+        }
+        else if (model === ModelMatch.NotAllowed) {
+            throw McpError.notAllowed();
+        }
+        else if (model === ModelMatch.NoMatchingModel) {
+            const newlyPickedModels = opts.isDuringToolCall
+                ? await this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server)
+                : await this._notify(( localize(
+                7961,
+                'MCP server "{0}" triggered a language model request, but it has no allowlisted models.',
+                opts.server.definition.label
+            )), {
+                    [( localize(7962, 'Configure'))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
+                    [( localize(7963, 'Cancel'))]: () => Promise.resolve(undefined),
+                });
+            if (newlyPickedModels) {
+                return this._getMatchingModel(opts);
+            }
+            throw McpError.notAllowed();
+        }
+        return model;
+    }
+    allowButtons(server, key) {
+        return {
+            [( localize(7964, 'Allow in this Session'))]: async () => {
+                this._sessionSets[key].set(server.definition.id, true);
+                return true;
+            },
+            [( localize(7965, 'Always'))]: async () => {
+                await this.updateConfig(server, c => c[key] = true);
+                return true;
+            },
+            [( localize(7966, 'Not Now'))]: async () => {
+                this._sessionSets[key].set(server.definition.id, false);
+                return false;
+            },
+            [( localize(7967, 'Never'))]: async () => {
+                await this.updateConfig(server, c => c[key] = false);
+                return false;
+            },
+        };
+    }
+    async _showContextual(isDuringToolCall, title, message, buttons) {
+        if (isDuringToolCall) {
+            const result = await this._dialogService.prompt({
+                type: 'question',
+                title: title,
+                message,
+                buttons: ( Object.entries(buttons).map(([label, run]) => ({ label, run }))),
+            });
+            return await result.result;
+        }
+        else {
+            return await this._notify(message, buttons);
+        }
+    }
+    async _notify(message, buttons) {
+        return await ( new Promise(resolve => {
+            const handle = this._notificationService.prompt(Severity.Info, message, ( Object.entries(buttons).map(([label, action]) => ({
+                label,
+                run: () => resolve(action()),
+            }))));
+            Event.once(handle.onDidClose)(() => resolve(undefined));
+        }));
+    }
+    async _getMatchingModelInner(server, isDuringToolCall, preferences) {
+        const config = this.getConfig(server);
+        if (isDuringToolCall && !config.allowedDuringChat && !( this._sessionSets.allowedDuringChat.has(server.definition.id))) {
+            return config.allowedDuringChat === undefined ? ModelMatch.UnsureAllowedDuringChat : ModelMatch.NotAllowed;
+        }
+        else if (!isDuringToolCall && !config.allowedOutsideChat && !( this._sessionSets.allowedOutsideChat.has(server.definition.id))) {
+            return config.allowedOutsideChat === undefined ? ModelMatch.UnsureAllowedOutsideChat : ModelMatch.NotAllowed;
+        }
+        const foundModelIdsDeep = config.allowedModels?.filter(m => !!this._languageModelsService.lookupLanguageModel(m)) || this._languageModelsService.getLanguageModelIds().filter(m => this._languageModelsService.lookupLanguageModel(m)?.isDefault);
+        const foundModelIds = foundModelIdsDeep.flat().sort((a, b) => b.length - a.length);
+        if (!foundModelIds.length) {
+            return ModelMatch.NoMatchingModel;
+        }
+        if (preferences?.hints) {
+            const found = mapFindFirst(preferences.hints, hint => foundModelIds.find(model => model.toLowerCase().includes(hint.name.toLowerCase())));
+            if (found) {
+                return found;
+            }
+        }
+        return foundModelIds[0];
+    }
+    _configKey(server) {
+        return `${server.collection.label}: ${server.definition.label}`;
+    }
+    getConfig(server) {
+        return this._getConfig(server).value || {};
+    }
+    _getConfig(server) {
+        const def = server.readDefinitions().get();
+        const mostSpecificConfig = ConfigurationTarget.MEMORY;
+        const leastSpecificConfig = def.collection?.configTarget || ConfigurationTarget.USER;
+        const key = this._configKey(server);
+        const resource = def.collection?.presentation?.origin;
+        const configValue = this._configurationService.inspect(mcpServerSamplingSection, { resource });
+        for (let target = mostSpecificConfig; target >= leastSpecificConfig; target--) {
+            const mapping = getConfigValueInTarget(configValue, target);
+            const config = mapping?.[key];
+            if (config) {
+                return { value: config, key, mapping, target, resource };
+            }
+        }
+        return { value: undefined, mapping: undefined, key, target: leastSpecificConfig, resource };
+    }
+    async updateConfig(server, mutate) {
+        const { value, mapping, key, target, resource } = this._getConfig(server);
+        const newConfig = { ...value };
+        mutate(newConfig);
+        await this._configurationService.updateValue(mcpServerSamplingSection, { ...mapping, [key]: newConfig }, { resource }, target);
+        return newConfig;
+    }
+};
+McpSamplingService = ( __decorate([
+    ( __param(0, ILanguageModelsService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IInstantiationService))
+], McpSamplingService));
+
+export { McpSamplingService };

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

@@ -16,11 +16,14 @@ import { IOutputService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
 import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
 import { McpServerRequestHandler } from "./mcpServerRequestHandler.js";
-import { IMcpServer, IMcpServerConnection, IMcpTool, McpCollectionReference, McpConnectionState, McpDefinitionReference, McpServerDefinition, McpServerToolsState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
-import { MCP } from "./modelContextProtocol.js";
+import { IMcpPrompt, IMcpResource, IMcpResourceTemplate, IMcpServer, IMcpServerConnection, IMcpServerStartOpts, IMcpTool, McpCapability, McpCollectionDefinition, McpCollectionReference, McpConnectionState, McpDefinitionReference, McpServerCacheState, McpServerDefinition } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpSamplingService } 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";
 interface IToolCacheEntry {
     readonly nonce: string | undefined;
     readonly tools: readonly IValidatedMcpTool[];
+    readonly prompts: readonly MCP.Prompt[] | undefined;
+    readonly capabilities: McpCapability | undefined;
 }
 interface IServerCacheEntry {
     readonly servers: readonly McpServerDefinition.Serialized[];
@@ -31,8 +34,8 @@ export declare class McpServerMetadataCache extends Disposable {
     private readonly extensionServers;
     constructor(scope: StorageScope, storageService: IStorageService);
     reset(): void;
-    getTools(definitionId: string): IToolCacheEntry | undefined;
-    storeTools(definitionId: string, nonce: string | undefined, tools: readonly IValidatedMcpTool[]): void;
+    get(definitionId: string): IToolCacheEntry | undefined;
+    store(definitionId: string, entry: IToolCacheEntry): void;
     getServers(collectionId: string): IServerCacheEntry | undefined;
     storeServers(collectionId: string, entry: IServerCacheEntry | undefined): void;
 }
@@ -43,7 +46,7 @@ export declare class McpServer extends Disposable implements IMcpServer {
     readonly collection: McpCollectionReference;
     readonly definition: McpDefinitionReference;
     private readonly _requiresExtensionActivation;
-    private readonly _toolCache;
+    private readonly _primitiveCache;
     private readonly _mcpRegistry;
     private readonly _extensionService;
     private readonly _loggerService;
@@ -53,33 +56,46 @@ export declare class McpServer extends Disposable implements IMcpServer {
     private readonly _instantiationService;
     private readonly _notificationService;
     private readonly _openerService;
+    private readonly _samplingService;
+    static callOn<R>(server: IMcpServer, fn: (handler: McpServerRequestHandler) => Promise<R>, token?: CancellationToken): Promise<R>;
     private readonly _connectionSequencer;
     private readonly _connection;
     readonly connection: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<IMcpServerConnection | undefined, void> & IDisposable;
     readonly connectionState: IObservable<McpConnectionState>;
-    private get toolsFromCache();
-    private readonly toolsFromServerPromise;
-    private readonly toolsFromServer;
-    readonly tools: IObservable<readonly IMcpTool[]>;
-    readonly toolsState: IObservable<McpServerToolsState>;
+    private readonly _capabilities;
+    get capabilities(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<number | undefined, void>;
+    private readonly _tools;
+    get tools(): IObservable<readonly IMcpTool[]>;
+    private readonly _prompts;
+    get prompts(): IObservable<readonly IMcpPrompt[]>;
+    private readonly _fullDefinitions;
+    readonly cacheState: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<McpServerCacheState, void>;
     private readonly _loggerId;
     private readonly _logger;
+    private _lastModeDebugged;
+    runningToolCalls: number;
     get trusted(): IObservable<boolean | undefined>;
-    constructor(collection: McpCollectionReference, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _toolCache: McpServerMetadataCache, _mcpRegistry: IMcpRegistry, workspacesService: IWorkspaceContextService, _extensionService: IExtensionService, _loggerService: ILoggerService, _outputService: IOutputService, _telemetryService: ITelemetryService, _commandService: ICommandService, _instantiationService: IInstantiationService, _notificationService: INotificationService, _openerService: IOpenerService);
+    constructor(collection: McpCollectionReference, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _primitiveCache: McpServerMetadataCache, toolPrefix: string, _mcpRegistry: IMcpRegistry, workspacesService: IWorkspaceContextService, _extensionService: IExtensionService, _loggerService: ILoggerService, _outputService: IOutputService, _telemetryService: ITelemetryService, _commandService: ICommandService, _instantiationService: IInstantiationService, _notificationService: INotificationService, _openerService: IOpenerService, _samplingService: IMcpSamplingService);
+    readDefinitions(): IObservable<{
+        server: McpServerDefinition | undefined;
+        collection: McpCollectionDefinition | undefined;
+    }>;
     showOutput(): void;
-    start(isFromInteraction?: boolean): Promise<McpConnectionState>;
+    resources(token?: CancellationToken): AsyncIterable<IMcpResource[]>;
+    resourceTemplates(token?: CancellationToken): Promise<IMcpResourceTemplate[]>;
+    start({ isFromInteraction, debug }?: IMcpServerStartOpts): Promise<McpConnectionState>;
     private showInteractiveError;
     stop(): Promise<void>;
     private resetLiveData;
     private _normalizeTool;
     private _getValidatedTools;
     private populateLiveData;
-    callOn<R>(fn: (handler: McpServerRequestHandler) => Promise<R>, token?: CancellationToken): Promise<R>;
 }
 export declare class McpTool implements IMcpTool {
     private readonly _server;
     private readonly _definition;
     readonly id: string;
+    readonly referenceName: string;
     get definition(): MCP.Tool;
     constructor(_server: McpServer, idPrefix: string, _definition: IValidatedMcpTool);
     call(params: Record<string, unknown>, token?: CancellationToken): Promise<MCP.CallToolResult>;