@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/embeddedExtensionToolsDetail.js

@@ -21,12 +21,12 @@ class EmbeddedExtensionToolsDetail extends Disposable {
         const toolsEl = append(this.root, $(".embedded-detail-tools"));
         this.toolsHeadingEl = append(toolsEl, $("h3.embedded-detail-tools-heading"));
         this.toolsHeadingEl.setAttribute("role", "heading");
-        this.toolsHeadingEl.textContent = ( localize(6008, "Included Tools"));
+        this.toolsHeadingEl.textContent = ( localize(6843, "Included Tools"));
         this.toolsMessageEl = append(toolsEl, $(".embedded-detail-tools-message"));
         this.toolsListEl = append(toolsEl, $(".embedded-detail-tools-list"));
         this.toolsListEl.setAttribute("role", "list");
         this.emptyEl = append(this.root, $(".embedded-detail-empty"));
-        this.emptyEl.textContent = ( localize(6009, "No extension selected."));
+        this.emptyEl.textContent = ( localize(6844, "No extension selected."));
         this.renderItem();
     }
     get element() {
@@ -63,7 +63,7 @@ class EmbeddedExtensionToolsDetail extends Disposable {
         this.nameEl.textContent = extension.displayName;
         const publisher = extension.publisherDisplayName;
         if (publisher) {
-            this.publisherEl.textContent = ( localize(6010, "by {0}", publisher));
+            this.publisherEl.textContent = ( localize(6845, "by {0}", publisher));
             this.publisherEl.style.display = "";
         } else {
             this.publisherEl.textContent = "";
@@ -77,7 +77,7 @@ class EmbeddedExtensionToolsDetail extends Disposable {
     loadTools(extension) {
         const cts = ( new CancellationTokenSource());
         this._manifestLoad.value = toDisposable(() => cts.dispose(true));
-        this.setToolsMessage(( localize(6011, "Loading tools...")));
+        this.setToolsMessage(( localize(6846, "Loading tools...")));
         clearNode(this.toolsListEl);
         extension.getManifest(cts.token).then(manifest => {
             if (cts.token.isCancellationRequested || this.current !== extension) {
@@ -89,7 +89,7 @@ class EmbeddedExtensionToolsDetail extends Disposable {
             if (cts.token.isCancellationRequested || this.current !== extension) {
                 return;
             }
-            const message = ( localize(6012, "Unable to load the tools for this extension."));
+            const message = ( localize(6847, "Unable to load the tools for this extension."));
             this.setToolsMessage(message);
             status(message);
         });
@@ -97,7 +97,7 @@ class EmbeddedExtensionToolsDetail extends Disposable {
     renderTools(tools) {
         clearNode(this.toolsListEl);
         if (tools.length === 0) {
-            const message = ( localize(6013, "This extension does not contribute any tools."));
+            const message = ( localize(6848, "This extension does not contribute any tools."));
             this.setToolsMessage(message);
             status(message);
             return;
@@ -112,7 +112,7 @@ class EmbeddedExtensionToolsDetail extends Disposable {
                 append(row, $(".embedded-detail-tool-description")).textContent = description;
             }
         }
-        status(tools.length === 1 ? ( localize(6014, "1 tool")) : ( localize(6015, "{0} tools", tools.length)));
+        status(tools.length === 1 ? ( localize(6849, "1 tool")) : ( localize(6850, "{0} tools", tools.length)));
     }
     setToolsMessage(message) {
         this.toolsMessageEl.textContent = message ?? "";

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/embeddedMcpServerDetail.d.ts

@@ -1,24 +1,50 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IWorkbenchMcpServer } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
+import { IWorkbenchMcpServer, McpServerInstallState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 import { IMcpWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
+export interface IMcpServerDetailInput {
+    readonly id: string;
+    readonly name: string;
+    readonly label: string;
+    readonly installState: McpServerInstallState;
+    readonly config?: IMcpServerConfiguration;
+    readonly source?: {
+        readonly uri: URI;
+        readonly range?: IRange;
+    };
+}
+export declare function createWorkbenchMcpServerDetailInput(server: IWorkbenchMcpServer): IMcpServerDetailInput;
 /**
- * Compact detail view for an MCP server inside the AI Customizations management editor's
- * split-pane host. Renders identity (icon + name + scope) and description.
- *
- * Advanced actions (enable / disable / uninstall / configure) remain accessible via the
- * row's existing context menu, so this component intentionally stays small.
+ * Detail view for an MCP server inside the AI Customizations management editor.
  */
 export declare class EmbeddedMcpServerDetail extends Disposable {
     private readonly mcpWorkbenchService;
+    private readonly instantiationService;
+    private readonly configurationService;
+    private readonly modelService;
+    private readonly languageService;
+    private readonly fileService;
     private readonly root;
     private readonly headerEl;
     private readonly leadingSlotEl;
     private readonly nameEl;
-    private readonly scopeEl;
-    private readonly descriptionEl;
+    private readonly pathEl;
+    private readonly definitionEditorContainer;
+    private readonly definitionEmptyEl;
+    private definitionEditor;
+    private readonly definitionModel;
     private readonly emptyEl;
     private current;
-    constructor(parent: HTMLElement, mcpWorkbenchService: IMcpWorkbenchService);
+    private currentDefinition;
+    private renderGeneration;
+    constructor(parent: HTMLElement, mcpWorkbenchService: IMcpWorkbenchService, instantiationService: IInstantiationService, configurationService: IConfigurationService, modelService: IModelService, languageService: ILanguageService, fileService: IFileService);
     get element(): HTMLElement;
     get headerElement(): HTMLElement;
     /**
@@ -26,7 +52,11 @@ export declare class EmbeddedMcpServerDetail extends Disposable {
      * Prefer this over reaching into the header element directly.
      */
     get leadingSlot(): HTMLElement;
-    setInput(server: IWorkbenchMcpServer): void;
+    setInput(server: IMcpServerDetailInput): void;
     clearInput(): void;
+    focus(): void;
     private renderItem;
+    private loadSourceDefinition;
+    private setDefinition;
+    private ensureDefinitionEditor;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/embeddedMcpServerDetail.js

@@ -1,30 +1,68 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { $ as $$1, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { CodeEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { LocalMcpServerScope } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { getSimpleEditorOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
+import { McpServerInstallState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
-import { userIcon, workspaceIcon } from './aiCustomizationIcons.js';
 
 const $ = $$1;
+function createWorkbenchMcpServerDetailInput(server) {
+    return {
+        id: server.id,
+        name: server.name,
+        label: server.label,
+        installState: server.installState,
+        config: server.config,
+        source: server.local?.mcpResource ? {
+            uri: server.local.mcpResource
+        } : undefined
+    };
+}
 let EmbeddedMcpServerDetail = class EmbeddedMcpServerDetail extends Disposable {
-    constructor(parent, mcpWorkbenchService) {
+    constructor(
+        parent,
+        mcpWorkbenchService,
+        instantiationService,
+        configurationService,
+        modelService,
+        languageService,
+        fileService
+    ) {
         super();
         this.mcpWorkbenchService = mcpWorkbenchService;
-        this.root = append(parent, $(".ai-customization-embedded-detail.embedded-mcp-detail"));
-        this.headerEl = append(this.root, $(".embedded-detail-header"));
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.fileService = fileService;
+        this.definitionModel = this._register(( new MutableDisposable()));
+        this.renderGeneration = 0;
+        this.root = append(parent, $(
+            ".editor-content-container.ai-customization-embedded-detail.embedded-mcp-detail"
+        ));
+        this.headerEl = append(this.root, $(".editor-header.mcp-detail-header"));
         this.leadingSlotEl = append(this.headerEl, $(".embedded-detail-leading-slot"));
-        const headerText = append(this.headerEl, $(".embedded-detail-header-text"));
-        this.nameEl = append(headerText, $("h2.embedded-detail-name"));
-        this.nameEl.setAttribute("role", "heading");
-        this.scopeEl = append(headerText, $(".embedded-detail-scope"));
-        this.descriptionEl = append(this.root, $(".embedded-detail-description"));
+        const headerText = append(this.headerEl, $(".editor-item-info"));
+        this.nameEl = append(headerText, $(".editor-item-name"));
+        this.pathEl = append(headerText, $(".editor-item-path"));
+        this.definitionEditorContainer = append(this.root, $(".embedded-editor-container.mcp-detail-definition-editor"));
+        this.definitionEmptyEl = append(this.root, $(".embedded-detail-empty.mcp-detail-definition-empty"));
+        this.definitionEmptyEl.tabIndex = -1;
+        this.definitionEmptyEl.textContent = ( localize(6851, "No definition is available for this MCP server."));
         this.emptyEl = append(this.root, $(".embedded-detail-empty"));
-        this.emptyEl.textContent = ( localize(6016, "No MCP server selected."));
+        this.emptyEl.textContent = ( localize(6852, "No MCP server selected."));
         this._register(this.mcpWorkbenchService.onChange(server => {
             if (this.current && server && server.id === this.current.id) {
-                this.current = server;
+                this.current = createWorkbenchMcpServerDetailInput(server);
                 this.renderItem();
             }
         }));
@@ -47,49 +85,133 @@ let EmbeddedMcpServerDetail = class EmbeddedMcpServerDetail extends Disposable {
         this.current = undefined;
         this.renderItem();
     }
+    focus() {
+        if (this.currentDefinition !== undefined) {
+            this.ensureDefinitionEditor().focus();
+            return;
+        }
+        this.definitionEmptyEl.focus();
+    }
     renderItem() {
+        const renderGeneration = ++this.renderGeneration;
         const server = this.current;
         const hasItem = !!server;
         this.emptyEl.style.display = hasItem ? "none" : "";
         this.root.classList.toggle("is-empty", !hasItem);
         if (!server) {
             this.nameEl.textContent = "";
-            this.scopeEl.textContent = "";
-            this.descriptionEl.textContent = "";
+            this.pathEl.textContent = "";
+            this.setDefinition(undefined);
+            this.definitionEmptyEl.style.display = "none";
             return;
         }
         this.nameEl.textContent = server.label || server.name;
-        const scope = server.local?.scope;
-        const scopeInfo = describeMcpScope(scope);
-        if (scopeInfo) {
-            this.scopeEl.textContent = scopeInfo.label;
-            this.scopeEl.style.display = "";
+        this.pathEl.textContent = server.source ? basename(server.source.uri) : "mcp.json";
+        if (server.installState !== McpServerInstallState.Installed) {
+            this.setDefinition(undefined, ( localize(
+                6853,
+                "Details are available after install when the MCP server can be inspected locally."
+            )));
+        } else if (server.config) {
+            this.setDefinition(`${JSON.stringify({
+    servers: {
+        [server.name]: server.config
+    }
+}, null, "\t")}\n`);
+        } else if (server.source) {
+            this.setDefinition(undefined, ( localize(6854, "Loading MCP server definition...")));
+            void this.loadSourceDefinition(server, server.source, renderGeneration);
         } else {
-            this.scopeEl.replaceChildren();
-            this.scopeEl.style.display = "none";
+            this.setDefinition(undefined);
+        }
+    }
+    async loadSourceDefinition(server, source, renderGeneration) {
+        try {
+            const content = ( (await this.fileService.readFile(source.uri)).value.toString());
+            if (this.current !== server || this.renderGeneration !== renderGeneration) {
+                return;
+            }
+            this.setDefinition(source.range ? getTextInRange(content, source.range) : content);
+        } catch {
+            if (this.current === server && this.renderGeneration === renderGeneration) {
+                this.setDefinition(undefined, ( localize(6855, "The MCP server definition could not be loaded.")));
+            }
         }
-        const description = (server.description || "").trim();
-        this.descriptionEl.textContent = description;
-        this.descriptionEl.style.display = description ? "" : "none";
+    }
+    setDefinition(
+        definition,
+        emptyMessage = ( localize(6851, "No definition is available for this MCP server."))
+    ) {
+        const hasDefinition = definition !== undefined;
+        this.definitionEditorContainer.style.display = hasDefinition ? "" : "none";
+        this.definitionEmptyEl.style.display = hasDefinition ? "none" : "";
+        this.definitionEmptyEl.textContent = emptyMessage;
+        if (this.currentDefinition === definition) {
+            return;
+        }
+        this.currentDefinition = definition;
+        if (!hasDefinition) {
+            this.definitionEditor?.setModel(null);
+            this.definitionModel.clear();
+            return;
+        }
+        const definitionEditor = this.ensureDefinitionEditor();
+        definitionEditor.updateOptions({
+            ariaLabel: ( localize(
+                6856,
+                "MCP server definition for {0}",
+                this.current?.label || this.current?.name || ""
+            ))
+        });
+        const model = this.modelService.createModel(definition, this.languageService.createById("jsonc"), undefined, true);
+        definitionEditor.setModel(model);
+        this.definitionModel.value = model;
+    }
+    ensureDefinitionEditor() {
+        if (!this.definitionEditor) {
+            this.definitionEditor = this._register(
+                this.instantiationService.createInstance(CodeEditorWidget, this.definitionEditorContainer, {
+                    ...getSimpleEditorOptions(this.configurationService),
+                    readOnly: true,
+                    domReadOnly: true,
+                    minimap: {
+                        enabled: false
+                    },
+                    lineNumbers: "on",
+                    wordWrap: "on",
+                    scrollBeyondLastLine: false,
+                    automaticLayout: true,
+                    folding: true,
+                    renderLineHighlight: "all",
+                    scrollbar: {
+                        vertical: "auto",
+                        horizontal: "auto"
+                    },
+                    ariaLabel: ( localize(6857, "MCP server definition"))
+                }, {
+                    isSimpleWidget: false
+                })
+            );
+        }
+        return this.definitionEditor;
     }
 };
-EmbeddedMcpServerDetail = ( __decorate([( __param(1, IMcpWorkbenchService))], EmbeddedMcpServerDetail));
-function describeMcpScope(scope) {
-    switch (scope) {
-    case LocalMcpServerScope.Workspace:
-        return {
-            label: ( localize(6017, "Workspace")),
-            icon: workspaceIcon
-        };
-    case LocalMcpServerScope.User:
-    case LocalMcpServerScope.RemoteUser:
-        return {
-            label: ( localize(6018, "User")),
-            icon: userIcon
-        };
-    default:
-        return undefined;
+EmbeddedMcpServerDetail = ( __decorate([( __param(1, IMcpWorkbenchService)), ( __param(2, IInstantiationService)), ( __param(3, IConfigurationService)), ( __param(4, IModelService)), ( __param(5, ILanguageService)), ( __param(6, IFileService))], EmbeddedMcpServerDetail));
+function getTextInRange(content, range) {
+    const lines = content.split(/\r\n|\r|\n/);
+    const startLineIndex = range.startLineNumber - 1;
+    const endLineIndex = range.endLineNumber - 1;
+    if (startLineIndex < 0 || endLineIndex >= lines.length || startLineIndex > endLineIndex) {
+        throw ( new Error("MCP server source range is outside the source document."));
+    }
+    if (startLineIndex === endLineIndex) {
+        return lines[startLineIndex].slice(range.startColumn - 1, range.endColumn - 1);
     }
+    return [
+        lines[startLineIndex].slice(range.startColumn - 1),
+        ...lines.slice(startLineIndex + 1, endLineIndex),
+        lines[endLineIndex].slice(0, range.endColumn - 1)
+    ].join("\n");
 }
 
-export { EmbeddedMcpServerDetail };
+export { EmbeddedMcpServerDetail, createWorkbenchMcpServerDetailInput };

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/galleryItemRenderer.js

@@ -24,10 +24,7 @@ class GalleryItemRenderer {
         const description = append(details, $("span.gallery-item-description"));
         const publisher = append(details, $("span.gallery-item-publisher"));
         const actionContainer = append(container, $(".gallery-item-action"));
-        const installButton = ( new Button(actionContainer, {
-            ...defaultButtonStyles,
-            supportIcons: true
-        }));
+        const installButton = ( new Button(actionContainer, defaultButtonStyles));
         const templateDisposables = ( new DisposableStore());
         templateDisposables.add(installButton);
         return {
@@ -43,7 +40,7 @@ class GalleryItemRenderer {
         templateData.elementDisposables.clear();
         templateData.name.textContent = this._provider.getLabel(element);
         const publisher = this._provider.getPublisherDisplayName(element);
-        templateData.publisher.textContent = publisher ? ( localize(6019, "by {0}", publisher)) : "";
+        templateData.publisher.textContent = publisher ? ( localize(6858, "by {0}", publisher)) : "";
         templateData.description.textContent = this._provider.getDescription(element) || "";
         this._updateInstallButton(templateData.installButton, element);
         templateData.elementDisposables.add(templateData.installButton.onDidClick(async () => {
@@ -53,7 +50,7 @@ class GalleryItemRenderer {
             if (this._provider.canInstall && !this._provider.canInstall(element)) {
                 return;
             }
-            templateData.installButton.label = ( localize(6020, "Installing..."));
+            templateData.installButton.label = ( localize(6859, "Installing..."));
             templateData.installButton.enabled = false;
             try {
                 await this._provider.install(element);
@@ -72,15 +69,15 @@ class GalleryItemRenderer {
     _updateInstallButton(button, element) {
         switch (this._provider.getInstallState(element)) {
         case GalleryItemInstallState.Installed:
-            button.label = ( localize(6021, "Installed"));
+            button.label = ( localize(6860, "Installed"));
             button.enabled = false;
             break;
         case GalleryItemInstallState.Installing:
-            button.label = ( localize(6020, "Installing..."));
+            button.label = ( localize(6859, "Installing..."));
             button.enabled = false;
             break;
         default:
-            button.label = ( localize(6022, "Install"));
+            button.label = ( localize(6861, "Install"));
             button.enabled = true;
             break;
         }