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

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(7243, "Saving chat history"))
+                label: ( localize(7300, "Saving chat history"))
             });
         }));
     }
@@ -356,14 +356,14 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                             this._didReportIssue = true;
                             this.dialogService.prompt({
                                 custom: true,
-                                title: ( localize(7244, "Error saving chat session")),
+                                title: ( localize(7301, "Error saving chat session")),
                                 message: ( localize(
-                                    7245,
+                                    7302,
                                     "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(7246, "Report Issue")),
+                                    label: ( localize(7303, "Report Issue")),
                                     run: () => this.openerService.open("https://github.com/microsoft/vscode/issues/new?template=bug_report.md")
                                 }]
                             });
@@ -708,7 +708,7 @@ async function getSessionMetadata(session) {
     }
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(7247, "New Chat")),
+        title: title || ( localize(7304, "New Chat")),
         lastMessageDate,
         timing,
         initialLocation: session.initialLocation,
@@ -716,7 +716,8 @@ async function getSessionMetadata(session) {
         isEmpty: session instanceof ChatModel ? session.getRequests().length === 0 : session.requests.length === 0,
         stats,
         isExternal: session instanceof ChatModel && !LocalChatSessionUri.parseLocalSessionId(session.sessionResource),
-        lastResponseState
+        lastResponseState,
+        permissionLevel: session instanceof ChatModel ? session.inputModel.state.get()?.permissionLevel : undefined
     };
 }
 

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

@@ -1,16 +1,19 @@
 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 { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.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 { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
 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 } from "./agentPluginService.js";
+import { IAgentPlugin, IAgentPluginDiscovery, IAgentPluginMcpServerDefinition } 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";
@@ -32,6 +35,21 @@ export declare function shellQuotePluginRootInCommand(command: string, fsPath: s
  * 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 declare class AgentPluginService extends Disposable implements IAgentPluginService {
     readonly _serviceBrand: undefined;
     readonly plugins: IObservable<readonly IAgentPlugin[]>;
@@ -138,4 +156,16 @@ export declare class MarketplaceAgentPluginDiscovery extends AbstractAgentPlugin
     start(enablementModel: IEnablementModel): void;
     protected _discoverPluginSources(): Promise<readonly IPluginSource[]>;
 }
+export declare class ExtensionAgentPluginDiscovery extends AbstractAgentPluginDiscovery {
+    private readonly _commandService;
+    private readonly _contextKeyService;
+    private readonly _dialogService;
+    private readonly _extensionPlugins;
+    private readonly _whenKeys;
+    constructor(_commandService: ICommandService, _contextKeyService: IContextKeyService, _dialogService: IDialogService, fileService: IFileService, pathService: IPathService, logService: ILogService, instantiationService: IInstantiationService);
+    start(enablementModel: IEnablementModel): void;
+    private _rebuildWhenKeys;
+    protected _discoverPluginSources(): Promise<readonly IPluginSource[]>;
+    private _promptUninstallExtension;
+}
 export {};

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

@@ -13,15 +13,24 @@ import { joinPath, normalizePath, isEqualOrParent, basename, extname } from '@co
 import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
 import { ConfigurationTarget, getConfigValueInTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { 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 { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
 import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
+import { ExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { EnablementModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
@@ -147,6 +156,19 @@ function interpolateMcpPluginRoot(def, fsPath, token, envVar) {
         uri: def.uri
     };
 }
+const BARE_ENV_VAR_RE = /\$\{(?![A-Za-z]+:)([A-Z_][A-Z0-9_]*)\}/g;
+function convertBareEnvVarsToVsCodeSyntax(def) {
+    return cloneAndChange(def, value => {
+        if (URI.isUri(value)) {
+            return value;
+        }
+        if (typeof value === "string") {
+            const replaced = value.replace(BARE_ENV_VAR_RE, "${env:$1}");
+            return replaced !== value ? replaced : undefined;
+        }
+        return undefined;
+    });
+}
 function parsePluginRootHooks(hookURI, json, pluginUri, userHome, workspaceContextService, token, envVar) {
     const fsPath = pluginUri.fsPath;
     const typedJson = json;
@@ -535,6 +557,7 @@ class AbstractAgentPluginDiscovery extends Disposable {
             if (adapter.pluginRootToken && adapter.pluginRootEnvVar) {
                 def = interpolateMcpPluginRoot(def, pluginFsPath, adapter.pluginRootToken, adapter.pluginRootEnvVar);
             }
+            def = convertBareEnvVarsToVsCodeSyntax(def);
             definitions.push(def);
         }
         return definitions;
@@ -893,5 +916,209 @@ let MarketplaceAgentPluginDiscovery = class MarketplaceAgentPluginDiscovery exte
     }
 };
 MarketplaceAgentPluginDiscovery = ( __decorate([( __param(0, IPluginMarketplaceService)), ( __param(1, IAgentPluginRepositoryService)), ( __param(2, IFileService)), ( __param(3, IPathService)), ( __param(4, ILogService)), ( __param(5, IInstantiationService))], MarketplaceAgentPluginDiscovery));
+const epPlugins = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: "chatPlugins",
+    jsonSchema: {
+        description: ( localize(7305, "Contributes agent plugins for chat.")),
+        type: "array",
+        items: {
+            additionalProperties: false,
+            type: "object",
+            defaultSnippets: [{
+                body: {
+                    path: "./relative/path/to/plugin/"
+                }
+            }],
+            required: ["path"],
+            properties: {
+                path: {
+                    description: ( localize(
+                        7306,
+                        "Path to the agent plugin root directory relative to the extension root."
+                    )),
+                    type: "string"
+                },
+                when: {
+                    description: ( localize(7307, "(Optional) A condition which must be true to enable this plugin.")),
+                    type: "string"
+                }
+            }
+        }
+    }
+});
+let ExtensionAgentPluginDiscovery = class ExtensionAgentPluginDiscovery extends AbstractAgentPluginDiscovery {
+    constructor(
+        _commandService,
+        _contextKeyService,
+        _dialogService,
+        fileService,
+        pathService,
+        logService,
+        instantiationService
+    ) {
+        super(fileService, pathService, logService, instantiationService);
+        this._commandService = _commandService;
+        this._contextKeyService = _contextKeyService;
+        this._dialogService = _dialogService;
+        this._extensionPlugins = ( new Map());
+        this._whenKeys = ( new Set());
+    }
+    start(enablementModel) {
+        this._enablementModel = enablementModel;
+        const scheduler = this._register(( new RunOnceScheduler(() => this._refreshPlugins(), 0)));
+        this._register(this._contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(this._whenKeys)) {
+                scheduler.schedule();
+            }
+        }));
+        epPlugins.setHandler((_extensions, delta) => {
+            for (const ext of delta.added) {
+                for (const raw of ext.value) {
+                    if (!raw.path) {
+                        ext.collector.error(( localize(
+                            7308,
+                            "Extension '{0}' cannot register a chatPlugins entry without a path.",
+                            ext.description.identifier.value
+                        )));
+                        continue;
+                    }
+                    const pluginUri = joinPath(ext.description.extensionLocation, raw.path);
+                    if (!isEqualOrParent(pluginUri, ext.description.extensionLocation)) {
+                        ext.collector.error(( localize(
+                            7309,
+                            "Extension '{0}' chatPlugins entry '{1}' resolves outside the extension.",
+                            ext.description.identifier.value,
+                            raw.path
+                        )));
+                        continue;
+                    }
+                    let whenExpr;
+                    if (raw.when) {
+                        whenExpr = ContextKeyExpr.deserialize(raw.when);
+                        if (!whenExpr) {
+                            ext.collector.error(( localize(
+                                7310,
+                                "Extension '{0}' chatPlugins entry '{1}' has an invalid when clause: '{2}'.",
+                                ext.description.identifier.value,
+                                raw.path,
+                                raw.when
+                            )));
+                            continue;
+                        }
+                    }
+                    this._extensionPlugins.set(extensionPluginKey(ext.description.identifier, raw.path), {
+                        uri: pluginUri,
+                        when: whenExpr,
+                        extensionId: ext.description.identifier.value
+                    });
+                }
+            }
+            for (const ext of delta.removed) {
+                for (const raw of ext.value) {
+                    this._extensionPlugins.delete(extensionPluginKey(ext.description.identifier, raw.path));
+                }
+            }
+            this._rebuildWhenKeys();
+            scheduler.schedule();
+        });
+    }
+    _rebuildWhenKeys() {
+        this._whenKeys.clear();
+        for (const {
+            when
+        } of ( this._extensionPlugins.values())) {
+            if (when) {
+                for (const key of ( when.keys())) {
+                    this._whenKeys.add(key);
+                }
+            }
+        }
+    }
+    async _discoverPluginSources() {
+        const sources = [];
+        for (const [, entry] of this._extensionPlugins) {
+            if (entry.when && !this._contextKeyService.contextMatchesRules(entry.when)) {
+                continue;
+            }
+            let stat;
+            try {
+                stat = await this._fileService.resolve(entry.uri);
+            } catch {
+                this._logService.debug(
+                    `[ExtensionAgentPluginDiscovery] Could not resolve extension plugin path: ${( entry.uri.toString())}`
+                );
+                continue;
+            }
+            if (!stat.isDirectory) {
+                this._logService.debug(
+                    `[ExtensionAgentPluginDiscovery] Extension plugin path is not a directory: ${( entry.uri.toString())}`
+                );
+                continue;
+            }
+            sources.push({
+                uri: stat.resource,
+                fromMarketplace: undefined,
+                remove: () => this._promptUninstallExtension(entry.extensionId)
+            });
+        }
+        return sources;
+    }
+    async _promptUninstallExtension(extensionId) {
+        const {
+            confirmed
+        } = await this._dialogService.confirm({
+            message: ( localize(
+                7311,
+                "This plugin is provided by the extension '{0}'. Do you want to uninstall the extension?",
+                extensionId
+            ))
+        });
+        if (confirmed) {
+            await this._commandService.executeCommand("workbench.extensions.uninstallExtension", extensionId);
+        }
+    }
+};
+ExtensionAgentPluginDiscovery = ( __decorate([( __param(0, ICommandService)), ( __param(1, IContextKeyService)), ( __param(2, IDialogService)), ( __param(3, IFileService)), ( __param(4, IPathService)), ( __param(5, ILogService)), ( __param(6, IInstantiationService))], ExtensionAgentPluginDiscovery));
+function extensionPluginKey(extensionId, path) {
+    return `${extensionId.value}/${path}`;
+}
+class ChatPluginsDataRenderer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.type = "table";
+    }
+    shouldRender(manifest) {
+        return !!manifest.contributes?.chatPlugins?.length;
+    }
+    render(manifest) {
+        const contributions = manifest.contributes?.chatPlugins ?? [];
+        if (!contributions.length) {
+            return {
+                data: {
+                    headers: [],
+                    rows: []
+                },
+                dispose: () => {}
+            };
+        }
+        const headers = [( localize(7312, "Path")), ( localize(7313, "When"))];
+        const rows = ( contributions.map(d => [d.path, d.when ?? "-"]));
+        return {
+            data: {
+                headers,
+                rows
+            },
+            dispose: () => {}
+        };
+    }
+}
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: "chatPlugins",
+    label: ( localize(7314, "Chat Plugins")),
+    access: {
+        canToggle: false
+    },
+    renderer: ( new SyncDescriptor(ChatPluginsDataRenderer))
+});
 
-export { AbstractAgentPluginDiscovery, AgentPluginService, ConfiguredAgentPluginDiscovery, MarketplaceAgentPluginDiscovery, resolveMcpServersMap, shellQuotePluginRootInCommand };
+export { AbstractAgentPluginDiscovery, AgentPluginService, ConfiguredAgentPluginDiscovery, ExtensionAgentPluginDiscovery, MarketplaceAgentPluginDiscovery, convertBareEnvVarsToVsCodeSyntax, resolveMcpServersMap, shellQuotePluginRootInCommand };

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

@@ -0,0 +1,66 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, ITransaction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+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 { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+/**
+ * In-memory representation of an installed plugin entry.
+ */
+export interface IStoredInstalledPlugin {
+    readonly pluginUri: URI;
+    readonly marketplace: string;
+}
+/**
+ * An observable store for installed agent plugins that is backed by a
+ * `installed.json` file within the agent-plugins directory. This makes
+ * the installed-plugin manifest discoverable by external tools (CLIs,
+ * other editors, etc.) without depending on VS Code internals.
+ *
+ * The on-disk format stores only the plugin URI (as a string) and the
+ * marketplace identifier. Plugin metadata (name, description, etc.) is
+ * read from the plugin manifest on disk by the discovery layer -
+ * keeping a single source of truth.
+ *
+ * On construction the store:
+ * 1. Attempts to read `installed.json` from the agent-plugins directory.
+ * 2. If no file exists, migrates data from the legacy {@link StorageService}
+ *    key (`chat.plugins.installed.v1`), rebasing plugin URIs from the old
+ *    cache directory to the new agent-plugins directory.
+ * 3. Sets up a correlated file watcher so that external edits to
+ *    `installed.json` are picked up automatically.
+ *
+ * Write operations update the in-memory observable synchronously and
+ * schedule a debounced file write so that rapid successive mutations
+ * (e.g. batch enables) are coalesced into a single I/O operation.
+ */
+export declare class FileBackedInstalledPluginsStore extends Disposable {
+    private readonly _agentPluginsHome;
+    private readonly _oldCacheRoot;
+    private readonly _fileService;
+    private readonly _logService;
+    private readonly _storageService;
+    private readonly _installed;
+    private readonly _fileUri;
+    private readonly _writeDelayer;
+    private _suppressFileWatch;
+    private _initialized;
+    readonly value: IObservable<readonly IStoredInstalledPlugin[]>;
+    constructor(_agentPluginsHome: URI, _oldCacheRoot: URI | undefined, _fileService: IFileService, _logService: ILogService, _storageService: IStorageService);
+    get(): readonly IStoredInstalledPlugin[];
+    set(newValue: readonly IStoredInstalledPlugin[], tx: ITransaction | undefined): void;
+    private _initialize;
+    private _readFromFile;
+    private _scheduleWrite;
+    private _writeToFile;
+    private _setupFileWatcher;
+    private _onFileChanged;
+    private _setValue;
+    private _migrateFromStorage;
+    /**
+     * If the plugin URI was under the old cache root, rebase it to the
+     * new agent-plugins directory. Otherwise, return `undefined` to keep
+     * the original.
+     */
+    private _rebasePluginUri;
+}

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

@@ -0,0 +1,190 @@
+
+import { ThrottledDelayer, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { joinPath, isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const INSTALLED_JSON_FILENAME = "installed.json";
+const INSTALLED_JSON_VERSION = 1;
+const LEGACY_INSTALLED_PLUGINS_STORAGE_KEY = "chat.plugins.installed.v1";
+const LEGACY_MARKETPLACE_INDEX_STORAGE_KEY = "chat.plugins.marketplaces.index.v1";
+class FileBackedInstalledPluginsStore extends Disposable {
+    constructor(
+        _agentPluginsHome,
+        _oldCacheRoot,
+        _fileService,
+        _logService,
+        _storageService
+    ) {
+        super();
+        this._agentPluginsHome = _agentPluginsHome;
+        this._oldCacheRoot = _oldCacheRoot;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._storageService = _storageService;
+        this._installed = observableValue("file/installed.json", []);
+        this._suppressFileWatch = false;
+        this._initialized = false;
+        this.value = this._installed;
+        this._fileUri = joinPath(_agentPluginsHome, INSTALLED_JSON_FILENAME);
+        this._writeDelayer = this._register(( new ThrottledDelayer(100)));
+        void this._initialize();
+    }
+    get() {
+        return this._installed.get();
+    }
+    set(newValue, tx) {
+        this._setValue(newValue, tx, true);
+    }
+    async _initialize() {
+        try {
+            const read = await this._readFromFile();
+            if (read !== undefined) {
+                this._setValue(read, undefined, false);
+            } else {
+                await this._migrateFromStorage();
+            }
+        } catch (error) {
+            this._logService.error("[FileBackedInstalledPluginsStore] Initialization failed", error);
+        }
+        this._initialized = true;
+        this._setupFileWatcher();
+    }
+    async _readFromFile() {
+        try {
+            const exists = await this._fileService.exists(this._fileUri);
+            if (!exists) {
+                return undefined;
+            }
+            const content = await this._fileService.readFile(this._fileUri);
+            const json = JSON.parse(( content.value.toString()));
+            if (!json || !Array.isArray(json.installed)) {
+                this._logService.warn(
+                    "[FileBackedInstalledPluginsStore] installed.json has unexpected format, ignoring"
+                );
+                return undefined;
+            }
+            return ( json.installed.filter(
+                entry => typeof entry.pluginUri === "string" && typeof entry.marketplace === "string"
+            ).map(entry => ({
+                pluginUri: ( URI.parse(entry.pluginUri)),
+                marketplace: entry.marketplace
+            })));
+        } catch {
+            return undefined;
+        }
+    }
+    _scheduleWrite() {
+        void this._writeDelayer.trigger(async () => {
+            await this._writeToFile();
+        });
+    }
+    async _writeToFile() {
+        const entries = ( this.get().map(e => ({
+            pluginUri: ( e.pluginUri.toString()),
+            marketplace: e.marketplace
+        })));
+        const data = {
+            version: INSTALLED_JSON_VERSION,
+            installed: entries
+        };
+        try {
+            this._suppressFileWatch = true;
+            const content = JSON.stringify(data, undefined, "\t");
+            await this._fileService.createFolder(this._agentPluginsHome);
+            await this._fileService.writeFile(this._fileUri, VSBuffer.fromString(content));
+            return true;
+        } catch (error) {
+            this._logService.error("[FileBackedInstalledPluginsStore] Failed to write installed.json", error);
+            return false;
+        } finally {
+            this._suppressFileWatch = false;
+        }
+    }
+    _setupFileWatcher() {
+        if (typeof this._fileService.createWatcher !== "function") {
+            return;
+        }
+        const dir = this._agentPluginsHome;
+        const watcher = this._fileService.createWatcher(dir, {
+            recursive: false,
+            excludes: []
+        });
+        this._register(watcher);
+        const scheduler = this._register(( new RunOnceScheduler(() => this._onFileChanged(), 100)));
+        this._register(watcher.onDidChange(e => {
+            if (!this._suppressFileWatch && e.affects(this._fileUri)) {
+                scheduler.schedule();
+            }
+        }));
+    }
+    async _onFileChanged() {
+        const read = await this._readFromFile();
+        if (read !== undefined) {
+            this._suppressFileWatch = true;
+            try {
+                this._setValue(read, undefined, false);
+            } finally {
+                this._suppressFileWatch = false;
+            }
+        }
+    }
+    _setValue(newValue, tx, scheduleWrite) {
+        this._installed.set(newValue, tx);
+        if (scheduleWrite && this._initialized && !this._suppressFileWatch) {
+            this._scheduleWrite();
+        }
+    }
+    async _migrateFromStorage() {
+        const raw = this._storageService.get(LEGACY_INSTALLED_PLUGINS_STORAGE_KEY, StorageScope.APPLICATION);
+        if (!raw) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed) || parsed.length === 0) {
+                return;
+            }
+            const migrated = ( revive(parsed).map(entry => {
+                const uri = URI.revive(entry.pluginUri);
+                const rebased = this._rebasePluginUri(uri);
+                return {
+                    pluginUri: rebased ?? uri,
+                    marketplace: entry.plugin?.marketplaceReference?.rawValue ?? ""
+                };
+            })).filter(e => !!e.marketplace);
+            this._logService.info(
+                `[FileBackedInstalledPluginsStore] Migrating ${migrated.length} plugin(s) from storage to installed.json`
+            );
+            this._setValue(migrated, undefined, false);
+            const didPersist = await this._writeToFile();
+            if (!didPersist) {
+                return;
+            }
+            this._storageService.remove(LEGACY_INSTALLED_PLUGINS_STORAGE_KEY, StorageScope.APPLICATION);
+            this._storageService.remove(LEGACY_MARKETPLACE_INDEX_STORAGE_KEY, StorageScope.APPLICATION);
+        } catch (error) {
+            this._logService.error("[FileBackedInstalledPluginsStore] Migration from storage failed", error);
+        }
+    }
+    _rebasePluginUri(uri) {
+        if (!this._oldCacheRoot) {
+            return undefined;
+        }
+        const oldRoot = this._oldCacheRoot;
+        if (!isEqual(uri, oldRoot) && uri.scheme === oldRoot.scheme && uri.path.startsWith(oldRoot.path + "/")) {
+            const relativePart = uri.path.substring(oldRoot.path.length);
+            return uri.with({
+                path: this._agentPluginsHome.path + relativePart
+            });
+        }
+        return undefined;
+    }
+}
+
+export { FileBackedInstalledPluginsStore };