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

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

@@ -0,0 +1,437 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { raceCancellation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { extUriBiasedIgnorePathCase, isEqual, getComparisonKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isAgentHostSessionResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { CustomizationMigrationType, isConfiguredLocationMigrationCandidate, isPromptFileMigrationCandidate, isUserDataMigrationCandidate, getMcpServerCustomizationMigrationCandidateKey, CustomizationMigrationHintTarget, getCustomizationMigrationTargetType, getCustomizationMigrationEnablementSetting, McpServerCustomizationMigrationFailureReason } from '../../common/promptSyntax/service/customizationMigrationService.js';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { IAgentHostActiveClientService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service';
+import { IAgentHostCustomizationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.service';
+import { AgentHostMcpServerApplicability } from '../agentSessions/agentHost/agentHostMcpServerSupport.js';
+import { McpServerCustomizationMigrator, isMcpServerMigrationDeliverable } from './mcpServerCustomizationMigration.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let CustomizationMigrationService = class CustomizationMigrationService extends Disposable {
+    constructor(
+        promptsService,
+        customizationHarnessService,
+        activeClientService,
+        agentHostCustomizationService,
+        fileService,
+        logService,
+        configurationService
+    ) {
+        super();
+        this.promptsService = promptsService;
+        this.customizationHarnessService = customizationHarnessService;
+        this.activeClientService = activeClientService;
+        this.agentHostCustomizationService = agentHostCustomizationService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.activeContextKey = "";
+        this.activeContextGeneration = 0;
+        this.mcpServerMigration = ( new McpServerCustomizationMigrator(fileService, logService));
+        this._register(autorun(reader => {
+            const sessionResource = this.customizationHarnessService.activeSessionResource.read(reader);
+            this.updateActiveContext(sessionResource);
+        }));
+        this._register(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
+            this.updateActiveContext(this.customizationHarnessService.activeSessionResource.get());
+        }));
+    }
+    async computeMigration(sessionResource, type, token = CancellationToken.None) {
+        if (!isAgentHostSessionResource(sessionResource)) {
+            return type === CustomizationMigrationType.McpServers ? this.emptyMcpServerMigration() : {
+                type,
+                files: [],
+                candidates: []
+            };
+        }
+        if (type !== CustomizationMigrationType.McpServers && !this.isMigrationEnabled(type)) {
+            return {
+                type,
+                files: [],
+                candidates: []
+            };
+        }
+        switch (type) {
+        case CustomizationMigrationType.UserData:
+            {
+                const customizations = (await Promise.all([
+                    this.promptsService.listPromptFiles(PromptsType.agent, token),
+                    this.promptsService.listPromptFiles(PromptsType.instructions, token)
+                ])).flat();
+                return this.createFileMigration(
+                    sessionResource,
+                    type,
+                    customizations.filter(isUserDataMigrationCandidate),
+                    token
+                );
+            }
+        case CustomizationMigrationType.PromptFiles:
+            {
+                const customizations = await this.promptsService.listPromptFiles(PromptsType.prompt, token);
+                return this.createFileMigration(
+                    sessionResource,
+                    type,
+                    customizations.filter(isPromptFileMigrationCandidate),
+                    token
+                );
+            }
+        case CustomizationMigrationType.ConfiguredLocations:
+            {
+                const customizations = (await Promise.all([
+                    this.promptsService.listPromptFiles(PromptsType.agent, token),
+                    this.promptsService.listPromptFiles(PromptsType.instructions, token),
+                    this.promptsService.listPromptFiles(PromptsType.skill, token)
+                ])).flat();
+                return this.createFileMigration(
+                    sessionResource,
+                    type,
+                    customizations.filter(isConfiguredLocationMigrationCandidate),
+                    token,
+                    true
+                );
+            }
+        case CustomizationMigrationType.McpServers:
+            return this.computeMcpServerMigration(sessionResource, token);
+        }
+    }
+    async computeMigrations(sessionResource, token = CancellationToken.None) {
+        return Promise.all([
+            this.computeMigration(sessionResource, CustomizationMigrationType.UserData, token),
+            this.computeMigration(sessionResource, CustomizationMigrationType.PromptFiles, token),
+            this.computeMigration(sessionResource, CustomizationMigrationType.ConfiguredLocations, token),
+            this.computeMigration(sessionResource, CustomizationMigrationType.McpServers, token)
+        ]);
+    }
+    async migrateMcpServers(sessionResource, requestedCandidates) {
+        if (requestedCandidates.length === 0) {
+            return {
+                migratedCount: 0,
+                failures: []
+            };
+        }
+        const roots = this.agentHostCustomizationService.getClientWorkingDirectoryUris(sessionResource);
+        const contextGeneration = this.activeContextGeneration;
+        if (!this.isExecutionContextCurrent(sessionResource, roots, contextGeneration)) {
+            return {
+                migratedCount: 0,
+                failures: ( requestedCandidates.map(candidate => this.noLongerEligible(candidate)))
+            };
+        }
+        const scope = this.activeClientService.acquireMcpServerSupportScope(getChatSessionType(sessionResource), roots);
+        if (!scope) {
+            return {
+                migratedCount: 0,
+                failures: ( requestedCandidates.map(candidate => this.noLongerEligible(candidate)))
+            };
+        }
+        try {
+            if (!(await this.waitForMcpServerSupport(scope))) {
+                return {
+                    migratedCount: 0,
+                    failures: ( requestedCandidates.map(candidate => this.noLongerEligible(candidate)))
+                };
+            }
+            if (!this.isExecutionContextCurrent(sessionResource, roots, contextGeneration)) {
+                return {
+                    migratedCount: 0,
+                    failures: ( requestedCandidates.map(candidate => this.noLongerEligible(candidate)))
+                };
+            }
+            const supportSnapshot = scope.support.get();
+            const plan = await this.mcpServerMigration.createPlan(supportSnapshot, roots);
+            const isExecutionCurrent = async candidates => {
+                if (!(await this.waitForMcpServerSupport(scope))) {
+                    return false;
+                }
+                return this.isExecutionContextCurrent(sessionResource, roots, contextGeneration) && scope.isResolved.get() && this.isMcpSupportContextCurrent(scope.support.get(), supportSnapshot, candidates);
+            };
+            if (!(await isExecutionCurrent(plan.candidates))) {
+                return {
+                    migratedCount: 0,
+                    failures: ( requestedCandidates.map(candidate => this.noLongerEligible(candidate)))
+                };
+            }
+            const currentCandidates = ( new Map(( plan.candidates.map(
+                candidate => [getMcpServerCustomizationMigrationCandidateKey(candidate), candidate]
+            ))));
+            const eligibleCandidates = [];
+            const failures = [];
+            for (const requested of requestedCandidates) {
+                const current = currentCandidates.get(getMcpServerCustomizationMigrationCandidateKey(requested));
+                if (!current || !equals(current.projectedConfiguration, requested.projectedConfiguration)) {
+                    failures.push(this.noLongerEligible(requested));
+                } else {
+                    eligibleCandidates.push(current);
+                }
+            }
+            this.logService.info(
+                `[MCP Customization Migration] Starting: selected=${requestedCandidates.length}, eligible=${eligibleCandidates.length}, stale=${failures.length}`
+            );
+            const result = await this.mcpServerMigration.migrate(eligibleCandidates, {
+                isContextCurrent: isExecutionCurrent,
+                roots
+            });
+            const combined = {
+                migratedCount: result.migratedCount,
+                failures: [...failures, ...result.failures]
+            };
+            for (const failure of combined.failures) {
+                if (failure.error) {
+                    this.logService.error(
+                        `[MCP Customization Migration] Failed: reason=${failure.reason}, server=${failure.name}`,
+                        failure.error
+                    );
+                } else {
+                    this.logService.warn(
+                        `[MCP Customization Migration] Failed: reason=${failure.reason}, server=${failure.name}`
+                    );
+                }
+            }
+            this.logService.info(
+                `[MCP Customization Migration] Finished: migrated=${combined.migratedCount}, failed=${combined.failures.length}`
+            );
+            return combined;
+        } finally {
+            scope.dispose();
+        }
+    }
+    async computeMigrationHint(sessionResource, token = CancellationToken.None) {
+        const harness = this.customizationHarnessService.findHarnessById(getChatSessionType(sessionResource));
+        if (!harness) {
+            return undefined;
+        }
+        const [
+            userDataMigration,
+            promptFilesMigration,
+            configuredLocationsMigration,
+            mcpServerMigration
+        ] = await Promise.all([
+            this.computeMigration(sessionResource, CustomizationMigrationType.UserData, token),
+            this.computeMigration(sessionResource, CustomizationMigrationType.PromptFiles, token),
+            this.computeMigration(sessionResource, CustomizationMigrationType.ConfiguredLocations, token),
+            this.computeMigration(sessionResource, CustomizationMigrationType.McpServers, token)
+        ]);
+        const fileCandidates = [userDataMigration, promptFilesMigration, configuredLocationsMigration].filter(migration => this.isMigrationEnabled(migration.type)).flatMap(migration => migration.candidates);
+        const workspaceFileCount = fileCandidates.filter(candidate => candidate.storage === PromptsStorage.local).length;
+        const userFileCount = fileCandidates.filter(candidate => candidate.storage === PromptsStorage.user).length;
+        const migratableMcpServerCount = this.isMigrationEnabled(CustomizationMigrationType.McpServers) ? mcpServerMigration.candidates.length : 0;
+        const unsupportedMcpServerCount = mcpServerMigration.servers.filter(server => !server.supported).length;
+        const fileHint = this.formatFileMigrationHint(workspaceFileCount, userFileCount, harness.label);
+        const migratableMcpHint = migratableMcpServerCount === 0 ? undefined : migratableMcpServerCount === 1 ? ( localize(
+            6793,
+            "Found 1 workspace MCP server that can be migrated for {0}.",
+            harness.label
+        )) : ( localize(
+            6794,
+            "Found {0} workspace MCP servers that can be migrated for {1}.",
+            migratableMcpServerCount,
+            harness.label
+        ));
+        const unsupportedMcpHint = unsupportedMcpServerCount === 0 ? undefined : unsupportedMcpServerCount === 1 ? ( localize(
+            6795,
+            "Found 1 MCP server that is not fully supported by {0}.",
+            harness.label
+        )) : ( localize(
+            6796,
+            "Found {0} MCP servers that are not fully supported by {1}.",
+            unsupportedMcpServerCount,
+            harness.label
+        ));
+        let migrationHint;
+        if (fileHint && migratableMcpHint && unsupportedMcpHint) {
+            migrationHint = ( localize(6797, "{0} {1} {2}", fileHint, migratableMcpHint, unsupportedMcpHint));
+        } else {
+            const firstHint = fileHint ?? migratableMcpHint;
+            const secondHint = firstHint === fileHint ? migratableMcpHint ?? unsupportedMcpHint : unsupportedMcpHint;
+            migrationHint = firstHint && secondHint ? ( localize(6798, "{0} {1}", firstHint, secondHint)) : firstHint ?? unsupportedMcpHint;
+        }
+        return migrationHint ? {
+            message: migrationHint,
+            target: fileHint || migratableMcpHint ? CustomizationMigrationHintTarget.FileMigrations : CustomizationMigrationHintTarget.McpServers,
+            counts: [{
+                type: CustomizationMigrationType.UserData,
+                count: userDataMigration.files.length
+            }, {
+                type: CustomizationMigrationType.PromptFiles,
+                count: promptFilesMigration.files.length
+            }, {
+                type: CustomizationMigrationType.ConfiguredLocations,
+                count: configuredLocationsMigration.files.length
+            }, {
+                type: CustomizationMigrationType.McpServers,
+                count: migratableMcpServerCount + unsupportedMcpServerCount
+            }].filter((
+                {
+                    count
+                }
+            ) => count > 0)
+        } : undefined;
+    }
+    formatFileMigrationHint(workspaceCount, userCount, harnessLabel) {
+        const fileCount = workspaceCount + userCount;
+        if (fileCount === 0) {
+            return undefined;
+        }
+        const sourceCounts = workspaceCount > 0 && userCount > 0 ? ( localize(6799, "{0} workspace and {1} user", workspaceCount, userCount)) : workspaceCount > 0 ? ( localize(6800, "{0} workspace", workspaceCount)) : ( localize(6801, "{0} user", userCount));
+        return fileCount === 1 ? ( localize(
+            6802,
+            "Found {0} customization file that is present but not used by {1} and could be migrated.",
+            sourceCounts,
+            harnessLabel
+        )) : ( localize(
+            6803,
+            "Found {0} customizations that are present but not used by {1} and could be migrated.",
+            sourceCounts,
+            harnessLabel
+        ));
+    }
+    async createFileMigration(
+        sessionResource,
+        type,
+        candidates,
+        token,
+        excludeSupportedLocations = false
+    ) {
+        const provider = this.customizationHarnessService.findHarnessById(getChatSessionType(sessionResource))?.itemProvider;
+        if (!provider?.provideSourceFolders) {
+            return {
+                type,
+                files: [],
+                candidates: []
+            };
+        }
+        const targetTypes = ( new Set(( candidates.map(getCustomizationMigrationTargetType))));
+        const sourceFolders = ( new Map());
+        for (const targetType of targetTypes) {
+            const folders = await provider.provideSourceFolders(sessionResource, targetType, token);
+            sourceFolders.set(targetType, folders ?? []);
+        }
+        const filteredCandidates = candidates.filter(customization => {
+            const targetType = getCustomizationMigrationTargetType(customization);
+            const compatibleFolders = sourceFolders.get(targetType)?.filter(folder => folder.source === customization.storage) ?? [];
+            return compatibleFolders.length > 0 && (!excludeSupportedLocations || !( compatibleFolders.some(
+                folder => extUriBiasedIgnorePathCase.isEqualOrParent(customization.uri, folder.uri)
+            )));
+        });
+        return {
+            type,
+            files: ( filteredCandidates.map(customization => customization.uri)),
+            candidates: filteredCandidates
+        };
+    }
+    async computeMcpServerMigration(sessionResource, token = CancellationToken.None) {
+        const roots = this.agentHostCustomizationService.getClientWorkingDirectoryUris(sessionResource);
+        const scope = this.activeClientService.acquireMcpServerSupportScope(getChatSessionType(sessionResource), roots);
+        if (!scope) {
+            return this.emptyMcpServerMigration();
+        }
+        try {
+            if (!(await this.waitForMcpServerSupport(scope, token)) || !this.areRootsEqual(
+                roots,
+                this.agentHostCustomizationService.getClientWorkingDirectoryUris(sessionResource)
+            )) {
+                return this.emptyMcpServerMigration();
+            }
+            const snapshot = scope.support.get();
+            const candidates = this.isMigrationEnabled(CustomizationMigrationType.McpServers) ? (await this.mcpServerMigration.createPlan(snapshot, roots)).candidates : [];
+            if (!(await this.waitForMcpServerSupport(scope, token)) || !this.areRootsEqual(
+                roots,
+                this.agentHostCustomizationService.getClientWorkingDirectoryUris(sessionResource)
+            ) || !this.isMcpSupportContextCurrent(scope.support.get(), snapshot, candidates)) {
+                return this.emptyMcpServerMigration();
+            }
+            const settledSnapshot = scope.support.get();
+            return {
+                type: CustomizationMigrationType.McpServers,
+                servers: ( settledSnapshot.servers.filter(
+                    server => server.applicability !== AgentHostMcpServerApplicability.OutsideCurrentScope
+                ).map(server => ({
+                    id: server.id,
+                    name: server.name,
+                    supported: server.compatibility.kind === "supported"
+                }))),
+                candidates: this.isMigrationEnabled(CustomizationMigrationType.McpServers) ? candidates : [],
+                discoveryComplete: settledSnapshot.discoveryComplete,
+                coverage: settledSnapshot.coverage
+            };
+        } finally {
+            scope.dispose();
+        }
+    }
+    emptyMcpServerMigration() {
+        return {
+            type: CustomizationMigrationType.McpServers,
+            servers: [],
+            candidates: [],
+            discoveryComplete: true,
+            coverage: {
+                restrictedByMcpAccess: false,
+                restrictedByCustomizationPolicy: false
+            }
+        };
+    }
+    isExecutionContextCurrent(sessionResource, roots, generation) {
+        return this.isMigrationEnabled(CustomizationMigrationType.McpServers) && isEqual(
+            sessionResource,
+            this.customizationHarnessService.activeSessionResource.get()
+        ) && generation === this.activeContextGeneration && this.areRootsEqual(
+            roots,
+            this.agentHostCustomizationService.getClientWorkingDirectoryUris(sessionResource)
+        );
+    }
+    isMigrationEnabled(type) {
+        return this.configurationService.getValue(getCustomizationMigrationEnablementSetting(type)) === true;
+    }
+    async waitForMcpServerSupport(scope, token = CancellationToken.None) {
+        await raceCancellation(scope.whenResolved(), token);
+        return !token.isCancellationRequested && scope.isResolved.get();
+    }
+    isMcpSupportContextCurrent(current, planned, candidates) {
+        if (!equals(current.coverage, planned.coverage)) {
+            return false;
+        }
+        const currentServers = ( new Map(( current.servers.map(server => [server.id, server]))));
+        return candidates.every(candidate => {
+            const server = currentServers.get(candidate.id);
+            return server !== undefined && isMcpServerMigrationDeliverable(server) && equals(server.projectedConfiguration, candidate.projectedConfiguration);
+        });
+    }
+    areRootsEqual(first, second) {
+        return first.length === second.length && first.every((root, index) => isEqual(root, second[index]));
+    }
+    noLongerEligible(candidate) {
+        return {
+            id: candidate.id,
+            name: candidate.name,
+            sourceUri: candidate.sourceUri,
+            targetUri: candidate.targetUri,
+            reason: McpServerCustomizationMigrationFailureReason.NoLongerEligible
+        };
+    }
+    updateActiveContext(sessionResource) {
+        const roots = this.agentHostCustomizationService.getClientWorkingDirectoryUris(sessionResource);
+        const key = JSON.stringify([getComparisonKey(sessionResource), ...( roots.map(root => getComparisonKey(root)))]);
+        if (key !== this.activeContextKey) {
+            this.activeContextKey = key;
+            this.activeContextGeneration++;
+        }
+    }
+};
+CustomizationMigrationService = ( __decorate([( __param(0, IPromptsService)), ( __param(1, ICustomizationHarnessService)), ( __param(2, IAgentHostActiveClientService)), ( __param(3, IAgentHostCustomizationService)), ( __param(4, IFileService)), ( __param(5, ILogService)), ( __param(6, IConfigurationService))], CustomizationMigrationService));
+
+export { CustomizationMigrationService };

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

@@ -1,22 +1,87 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
 import { IAgentPluginItem } from "../agentPluginEditor/agentPluginItems.js";
+import { IPluginInstallService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginInstallService.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IClipboardService } from "@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IAgentPlugin } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService";
+import { IAgentPluginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { AICustomizationManagementSection } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IMarkdownRendererService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+export interface IPluginReadme {
+    readonly content: string;
+    readonly baseUri: URI;
+}
+export declare class PluginReadmeRenderGuard {
+    private generation;
+    begin(): number;
+    isCurrent(generation: number): boolean;
+}
+export declare function loadPluginReadme(item: IAgentPluginItem, fileService: Pick<IFileService, "readFile">, requestService: Pick<IRequestService, "request">): Promise<IPluginReadme | undefined>;
+export declare function waitForInstalledPlugin(agentPluginService: Pick<IAgentPluginService, "plugins">, expectedUri: URI, token: CancellationToken): Promise<IAgentPlugin | undefined>;
 /**
  * Compact detail view for an agent plugin inside the AI Customizations management editor's
- * split-pane host. Renders identity (icon + name + source) and description.
- *
- * Advanced actions (enable / disable / uninstall) remain accessible via the row's existing
- * context menu, so this component intentionally stays small.
+ * split-pane host. Renders identity, provenance, contribution summary, and description while
+ * keeping management actions in the list/context-menu surfaces.
  */
 export declare class EmbeddedAgentPluginDetail extends Disposable {
+    private readonly labelService;
+    private readonly clipboardService;
+    private readonly openerService;
+    private readonly agentPluginService;
+    private readonly pluginInstallService;
+    private readonly notificationService;
+    private readonly contextMenuService;
+    private readonly commandService;
+    private readonly hoverService;
+    private readonly fileService;
+    private readonly requestService;
+    private readonly markdownRendererService;
+    private readonly _onDidRequestOpenSkill;
+    readonly onDidRequestOpenSkill: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<URI>;
+    private readonly _onDidRequestOpenAgent;
+    readonly onDidRequestOpenAgent: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<URI>;
+    private readonly _onDidRequestOpenSection;
+    readonly onDidRequestOpenSection: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<AICustomizationManagementSection>;
+    private readonly _onDidUninstall;
+    readonly onDidUninstall: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
     private readonly root;
     private readonly headerEl;
     private readonly leadingSlotEl;
+    private readonly nameRowEl;
     private readonly nameEl;
-    private readonly sourceEl;
+    private readonly statusBadgeEl;
+    private readonly titleActionsEl;
     private readonly descriptionEl;
+    private readonly sourceFactsEl;
+    private readonly factsEl;
+    private readonly contributionsEl;
+    private readonly contributionsListEl;
+    private readonly readmeEl;
+    private readonly readmeContentEl;
     private readonly emptyEl;
+    private readonly renderDisposables;
+    private readonly copyStateReset;
+    private readonly narrowLayoutUpdate;
+    private readonly inputStateAutorun;
+    private readonly installWaitDisposables;
     private current;
-    constructor(parent: HTMLElement);
+    private narrowLayout;
+    private readonly readmeRenderGuard;
+    private updateEnablementAction;
+    private pluginVersionRowEl;
+    private pluginVersionValueEl;
+    private renderedPolicyBlocked;
+    constructor(parent: HTMLElement, labelService: ILabelService, clipboardService: IClipboardService, openerService: IOpenerService, agentPluginService: IAgentPluginService, pluginInstallService: IPluginInstallService, notificationService: INotificationService, contextMenuService: IContextMenuService, commandService: ICommandService, hoverService: IHoverService, fileService: IFileService, requestService: IRequestService, markdownRendererService: IMarkdownRendererService);
+    private updateNarrowLayout;
     get element(): HTMLElement;
     get headerElement(): HTMLElement;
     /**
@@ -27,4 +92,18 @@ export declare class EmbeddedAgentPluginDetail extends Disposable {
     setInput(item: IAgentPluginItem): void;
     clearInput(): void;
     private renderItem;
+    private updateInstalledState;
+    private renderTitleActions;
+    private renderEnablementSplitButton;
+    private toInstalledPluginItem;
+    private renderMarketplaceLink;
+    private renderFacts;
+    private appendPluginVersionFact;
+    private updatePluginVersionFact;
+    private appendFact;
+    private createLocationValue;
+    private renderReadme;
+    dispose(): void;
+    private renderContributions;
 }
+export declare function getPluginVersion(item: IAgentPluginItem): string | undefined;