@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

package/vscode/src/vs/workbench/contrib/chat/common/model/chatModelStore.d.ts

@@ -17,6 +17,27 @@ export interface ChatModelStoreDelegate {
     createModel: (props: IStartSessionProps) => ChatModel;
     willDisposeModel: (model: ChatModel) => Promise<void>;
 }
+export interface IChatModelReferenceDebugHolder {
+    readonly holder: string;
+    readonly count: number;
+}
+export interface IChatModelReferenceDebugInfo {
+    readonly sessionResource: URI;
+    readonly title: string;
+    readonly createdBy: string;
+    readonly initialLocation: ChatAgentLocation;
+    readonly isImported: boolean;
+    readonly willKeepAlive: boolean;
+    readonly hasPendingEdits: boolean;
+    readonly pendingDisposal: boolean;
+    readonly referenceCount: number;
+    readonly holders: readonly IChatModelReferenceDebugHolder[];
+}
+export interface IChatModelReferenceDebugSnapshot {
+    readonly totalModels: number;
+    readonly totalReferences: number;
+    readonly models: readonly IChatModelReferenceDebugInfo[];
+}
 export declare class ChatModelStore extends Disposable {
     private readonly delegate;
     private readonly logService;
@@ -24,6 +45,9 @@ export declare class ChatModelStore extends Disposable {
     private readonly _models;
     private readonly _modelsToDispose;
     private readonly _pendingDisposals;
+    private readonly _modelCreateOwners;
+    private readonly _referenceOwners;
+    private _referenceOwnerIds;
     private readonly _onDidDisposeModel;
     readonly onDidDisposeModel: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ChatModel>;
     private readonly _onDidCreateModel;
@@ -36,11 +60,13 @@ export declare class ChatModelStore extends Disposable {
      */
     get(uri: URI): ChatModel | undefined;
     has(uri: URI): boolean;
-    acquireExisting(uri: URI): IReference<ChatModel> | undefined;
-    acquireOrCreate(props: IStartSessionProps): IReference<ChatModel>;
+    acquireExisting(uri: URI, debugOwner?: string): IReference<ChatModel> | undefined;
+    acquireOrCreate(props: IStartSessionProps, debugOwner?: string): IReference<ChatModel>;
+    getReferenceDebugSnapshot(): IChatModelReferenceDebugSnapshot;
     private createReferencedObject;
     private destroyReferencedObject;
     private doDestroyReferencedObject;
+    private wrapReference;
     /**
      * For test use only
      */

package/vscode/src/vs/workbench/contrib/chat/common/model/chatModelStore.js

@@ -4,6 +4,7 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 import { Disposable, ReferenceCollection } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
 import { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
 
 let ChatModelStore = class ChatModelStore extends Disposable {
@@ -14,14 +15,17 @@ let ChatModelStore = class ChatModelStore extends Disposable {
         this._models = ( new ObservableMap());
         this._modelsToDispose = ( new Set());
         this._pendingDisposals = ( new Set());
+        this._modelCreateOwners = ( new Map());
+        this._referenceOwners = ( new Map());
+        this._referenceOwnerIds = 0;
         this._onDidDisposeModel = this._register(( new Emitter()));
         this.onDidDisposeModel = this._onDidDisposeModel.event;
         this._onDidCreateModel = this._register(( new Emitter()));
         this.onDidCreateModel = this._onDidCreateModel.event;
         const self = this;
         this._refCollection = new (class extends ReferenceCollection {
-            createReferencedObject(key, props) {
-                return self.createReferencedObject(key, props);
+            createReferencedObject(key, props, debugOwner) {
+                return self.createReferencedObject(key, props, debugOwner);
             }
             destroyReferencedObject(key, object) {
                 return self.destroyReferencedObject(key, object);
@@ -40,17 +44,51 @@ let ChatModelStore = class ChatModelStore extends Disposable {
     has(uri) {
         return ( this._models.has(this.toKey(uri)));
     }
-    acquireExisting(uri) {
+    acquireExisting(uri, debugOwner) {
         const key = this.toKey(uri);
         if (!( this._models.has(key))) {
             return undefined;
         }
-        return this._refCollection.acquire(key);
+        return this.wrapReference(key, this._refCollection.acquire(key, undefined, debugOwner), debugOwner);
     }
-    acquireOrCreate(props) {
-        return this._refCollection.acquire(this.toKey(props.sessionResource), props);
+    acquireOrCreate(props, debugOwner) {
+        const key = this.toKey(props.sessionResource);
+        return this.wrapReference(key, this._refCollection.acquire(key, props, debugOwner), debugOwner);
     }
-    createReferencedObject(key, props) {
+    getReferenceDebugSnapshot() {
+        const models = ( Array.from(( this._models.values())).map(model => {
+            const key = this.toKey(model.sessionResource);
+            const owners = this._referenceOwners.get(key) ?? ( new Map());
+            const countsByOwner = ( new Map());
+            for (const owner of ( owners.values())) {
+                countsByOwner.set(owner, (countsByOwner.get(owner) ?? 0) + 1);
+            }
+            const holders = ( Array.from(countsByOwner.entries()).map(([holder, count]) => ({
+                holder,
+                count
+            }))).sort((a, b) => b.count - a.count || a.holder.localeCompare(b.holder));
+            return {
+                sessionResource: model.sessionResource,
+                title: model.title,
+                createdBy: this._modelCreateOwners.get(key) ?? "unknown",
+                initialLocation: model.initialLocation,
+                isImported: !!model.isImported,
+                willKeepAlive: model.willKeepAlive,
+                hasPendingEdits: !!model.editingSession?.entries.get().some(entry => entry.state.get() === ModifiedFileEntryState.Modified),
+                pendingDisposal: ( this._modelsToDispose.has(key)),
+                referenceCount: owners.size,
+                holders
+            };
+        })).sort(
+            (a, b) => b.referenceCount - a.referenceCount || Number(b.hasPendingEdits) - Number(a.hasPendingEdits) || ( a.sessionResource.toString()).localeCompare(( b.sessionResource.toString()))
+        );
+        return {
+            totalModels: models.length,
+            totalReferences: models.reduce((total, model) => total + model.referenceCount, 0),
+            models
+        };
+    }
+    createReferencedObject(key, props, debugOwner) {
         this._modelsToDispose.delete(key);
         const existingModel = this._models.get(key);
         if (existingModel) {
@@ -61,6 +99,7 @@ let ChatModelStore = class ChatModelStore extends Disposable {
         }
         this.logService.trace(`Creating chat session ${key}`);
         const model = this.delegate.createModel(props);
+        this._modelCreateOwners.set(key, debugOwner ?? "unspecified");
         if (( model.sessionResource.toString()) !== key) {
             throw ( new Error(`Chat session key mismatch for ${key}`));
         }
@@ -85,12 +124,41 @@ let ChatModelStore = class ChatModelStore extends Disposable {
             if (( this._modelsToDispose.has(key))) {
                 this.logService.trace(`Disposing chat session ${key}`);
                 this._models.delete(key);
+                this._modelCreateOwners.delete(key);
+                this._referenceOwners.delete(key);
                 this._onDidDisposeModel.fire(object);
                 object.dispose();
             }
             this._modelsToDispose.delete(key);
         }
     }
+    wrapReference(key, reference, debugOwner) {
+        const ownerId = ++this._referenceOwnerIds;
+        let ownerEntries = this._referenceOwners.get(key);
+        if (!ownerEntries) {
+            ownerEntries = ( new Map());
+            this._referenceOwners.set(key, ownerEntries);
+        }
+        ownerEntries.set(ownerId, debugOwner ?? "unspecified");
+        let isDisposed = false;
+        const wrapped = {
+            object: reference.object,
+            dispose: () => {
+                if (isDisposed) {
+                    return;
+                }
+                isDisposed = true;
+                const owners = this._referenceOwners.get(key);
+                owners?.delete(ownerId);
+                if (owners?.size === 0) {
+                    this._referenceOwners.delete(key);
+                }
+                reference.dispose();
+                wrapped.object = null;
+            }
+        };
+        return wrapped;
+    }
     async waitForModelDisposals() {
         await Promise.all(this._pendingDisposals);
     }

package/vscode/src/vs/workbench/contrib/chat/common/model/chatSessionOperationLog.js

@@ -52,6 +52,7 @@ const responsePartSchema = v(
             case "progressMessage":
             case "pullRequest":
             case "questionCarousel":
+            case "planReview":
             case "undoStop":
             case "warning":
             case "treeData":
@@ -110,7 +111,14 @@ const requestSchema = object({
     contentReferences: v(m => m.response?.contentReferences, equals),
     codeCitations: v(m => m.response?.codeCitations, equals),
     timeSpentWaiting: v(m => m.response?.timestamp),
-    modeInfo: v(m => m.modeInfo, equals)
+    completionTokens: v(m => m.response?.completionTokenCount),
+    elapsedMs: v(
+        m => m.response?.elapsedMs ?? (m.response?.completedAt ? Math.max(0, m.response.completedAt - m.response.confirmationAdjustedTimestamp.get()) : undefined)
+    ),
+    modeInfo: v(m => m.modeInfo, equals),
+    isSystemInitiated: v(m => m.isSystemInitiated),
+    systemInitiatedLabel: v(m => m.systemInitiatedLabel),
+    terminalExecutionId: v(m => m.terminalExecutionId)
 }, {
     sealed: o => o.modelState?.value === ResponseModelState.Cancelled || o.modelState?.value === ResponseModelState.Failed || o.modelState?.value === ResponseModelState.Complete
 });

package/vscode/src/vs/workbench/contrib/chat/common/model/chatSessionStore.js

@@ -98,7 +98,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: "join.chatSessionStore",
-                label: ( localize(7300, "Saving chat history"))
+                label: ( localize(7418, "Saving chat history"))
             });
         }));
     }
@@ -356,14 +356,14 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                             this._didReportIssue = true;
                             this.dialogService.prompt({
                                 custom: true,
-                                title: ( localize(7301, "Error saving chat session")),
+                                title: ( localize(7419, "Error saving chat session")),
                                 message: ( localize(
-                                    7302,
+                                    7420,
                                     "Error serializing chat session for storage. The session will be lost if the window is closed. Please report this issue to the VS Code team:\n\n{0}",
                                     e.stack || toErrorMessage(e)
                                 )),
                                 buttons: [{
-                                    label: ( localize(7303, "Report Issue")),
+                                    label: ( localize(7421, "Report Issue")),
                                     run: () => this.openerService.open("https://github.com/microsoft/vscode/issues/new?template=bug_report.md")
                                 }]
                             });
@@ -375,6 +375,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                             append: op === "append"
                         });
                     }
+                    session.dataSerializer.confirmWrite();
                 } else {
                     const content = ( new ChatSessionOperationLog()).createInitialFromSerialized(session);
                     await this.fileService.writeFile(storageLocation.log, content);
@@ -708,7 +709,7 @@ async function getSessionMetadata(session) {
     }
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(7304, "New Chat")),
+        title: title || ( localize(7422, "New Chat")),
         lastMessageDate,
         timing,
         initialLocation: session.initialLocation,

package/vscode/src/vs/workbench/contrib/chat/common/model/objectMutationLog.d.ts

@@ -79,6 +79,9 @@ export declare class ObjectMutationLog<TFrom, TTo> {
     private readonly _compactAfterEntries;
     private _previous;
     private _entryCount;
+    private _hasPendingWrite;
+    private _pendingPrevious;
+    private _pendingEntryCount;
     constructor(_transform: Transform<TFrom, TTo>, _compactAfterEntries?: number);
     /**
      * Creates an initial log file from the given object.
@@ -86,6 +89,11 @@ export declare class ObjectMutationLog<TFrom, TTo> {
     createInitial(current: TFrom): VSBuffer;
     /**
      * Creates an initial log file from the serialized object.
+     *
+     * Unlike {@link write}, this commits state immediately without requiring
+     * {@link confirmWrite}. This is safe because the returned buffer contains
+     * a self-contained `Initial` entry — if it fails to persist, no
+     * incremental entries can be appended to a non-existent file.
      */
     createInitialFromSerialized(value: TTo): VSBuffer;
     /**
@@ -94,11 +102,21 @@ export declare class ObjectMutationLog<TFrom, TTo> {
     read(content: VSBuffer): TTo;
     /**
      * Writes updates to the log. Returns the operation type and data to write.
+     * The caller **must** invoke {@link confirmWrite} after the data is
+     * successfully persisted to commit the internal state. Without confirmation,
+     * the next write is computed against the last confirmed state, and will only
+     * produce a full initial entry when no confirmed state exists, preventing
+     * corrupted log files when a write fails.
      */
     write(current: TFrom): {
         op: "append" | "replace";
         data: VSBuffer;
     };
+    /**
+     * Commits the internal state after a successful write to disk.
+     */
+    confirmWrite(): void;
+    private _clearPending;
     private _applySet;
     private _applyPush;
     private _diff;

package/vscode/src/vs/workbench/contrib/chat/common/model/objectMutationLog.js

@@ -106,6 +106,8 @@ class ObjectMutationLog {
         this._transform = _transform;
         this._compactAfterEntries = _compactAfterEntries;
         this._entryCount = 0;
+        this._hasPendingWrite = false;
+        this._pendingEntryCount = 0;
     }
     createInitial(current) {
         return this.createInitialFromSerialized(this._transform.extract(current));
@@ -113,6 +115,7 @@ class ObjectMutationLog {
     createInitialFromSerialized(value) {
         this._previous = value;
         this._entryCount = 1;
+        this._clearPending();
         const entry = {
             kind: EntryKind.Initial,
             v: value
@@ -139,12 +142,21 @@ class ObjectMutationLog {
                         state = entry.v;
                         break;
                     case EntryKind.Set:
+                        if (state === undefined) {
+                            throw ( new Error("Log file is missing an initial entry"));
+                        }
                         this._applySet(state, entry.k, entry.v);
                         break;
                     case EntryKind.Push:
+                        if (state === undefined) {
+                            throw ( new Error("Log file is missing an initial entry"));
+                        }
                         this._applyPush(state, entry.k, entry.v, entry.i);
                         break;
                     case EntryKind.Delete:
+                        if (state === undefined) {
+                            throw ( new Error("Log file is missing an initial entry"));
+                        }
                         this._applySet(state, entry.k, undefined);
                         break;
                     default:
@@ -159,13 +171,15 @@ class ObjectMutationLog {
         }
         this._previous = state;
         this._entryCount = lineCount;
+        this._clearPending();
         return state;
     }
     write(current) {
         const currentValue = this._transform.extract(current);
         if (!this._previous || this._entryCount > this._compactAfterEntries) {
-            this._previous = currentValue;
-            this._entryCount = 1;
+            this._hasPendingWrite = true;
+            this._pendingPrevious = currentValue;
+            this._pendingEntryCount = 1;
             const entry = {
                 kind: EntryKind.Initial,
                 v: currentValue
@@ -187,13 +201,15 @@ class ObjectMutationLog {
             throw e;
         }
         if (entries.length === 0) {
+            this._clearPending();
             return {
                 op: "append",
                 data: VSBuffer.fromString("")
             };
         }
-        this._entryCount += entries.length;
-        this._previous = currentValue;
+        this._hasPendingWrite = true;
+        this._pendingEntryCount = this._entryCount + entries.length;
+        this._pendingPrevious = currentValue;
         let data = "";
         for (const e of entries) {
             data += JSON.stringify(e) + "\n";
@@ -203,6 +219,18 @@ class ObjectMutationLog {
             data: VSBuffer.fromString(data)
         };
     }
+    confirmWrite() {
+        if (this._hasPendingWrite) {
+            this._previous = this._pendingPrevious;
+            this._entryCount = this._pendingEntryCount;
+            this._clearPending();
+        }
+    }
+    _clearPending() {
+        this._hasPendingWrite = false;
+        this._pendingPrevious = undefined;
+        this._pendingEntryCount = 0;
+    }
     _applySet(state, path, value) {
         if (path.length === 0) {
             return;

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginService.d.ts

@@ -2,39 +2,22 @@ import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { SyncDescriptor0 } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors";
-import { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
+import { type INamedPluginResource, type IMcpServerDefinition, type IParsedHookCommand } from "../../../../../platform/agentPlugins/common/pluginParsers.js";
 import { ContributionEnablementState, IEnablementModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement";
-import { IHookCommand } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema";
 import { HookType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes";
 import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
 export interface IAgentPluginHook {
     readonly type: HookType;
-    readonly hooks: readonly IHookCommand[];
+    readonly hooks: readonly IParsedHookCommand[];
     /** URI where this hook is defined -- not unique, multiple hooks may be in a manifest */
     readonly uri: URI;
     readonly originalId: string;
 }
-export interface IAgentPluginCommand {
-    readonly uri: URI;
-    readonly name: string;
-}
-export interface IAgentPluginSkill {
-    readonly uri: URI;
-    readonly name: string;
-}
-export interface IAgentPluginAgent {
-    readonly uri: URI;
-    readonly name: string;
-}
-export interface IAgentPluginInstruction {
-    readonly uri: URI;
-    readonly name: string;
-}
-export interface IAgentPluginMcpServerDefinition {
-    readonly name: string;
-    readonly configuration: IMcpServerConfiguration;
-    readonly uri: URI;
-}
+export type IAgentPluginCommand = INamedPluginResource;
+export type IAgentPluginSkill = INamedPluginResource;
+export type IAgentPluginAgent = INamedPluginResource;
+export type IAgentPluginInstruction = INamedPluginResource;
+export type IAgentPluginMcpServerDefinition = IMcpServerDefinition;
 export interface IAgentPlugin {
     readonly uri: URI;
     /** Human-readable display name for the plugin. */
@@ -55,7 +38,9 @@ export interface IAgentPluginDiscovery extends IDisposable {
     readonly plugins: IObservable<readonly IAgentPlugin[]>;
     start(enablementModel: IEnablementModel): void;
 }
-export declare function getCanonicalPluginCommandId(plugin: IAgentPlugin, commandName: string): string;
+export declare function getCanonicalPluginCommandId(plugin: {
+    readonly uri: URI;
+}, commandName: string): string;
 declare class AgentPluginDiscoveryRegistry {
     private readonly _discovery;
     register(descriptor: SyncDescriptor0<IAgentPluginDiscovery>): void;

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginServiceImpl.d.ts

@@ -13,43 +13,11 @@ import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
 import { IEnablementModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement";
 import { IAgentPluginRepositoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service";
-import { IAgentPlugin, IAgentPluginDiscovery, IAgentPluginMcpServerDefinition } from "./agentPluginService.js";
+import { IAgentPlugin, IAgentPluginDiscovery } from "./agentPluginService.js";
 import { IAgentPluginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service";
 import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
 import { IPluginMarketplaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service";
-/**
- * Replaces `${CLAUDE_PLUGIN_ROOT}` in a shell command string with the
- * given fsPath. If the path contains characters that would break shell
- * parsing (e.g. spaces), occurrences are wrapped in double-quotes.
- *
- * The token may be followed by additional path segments like
- * `${CLAUDE_PLUGIN_ROOT}/scripts/run.sh`; the entire resulting path
- * (including suffix) is quoted as one unit.
- *
- */
-export declare function shellQuotePluginRootInCommand(command: string, fsPath: string, token: string): string;
-/**
- * Extracts the MCP server map from a raw JSON value. Accepts both the
- * wrapped format `{ mcpServers: { … } }` (Claude `.mcp.json`) and the
- * flat format where server entries are at the top level.
- * Returns `undefined` when the input is not a usable object.
- */
-export declare function resolveMcpServersMap(raw: unknown): Record<string, unknown> | undefined;
-/**
- * Converts bare `${VAR}` environment-variable references found in MCP server
- * definition strings to the VS Code `${env:VAR}` syntax so that the
- * `configurationResolverService` can resolve them later in the pipeline.
- *
- * The MCP ecosystem (Claude Desktop, Copilot CLI) uses bare `${VAR}` to
- * reference environment variables, while VS Code's resolver expects the
- * `${env:VAR}` form. This function bridges that gap for all plugin-provided
- * MCP server definitions.
- *
- * Only references whose name consists of uppercase letters, digits, and
- * underscores are converted — this avoids transforming VS Code's own variable
- * tokens (e.g. `${workspaceFolder}`) which use lowercase/camelCase names.
- */
-export declare function convertBareEnvVarsToVsCodeSyntax(def: IAgentPluginMcpServerDefinition): IAgentPluginMcpServerDefinition;
+export { shellQuotePluginRootInCommand, resolveMcpServersMap, convertBareEnvVarsToVsCodeSyntax } from "../../../../../platform/agentPlugins/common/pluginParsers.js";
 export declare class AgentPluginService extends Disposable implements IAgentPluginService {
     readonly _serviceBrand: undefined;
     readonly plugins: IObservable<readonly IAgentPlugin[]>;
@@ -79,19 +47,18 @@ export declare abstract class AbstractAgentPluginDiscovery extends Disposable im
     protected readonly _fileService: IFileService;
     protected readonly _pathService: IPathService;
     protected readonly _logService: ILogService;
-    protected readonly _instantiationService: IInstantiationService;
+    protected readonly _workspaceContextService: IWorkspaceContextService;
     private readonly _pluginEntries;
     private readonly _plugins;
     readonly plugins: IObservable<readonly IAgentPlugin[]>;
     private _discoverVersion;
     protected _enablementModel: IEnablementModel;
-    constructor(_fileService: IFileService, _pathService: IPathService, _logService: ILogService, _instantiationService: IInstantiationService);
+    constructor(_fileService: IFileService, _pathService: IPathService, _logService: ILogService, _workspaceContextService: IWorkspaceContextService);
     abstract start(enablementModel: IEnablementModel): void;
     protected _refreshPlugins(): Promise<void>;
     /** Subclasses return plugin sources to discover. */
     protected abstract _discoverPluginSources(): Promise<readonly IPluginSource[]>;
     private _discoverAndBuildPlugins;
-    private _detectPluginFormatAdapter;
     protected _pathExists(resource: URI): Promise<boolean>;
     private _toPlugin;
     private _readManifest;
@@ -107,32 +74,21 @@ export declare abstract class AbstractAgentPluginDiscovery extends Disposable im
      * server name wins.
      */
     private _readMcpDefinitionsFromPaths;
-    private _parseMcpServerDefinitionMap;
-    private _normalizeMcpServerConfiguration;
     private _readJsonFile;
-    private _readSkills;
     /**
      * Scans directories for rule/instruction files (`.mdc`, `.md`,
      * `.instructions.md`), returning `{ uri, name }` entries where name is
      * derived from the filename minus the matched suffix.
      */
     private _readRules;
-    /**
-     * Scans directories for `.md` files, returning `{ uri, name }` entries
-     * where name is derived from the filename (minus the `.md` extension).
-     * If a path points to a specific `.md` file, it is included directly.
-     * Used for both commands and agents.
-     */
-    private _readMarkdownComponents;
     private _disposePluginEntriesExcept;
     dispose(): void;
 }
 export declare class ConfiguredAgentPluginDiscovery extends AbstractAgentPluginDiscovery {
     private readonly _configurationService;
     private readonly _pluginMarketplaceService;
-    private readonly _workspaceContextService;
     private readonly _pluginLocationsConfig;
-    constructor(_configurationService: IConfigurationService, fileService: IFileService, _pluginMarketplaceService: IPluginMarketplaceService, _workspaceContextService: IWorkspaceContextService, pathService: IPathService, logService: ILogService, instantiationService: IInstantiationService);
+    constructor(_configurationService: IConfigurationService, fileService: IFileService, _pluginMarketplaceService: IPluginMarketplaceService, workspaceContextService: IWorkspaceContextService, pathService: IPathService, logService: ILogService);
     start(enablementModel: IEnablementModel): void;
     protected _discoverPluginSources(): Promise<readonly IPluginSource[]>;
     private _getUserHome;
@@ -152,7 +108,7 @@ export declare class ConfiguredAgentPluginDiscovery extends AbstractAgentPluginD
 export declare class MarketplaceAgentPluginDiscovery extends AbstractAgentPluginDiscovery {
     private readonly _pluginMarketplaceService;
     private readonly _pluginRepositoryService;
-    constructor(_pluginMarketplaceService: IPluginMarketplaceService, _pluginRepositoryService: IAgentPluginRepositoryService, fileService: IFileService, pathService: IPathService, logService: ILogService, instantiationService: IInstantiationService);
+    constructor(_pluginMarketplaceService: IPluginMarketplaceService, _pluginRepositoryService: IAgentPluginRepositoryService, fileService: IFileService, pathService: IPathService, logService: ILogService, workspaceContextService: IWorkspaceContextService);
     start(enablementModel: IEnablementModel): void;
     protected _discoverPluginSources(): Promise<readonly IPluginSource[]>;
 }
@@ -162,10 +118,9 @@ export declare class ExtensionAgentPluginDiscovery extends AbstractAgentPluginDi
     private readonly _dialogService;
     private readonly _extensionPlugins;
     private readonly _whenKeys;
-    constructor(_commandService: ICommandService, _contextKeyService: IContextKeyService, _dialogService: IDialogService, fileService: IFileService, pathService: IPathService, logService: ILogService, instantiationService: IInstantiationService);
+    constructor(_commandService: ICommandService, _contextKeyService: IContextKeyService, _dialogService: IDialogService, fileService: IFileService, pathService: IPathService, logService: ILogService, workspaceContextService: IWorkspaceContextService);
     start(enablementModel: IEnablementModel): void;
     private _rebuildWhenKeys;
     protected _discoverPluginSources(): Promise<readonly IPluginSource[]>;
     private _promptUninstallExtension;
 }
-export {};