@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceTelemetry.js

@@ -6,6 +6,7 @@ import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { ChatAgentVoteDirection, ChatCopyKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { isImageVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 
 let ChatServiceTelemetry = class ChatServiceTelemetry {
     constructor(telemetryService) {
@@ -120,7 +121,7 @@ let ChatRequestTelemetry = class ChatRequestTelemetry {
             agent: detectedAgent?.id ?? this.opts.agent.id,
             agentExtensionId: detectedAgent?.extensionId.value ?? this.opts.agent.extensionId.value,
             slashCommand: this.opts.agentSlashCommandPart ? this.opts.agentSlashCommandPart.command.name : this.opts.commandPart?.slashCommand.command,
-            chatSessionId: this.opts.sessionId,
+            chatSessionId: chatSessionResourceToId(this.opts.sessionResource),
             enableCommandDetection: this.opts.enableCommandDetection,
             isParticipantDetected: !!detectedAgent,
             location: this.opts.location,

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

@@ -1,4 +1,4 @@
-import { IDisposable, IReference, ReferenceCollection } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
@@ -8,7 +8,6 @@ export interface IStartSessionProps {
     readonly initialData?: ISerializedChatDataReference;
     readonly location: ChatAgentLocation;
     readonly sessionResource: URI;
-    readonly sessionId?: string;
     readonly canUseTools: boolean;
     readonly transferEditingSession?: IChatEditingSession;
     readonly disableBackgroundKeepAlive?: boolean;
@@ -18,10 +17,10 @@ export interface ChatModelStoreDelegate {
     createModel: (props: IStartSessionProps) => ChatModel;
     willDisposeModel: (model: ChatModel) => Promise<void>;
 }
-export declare class ChatModelStore extends ReferenceCollection<ChatModel> implements IDisposable {
+export declare class ChatModelStore extends Disposable {
     private readonly delegate;
     private readonly logService;
-    private readonly _store;
+    private readonly _refCollection;
     private readonly _models;
     private readonly _modelsToDispose;
     private readonly _pendingDisposals;
@@ -39,8 +38,8 @@ export declare class ChatModelStore extends ReferenceCollection<ChatModel> imple
     has(uri: URI): boolean;
     acquireExisting(uri: URI): IReference<ChatModel> | undefined;
     acquireOrCreate(props: IStartSessionProps): IReference<ChatModel>;
-    protected createReferencedObject(key: string, props?: IStartSessionProps): ChatModel;
-    protected destroyReferencedObject(key: string, object: ChatModel): void;
+    private createReferencedObject;
+    private destroyReferencedObject;
     private doDestroyReferencedObject;
     /**
      * For test use only

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

@@ -1,24 +1,32 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { ReferenceCollection, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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 { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
 
-let ChatModelStore = class ChatModelStore extends ReferenceCollection {
+let ChatModelStore = class ChatModelStore extends Disposable {
     constructor(delegate, logService) {
         super();
         this.delegate = delegate;
         this.logService = logService;
-        this._store = ( new DisposableStore());
         this._models = ( new ObservableMap());
         this._modelsToDispose = ( new Set());
         this._pendingDisposals = ( new Set());
-        this._onDidDisposeModel = this._store.add(( new Emitter()));
+        this._onDidDisposeModel = this._register(( new Emitter()));
         this.onDidDisposeModel = this._onDidDisposeModel.event;
-        this._onDidCreateModel = this._store.add(( new Emitter()));
+        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);
+            }
+            destroyReferencedObject(key, object) {
+                return self.destroyReferencedObject(key, object);
+            }
+        })();
     }
     get observable() {
         return this._models.observable;
@@ -37,10 +45,10 @@ let ChatModelStore = class ChatModelStore extends ReferenceCollection {
         if (!( this._models.has(key))) {
             return undefined;
         }
-        return this.acquire(key);
+        return this._refCollection.acquire(key);
     }
     acquireOrCreate(props) {
-        return this.acquire(this.toKey(props.sessionResource), props);
+        return this._refCollection.acquire(this.toKey(props.sessionResource), props);
     }
     createReferencedObject(key, props) {
         this._modelsToDispose.delete(key);
@@ -90,7 +98,7 @@ let ChatModelStore = class ChatModelStore extends ReferenceCollection {
         return ( uri.toString());
     }
     dispose() {
-        this._store.dispose();
+        super.dispose();
         this._models.forEach(model => model.dispose());
     }
 };

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

@@ -9,6 +9,7 @@ import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IWorkspaceEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service";
 import { IChatSessionStats, IChatSessionTiming, ResponseModelState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 import { ChatModel, ISerializableChatData, ISerializableChatsData, ISerializedChatDataReference } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
@@ -22,13 +23,16 @@ export declare class ChatSessionStore extends Disposable {
     private readonly lifecycleService;
     private readonly userDataProfilesService;
     private readonly configurationService;
-    private readonly storageRoot;
+    private readonly workspaceEditingService;
+    private storageRoot;
     private readonly previousEmptyWindowStorageRoot;
     private readonly transferredSessionStorageRoot;
     private readonly storeQueue;
     private storeTask;
     private shuttingDown;
-    constructor(fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService, workspaceContextService: IWorkspaceContextService, telemetryService: ITelemetryService, storageService: IStorageService, lifecycleService: ILifecycleService, userDataProfilesService: IUserDataProfilesService, configurationService: IConfigurationService);
+    constructor(fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService, workspaceContextService: IWorkspaceContextService, telemetryService: ITelemetryService, storageService: IStorageService, lifecycleService: ILifecycleService, userDataProfilesService: IUserDataProfilesService, configurationService: IConfigurationService, workspaceEditingService: IWorkspaceEditingService);
+    private handleWorkspaceTransition;
+    private migrateSessionsToNewWorkspace;
     storeSessions(sessions: ChatModel[]): Promise<void>;
     storeSessionsMetadataOnly(sessions: ChatModel[]): Promise<void>;
     storeTransferSession(transferData: IChatTransfer, session: ChatModel): Promise<void>;
@@ -68,11 +72,11 @@ export interface IChatSessionEntryMetadata {
     sessionId: string;
     title: string;
     lastMessageDate: number;
-    timing?: IChatSessionTiming;
+    timing: IChatSessionTiming;
     initialLocation?: ChatAgentLocation;
     hasPendingEdits?: boolean;
     stats?: IChatSessionStats;
-    lastResponseState?: ResponseModelState;
+    lastResponseState: ResponseModelState;
     /**
      * This only exists because the migrated data from the storage service had empty sessions persisted, and it's impossible to know which ones are
      * currently in use. Now, `clearSession` deletes empty sessions, so old ones shouldn't take up space in the store anymore, but we still need to

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

@@ -18,8 +18,10 @@ import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { isEmptyWorkspaceIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IWorkspaceEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service';
 import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
 import { ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
@@ -44,7 +46,8 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         storageService,
         lifecycleService,
         userDataProfilesService,
-        configurationService
+        configurationService,
+        workspaceEditingService
     ) {
         super();
         this.fileService = fileService;
@@ -56,6 +59,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         this.lifecycleService = lifecycleService;
         this.userDataProfilesService = userDataProfilesService;
         this.configurationService = configurationService;
+        this.workspaceEditingService = workspaceEditingService;
         this.storeQueue = ( new Sequencer());
         this.shuttingDown = false;
         const workspace = this.workspaceContextService.getWorkspace();
@@ -74,6 +78,12 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             this.userDataProfilesService.defaultProfile.globalStorageHome,
             "transferredChatSessions"
         );
+        this._register(this.workspaceEditingService.onDidEnterWorkspace(event => {
+            const transitionPromise = this.storeQueue.queue(
+                () => this.handleWorkspaceTransition(event.oldWorkspace, event.newWorkspace)
+            );
+            event.join(transitionPromise);
+        }));
         this._register(this.lifecycleService.onWillShutdown(e => {
             this.shuttingDown = true;
             if (!this.storeTask) {
@@ -81,10 +91,96 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: "join.chatSessionStore",
-                label: ( localize(6352, "Saving chat history"))
+                label: ( localize(6904, "Saving chat history"))
             });
         }));
     }
+    async handleWorkspaceTransition(oldWorkspace, newWorkspace) {
+        const wasEmptyWindow = isEmptyWorkspaceIdentifier(oldWorkspace);
+        const isNewWorkspaceEmpty = isEmptyWorkspaceIdentifier(newWorkspace);
+        const oldWorkspaceId = oldWorkspace.id;
+        const newWorkspaceId = newWorkspace.id;
+        this.logService.info(
+            `ChatSessionStore: Workspace transition from ${oldWorkspaceId} to ${newWorkspaceId}`
+        );
+        const oldStorageRoot = wasEmptyWindow ? joinPath(
+            this.userDataProfilesService.defaultProfile.globalStorageHome,
+            "emptyWindowChatSessions"
+        ) : joinPath(
+            this.environmentService.workspaceStorageHome,
+            oldWorkspaceId,
+            "chatSessions"
+        );
+        const newStorageRoot = isNewWorkspaceEmpty ? joinPath(
+            this.userDataProfilesService.defaultProfile.globalStorageHome,
+            "emptyWindowChatSessions"
+        ) : joinPath(
+            this.environmentService.workspaceStorageHome,
+            newWorkspaceId,
+            "chatSessions"
+        );
+        if (( oldStorageRoot.toString()) === ( newStorageRoot.toString())) {
+            this.storageRoot = newStorageRoot;
+            return;
+        }
+        this.storageRoot = newStorageRoot;
+        await this.migrateSessionsToNewWorkspace(oldStorageRoot, wasEmptyWindow, isNewWorkspaceEmpty);
+    }
+    async migrateSessionsToNewWorkspace(oldStorageRoot, wasEmptyWindow, isNewWorkspaceEmpty) {
+        try {
+            const oldStorageExists = await this.fileService.exists(oldStorageRoot);
+            if (!oldStorageExists) {
+                this.logService.info(
+                    `ChatSessionStore: Old storage location does not exist, skipping migration`
+                );
+                return;
+            }
+            const oldDirectory = await this.fileService.resolve(oldStorageRoot);
+            if (!oldDirectory.children) {
+                this.logService.info(
+                    `ChatSessionStore: No children in old storage location, skipping migration`
+                );
+                return;
+            }
+            this.logService.info(
+                `ChatSessionStore: Found ${oldDirectory.children.length} files in old storage location`
+            );
+            let migratedCount = 0;
+            for (const child of oldDirectory.children) {
+                if (!child.isDirectory && (child.name.endsWith(".json") || child.name.endsWith(".jsonl"))) {
+                    const oldFilePath = child.resource;
+                    const newFilePath = joinPath(this.storageRoot, child.name);
+                    try {
+                        await this.fileService.copy(oldFilePath, newFilePath, false);
+                        migratedCount++;
+                    } catch (e) {
+                        if (toFileOperationResult(e) === FileOperationResult.FILE_MOVE_CONFLICT) {
+                            this.logService.trace(
+                                `ChatSessionStore: Session file ${child.name} already exists at target, skipping`
+                            );
+                        } else {
+                            this.reportError("sessionMigration", `Error migrating chat session file ${child.name}`, e);
+                        }
+                    }
+                }
+            }
+            this.logService.info(
+                `ChatSessionStore: Copied ${migratedCount} chat session files from ${wasEmptyWindow ? "empty window" : ( oldStorageRoot.toString())} to ${isNewWorkspaceEmpty ? "empty window" : ( this.storageRoot.toString())} (originals preserved at old location)`
+            );
+            this.indexCache = undefined;
+            try {
+                await this.flushIndex();
+            } catch (e) {
+                this.reportError(
+                    "migrateWorkspace",
+                    "Error flushing chat session index after workspace migration",
+                    e
+                );
+            }
+        } catch (e) {
+            this.reportError("migrateWorkspace", "Error migrating chat sessions to new workspace", e);
+        }
+    }
     async storeSessions(sessions) {
         if (this.shuttingDown) {
             return;
@@ -257,7 +353,8 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             } else {
                 await this.fileService.writeFile(storageLocation.flat, VSBuffer.fromString(JSON.stringify(session)));
             }
-            index.entries[session.sessionId] = await getSessionMetadata(session);
+            const newMetadata = await getSessionMetadata(session);
+            index.entries[session.sessionId] = newMetadata;
         } catch (e) {
             this.reportError("sessionWrite", "Error writing chat session", e);
         }
@@ -389,15 +486,22 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                     entries: {}
                 };
             }
-            return this.indexCache;
         } catch (e) {
             this.reportError("invalidIndexJSON", `Index corrupt: ${data}`, e);
             this.indexCache = {
                 version: 1,
                 entries: {}
             };
-            return this.indexCache;
         }
+        for (const entry of ( Object.values(this.indexCache.entries))) {
+            entry.timing ??= {
+                created: entry.lastMessageDate,
+                lastRequestStarted: undefined,
+                lastRequestEnded: entry.lastMessageDate
+            };
+            entry.lastResponseState ??= entry.lastResponseState === ResponseModelState.Pending || entry.lastResponseState === ResponseModelState.NeedsInput ? ResponseModelState.Complete : entry.lastResponseState || ResponseModelState.Complete;
+        }
+        return this.indexCache;
     }
     async getIndex() {
         return this.storeQueue.queue(async () => {
@@ -534,7 +638,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         return this.storageRoot;
     }
 };
-ChatSessionStore = ChatSessionStore_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IEnvironmentService)), ( __param(2, ILogService)), ( __param(3, IWorkspaceContextService)), ( __param(4, ITelemetryService)), ( __param(5, IStorageService)), ( __param(6, ILifecycleService)), ( __param(7, IUserDataProfilesService)), ( __param(8, IConfigurationService))], ChatSessionStore));
+ChatSessionStore = ChatSessionStore_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IEnvironmentService)), ( __param(2, ILogService)), ( __param(3, IWorkspaceContextService)), ( __param(4, ITelemetryService)), ( __param(5, IStorageService)), ( __param(6, ILifecycleService)), ( __param(7, IUserDataProfilesService)), ( __param(8, IConfigurationService)), ( __param(9, IWorkspaceEditingService))], ChatSessionStore));
 function isChatSessionEntryMetadata(obj) {
     return (!!obj && typeof obj === "object" && typeof obj.sessionId === "string" && typeof obj.title === "string" && typeof obj.lastMessageDate === "number");
 }
@@ -575,7 +679,7 @@ async function getSessionMetadata(session) {
     }
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(6353, "New Chat")),
+        title: title || ( localize(6905, "New Chat")),
         lastMessageDate,
         timing,
         initialLocation: session.initialLocation,

package/vscode/src/vs/workbench/contrib/chat/common/participants/chatSlashCommands.d.ts

@@ -7,6 +7,7 @@ import { IChatFollowup, IChatProgress, IChatResponseProgressFileTreeData } from
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
 import { ChatAgentLocation, ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
 import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service";
 export interface IChatSlashData {
     command: string;
@@ -27,6 +28,7 @@ export interface IChatSlashData {
     silent?: boolean;
     locations: ChatAgentLocation[];
     modes?: ChatModeKind[];
+    target?: Target;
 }
 export interface IChatSlashFragment {
     content: string | {

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

@@ -0,0 +1,52 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { HookType, IHookCommand } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema";
+import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
+export interface IAgentPluginHook {
+    readonly type: HookType;
+    readonly hooks: readonly IHookCommand[];
+    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 IAgentPluginMcpServerDefinition {
+    readonly name: string;
+    readonly configuration: IMcpServerConfiguration;
+}
+export interface IAgentPlugin {
+    readonly uri: URI;
+    readonly enabled: IObservable<boolean>;
+    setEnabled(enabled: boolean): void;
+    readonly hooks: IObservable<readonly IAgentPluginHook[]>;
+    readonly commands: IObservable<readonly IAgentPluginCommand[]>;
+    readonly skills: IObservable<readonly IAgentPluginSkill[]>;
+    readonly agents: IObservable<readonly IAgentPluginAgent[]>;
+    readonly mcpServerDefinitions: IObservable<readonly IAgentPluginMcpServerDefinition[]>;
+    /** Set when the plugin was installed from a marketplace repository. */
+    readonly fromMarketplace?: IMarketplacePlugin;
+}
+export interface IAgentPluginDiscovery extends IDisposable {
+    readonly plugins: IObservable<readonly IAgentPlugin[]>;
+    start(): void;
+}
+export declare function getCanonicalPluginCommandId(plugin: IAgentPlugin, commandName: string): string;
+declare class AgentPluginDiscoveryRegistry {
+    private readonly _discovery;
+    register(descriptor: SyncDescriptor0<IAgentPluginDiscovery>): void;
+    getAll(): readonly SyncDescriptor0<IAgentPluginDiscovery>[];
+}
+export declare const agentPluginDiscoveryRegistry: AgentPluginDiscoveryRegistry;
+export {};

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

@@ -0,0 +1,29 @@
+
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+
+function getCanonicalPluginCommandId(plugin, commandName) {
+    const pluginSegment = basename(plugin.uri);
+    const prefix = normalizePluginToken(pluginSegment);
+    const normalizedCommand = normalizePluginToken(commandName);
+    if (normalizedCommand.startsWith(`${prefix}:`)) {
+        return normalizedCommand;
+    }
+    return `${prefix}:${normalizedCommand}`;
+}
+function normalizePluginToken(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_.:-]/g, "-").replace(/-+/g, "-").replace(/^[-:.]+|[-:.]+$/g, "");
+}
+class AgentPluginDiscoveryRegistry {
+    constructor() {
+        this._discovery = [];
+    }
+    register(descriptor) {
+        this._discovery.push(descriptor);
+    }
+    getAll() {
+        return this._discovery;
+    }
+}
+const agentPluginDiscoveryRegistry = ( new AgentPluginDiscoveryRegistry());
+
+export { agentPluginDiscoveryRegistry, getCanonicalPluginCommandId };

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

@@ -0,0 +1,73 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { 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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IAgentPlugin, IAgentPluginDiscovery } from "./agentPluginService.js";
+import { IAgentPluginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service";
+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;
+export declare class AgentPluginService extends Disposable implements IAgentPluginService {
+    readonly _serviceBrand: undefined;
+    readonly allPlugins: IObservable<readonly IAgentPlugin[]>;
+    readonly plugins: IObservable<readonly IAgentPlugin[]>;
+    constructor(instantiationService: IInstantiationService, configurationService: IConfigurationService);
+    setPluginEnabled(pluginUri: URI, enabled: boolean): void;
+    private _dedupeAndSort;
+}
+export declare class ConfiguredAgentPluginDiscovery extends Disposable implements IAgentPluginDiscovery {
+    private readonly _configurationService;
+    private readonly _fileService;
+    private readonly _pluginMarketplaceService;
+    private readonly _workspaceContextService;
+    private readonly _pathService;
+    private readonly _logService;
+    private readonly _instantiationService;
+    private readonly _pluginPathsConfig;
+    private readonly _pluginEntries;
+    private readonly _plugins;
+    readonly plugins: IObservable<readonly IAgentPlugin[]>;
+    private _discoverVersion;
+    constructor(_configurationService: IConfigurationService, _fileService: IFileService, _pluginMarketplaceService: IPluginMarketplaceService, _workspaceContextService: IWorkspaceContextService, _pathService: IPathService, _logService: ILogService, _instantiationService: IInstantiationService);
+    start(): void;
+    private _refreshPlugins;
+    private _discoverPlugins;
+    /**
+     * Resolves a plugin path to one or more resource URIs. Absolute paths are
+     * used directly; relative paths are resolved against each workspace folder.
+     */
+    private _resolvePluginPath;
+    /**
+     * Updates the enabled state of a plugin path in the configuration,
+     * writing to the most specific config target where the key is defined.
+     */
+    private _updatePluginPathEnabled;
+    private _detectPluginFormatAdapter;
+    private _pathExists;
+    private _toPlugin;
+    private _readMcpDefinitions;
+    private _readInlinePluginJsonMcpDefinitions;
+    private _parseMcpServerDefinitionMap;
+    private _normalizeMcpServerConfiguration;
+    private _readHooks;
+    private _readJsonFile;
+    private _readSkills;
+    private _readAgents;
+    private _readCommands;
+    private _disposePluginEntriesExcept;
+    dispose(): void;
+}