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

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.js

@@ -1,11 +1,15 @@
 
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { IAgentEditorCommentsBridge } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentEditorComments/common/agentEditorComments.service';
 
-class PlanReviewFeedbackService extends Disposable {
-    constructor() {
-        super(...arguments);
+let PlanReviewFeedbackService = class PlanReviewFeedbackService extends Disposable {
+    constructor(_commentsBridge) {
+        super();
+        this._commentsBridge = _commentsBridge;
+        this.priority = 0;
         this._registrations = ( new Map());
         this._onDidChangeFeedback = this._register(( new Emitter()));
         this.onDidChangeFeedback = this._onDidChangeFeedback.event;
@@ -13,34 +17,99 @@ class PlanReviewFeedbackService extends Disposable {
         this.onDidChangeNavigation = this._onDidChangeNavigation.event;
         this._onDidChangeRegistrations = this._register(( new Emitter()));
         this.onDidChangeRegistrations = this._onDidChangeRegistrations.event;
+        this._onDidChangePlanReviewScope = this._register(( new Emitter()));
+        this.onDidChangePlanReviewScope = this._onDidChangePlanReviewScope.event;
+        this.onDidChangeComments = Event.signal(Event.any(this.onDidChangeFeedback, this.onDidChangeRegistrations));
+        this.onDidRevealComment = Event.None;
+        this._register(this._commentsBridge.registerProvider(this));
     }
-    registerPlanReview(planUri, onSubmit) {
+    registerPlanReview(planUri, review) {
         const key = ( planUri.toString());
-        this._registrations.set(key, {
-            onSubmit,
+        const registrations = this._registrations.get(key) ?? [];
+        const previous = registrations.at(-1);
+        if (previous) {
+            this._onDidChangePlanReviewScope.fire({
+                planUri,
+                sessionResource: previous.review.sessionResource,
+                active: false
+            });
+        }
+        const registration = {
+            review,
             items: [],
+            existingCommentIds: ( new Set()),
             navigationAnchor: undefined
+        };
+        registrations.push(registration);
+        this._registrations.set(key, registrations);
+        this._onDidChangePlanReviewScope.fire({
+            planUri,
+            sessionResource: review.sessionResource,
+            active: true
         });
+        for (const commentId of this._commentsBridge.getCommentIds(planUri, true)) {
+            registration.existingCommentIds.add(commentId);
+        }
         this._onDidChangeRegistrations.fire();
         return toDisposable(() => {
-            this._registrations.delete(key);
+            const index = registrations.indexOf(registration);
+            if (index === -1) {
+                return;
+            }
+            const wasActive = index === registrations.length - 1;
+            registrations.splice(index, 1);
+            if (registrations.length === 0) {
+                this._registrations.delete(key);
+            }
+            if (wasActive) {
+                this._onDidChangePlanReviewScope.fire({
+                    planUri,
+                    sessionResource: review.sessionResource,
+                    active: false
+                });
+                const active = registrations.at(-1);
+                if (active) {
+                    this._onDidChangePlanReviewScope.fire({
+                        planUri,
+                        sessionResource: active.review.sessionResource,
+                        active: true
+                    });
+                }
+            }
             this._onDidChangeRegistrations.fire();
         });
     }
     isActivePlanReview(uri) {
-        return ( this._registrations.has(( uri.toString())));
+        return this._getRegistration(uri) !== undefined;
+    }
+    getPlanReview(uri) {
+        return this._getRegistration(uri)?.review;
+    }
+    notifyFeedbackChanged(planUri) {
+        if (this.isActivePlanReview(planUri)) {
+            this._onDidChangeFeedback.fire(planUri);
+        }
     }
     addFeedback(planUri, line, column, text) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
+        return this._addFeedback(planUri, {
+            startLineNumber: line,
+            startColumn: column,
+            endLineNumber: line,
+            endColumn: column
+        }, text);
+    }
+    _addFeedback(planUri, range, text) {
+        const registration = this._getRegistration(planUri);
         if (!registration) {
             return "";
         }
         const id = generateUuid();
         registration.items.push({
             id,
-            line,
-            column,
+            resource: planUri,
+            range,
+            line: range.startLineNumber,
+            column: range.startColumn,
             text
         });
         registration.items.sort((a, b) => a.line - b.line || a.column - b.column);
@@ -48,8 +117,7 @@ class PlanReviewFeedbackService extends Disposable {
         return id;
     }
     removeFeedback(planUri, feedbackId) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
+        const registration = this._getRegistration(planUri);
         if (!registration) {
             return;
         }
@@ -57,11 +125,15 @@ class PlanReviewFeedbackService extends Disposable {
         if (idx >= 0) {
             registration.items.splice(idx, 1);
             this._onDidChangeFeedback.fire(planUri);
+            return;
+        }
+        const item = this.getFeedback(planUri).find(candidate => candidate.id === feedbackId);
+        if (item) {
+            this._commentsBridge.deleteComment(planUri, item.id);
         }
     }
     updateFeedback(planUri, feedbackId, newText) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
+        const registration = this._getRegistration(planUri);
         if (!registration) {
             return;
         }
@@ -69,35 +141,48 @@ class PlanReviewFeedbackService extends Disposable {
         if (idx >= 0) {
             const old = registration.items[idx];
             registration.items[idx] = {
-                id: old.id,
-                line: old.line,
-                column: old.column,
+                ...old,
                 text: newText
             };
             this._onDidChangeFeedback.fire(planUri);
         }
     }
     getFeedback(planUri) {
-        const key = ( planUri.toString());
-        return this._registrations.get(key)?.items ?? [];
+        const registration = this._getRegistration(planUri);
+        if (!registration) {
+            return [];
+        }
+        return ( this._commentsBridge.getComments(planUri, true).filter(comment => !( registration.existingCommentIds.has(comment.id))).map(comment => ({
+            id: comment.id,
+            resource: comment.resource,
+            range: comment.range,
+            line: comment.range.startLineNumber,
+            column: comment.range.startColumn,
+            text: comment.body
+        })));
     }
     clearFeedback(planUri) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
-        if (!registration || registration.items.length === 0) {
+        const registration = this._getRegistration(planUri);
+        if (!registration) {
             return;
         }
+        const feedback = this.getFeedback(planUri);
+        const localIds = ( new Set(( registration.items.map(item => item.id))));
         registration.items.length = 0;
         registration.navigationAnchor = undefined;
+        for (const item of feedback) {
+            if (!( localIds.has(item.id))) {
+                this._commentsBridge.deleteComment(planUri, item.id);
+            }
+        }
         this._onDidChangeFeedback.fire(planUri);
     }
     getNextFeedback(planUri, next) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
-        if (!registration || registration.items.length === 0) {
+        const registration = this._getRegistration(planUri);
+        const items = this.getFeedback(planUri);
+        if (!registration || items.length === 0) {
             return undefined;
         }
-        const items = registration.items;
         const anchorIdx = registration.navigationAnchor ? items.findIndex(item => item.id === registration.navigationAnchor) : -1;
         let targetIdx;
         if (anchorIdx === -1) {
@@ -107,61 +192,75 @@ class PlanReviewFeedbackService extends Disposable {
         }
         const target = items[targetIdx];
         this.setNavigationAnchor(planUri, target.id);
+        this._commentsBridge.revealComment(target.resource, target.id);
         return target;
     }
     getNavigationBearing(planUri) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
+        const registration = this._getRegistration(planUri);
         if (!registration) {
             return {
                 activeIdx: -1,
                 totalCount: 0
             };
         }
-        const totalCount = registration.items.length;
+        const items = this.getFeedback(planUri);
+        const totalCount = items.length;
         if (!registration.navigationAnchor) {
             return {
                 activeIdx: -1,
                 totalCount
             };
         }
-        const activeIdx = registration.items.findIndex(item => item.id === registration.navigationAnchor);
+        const activeIdx = items.findIndex(item => item.id === registration.navigationAnchor);
         return {
             activeIdx,
             totalCount
         };
     }
     setNavigationAnchor(planUri, itemId) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
+        const registration = this._getRegistration(planUri);
         if (registration) {
             registration.navigationAnchor = itemId;
             this._onDidChangeNavigation.fire(planUri);
         }
     }
-    submitAllFeedback(planUri) {
-        const key = ( planUri.toString());
-        const registration = this._registrations.get(key);
-        if (!registration || registration.items.length === 0) {
-            return;
+    async submitAllFeedback(planUri) {
+        const registration = this._getRegistration(planUri);
+        if (!registration || (this.getFeedback(planUri).length === 0 && !registration.review.hasOverallFeedback())) {
+            return false;
         }
-        const formatted = this._formatFeedback(registration.items);
-        registration.onSubmit({
-            rejected: false,
-            feedback: formatted
-        });
+        return registration.review.submitFeedback();
     }
-    _formatFeedback(items) {
-        const parts = ["Here's the feedback:"];
-        for (const item of items) {
-            if (item.column > 1) {
-                parts.push(`Line ${item.line}: Column ${item.column}: ${item.text}`);
-            } else {
-                parts.push(`Line ${item.line}: ${item.text}`);
-            }
-        }
-        return parts.join("\n");
+    submitPlanAction(planUri, action) {
+        return this._getRegistration(planUri)?.review.submitAction(action) ?? Promise.resolve();
+    }
+    rejectPlan(planUri) {
+        return this._getRegistration(planUri)?.review.reject() ?? Promise.resolve();
+    }
+    acceptsComments(resource) {
+        return this.isActivePlanReview(resource);
+    }
+    getComments(resource) {
+        return this._getRegistration(resource)?.items.map(item => ({
+            id: item.id,
+            resource,
+            range: item.range,
+            body: item.text
+        })) ?? [];
+    }
+    getCommentIds(resource) {
+        return this._getRegistration(resource)?.items.map(item => item.id) ?? [];
+    }
+    addComment(resource, range, body) {
+        this._addFeedback(resource, range, body);
+    }
+    deleteComment(resource, id) {
+        this.removeFeedback(resource, id);
+    }
+    _getRegistration(planUri) {
+        return this._registrations.get(( planUri.toString()))?.at(-1);
     }
-}
+};
+PlanReviewFeedbackService = ( __decorate([( __param(0, IAgentEditorCommentsBridge))], PlanReviewFeedbackService));
 
 export { PlanReviewFeedbackService };

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

@@ -1,7 +1,7 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IMeteredConnectionService } from "@codingame/monaco-vscode-api/vscode/vs/platform/meteredConnection/common/meteredConnection.service";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
-import { IExtensionsWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service";
 import { IPluginInstallService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginInstallService.service";
 import { IPluginMarketplaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service";
 /**
@@ -9,29 +9,25 @@ import { IPluginMarketplaceService } from "@codingame/monaco-vscode-api/vscode/v
  * {@link IPluginMarketplaceService} with the plugin update *action* exposed
  * by {@link IPluginInstallService}.
  *
- * The marketplace service flips `hasUpdatesAvailable` to `true` roughly once
- * a day when at least one cloned plugin repository has upstream changes.
+ * The marketplace service reports canonical marketplace IDs roughly once
+ * a day when cloned plugin repositories have upstream changes.
  * Without this contribution, that signal was never consumed and plugins
  * were never auto-updated (see microsoft/vscode#308563).
  *
- * When the signal becomes `true` and `extensions.autoUpdate` is `on`, we
- * silently update all installed plugins. When auto-update is `off`, plugins
- * are not auto-updated. (`getAutoUpdateValue()` normalizes the setting to
- * `'on' | 'off'`, migrating any legacy stored values such as `false`.)
+ * Only plugins from the reported marketplaces are updated. The marketplace
+ * service applies managed per-marketplace policy before reporting updates.
  *
- * The flag is cleared after every attempt — including failures — so the
- * next periodic check's `false → true` transition can always re-trigger the
- * autorun. `updateAllPlugins` already clears it on success; clearing again
- * in `finally` is a no-op on the success path and handles the partial-
- * failure path where the install service leaves the flag at `true`.
+ * Processed marketplace IDs are acknowledged after every attempt, including
+ * failures. IDs reported while an update is running remain queued.
  */
 export declare class PluginAutoUpdate extends Disposable implements IWorkbenchContribution {
     private readonly _pluginMarketplaceService;
     private readonly _pluginInstallService;
-    private readonly _extensionsWorkbenchService;
     private readonly _logService;
+    private readonly _meteredConnectionService;
     static readonly ID = "workbench.contrib.pluginAutoUpdate";
     private _updateInFlight;
-    constructor(_pluginMarketplaceService: IPluginMarketplaceService, _pluginInstallService: IPluginInstallService, _extensionsWorkbenchService: IExtensionsWorkbenchService, _logService: ILogService);
+    constructor(_pluginMarketplaceService: IPluginMarketplaceService, _pluginInstallService: IPluginInstallService, _logService: ILogService, _meteredConnectionService: IMeteredConnectionService);
+    private _triggerQueuedAutoUpdate;
     private _triggerAutoUpdate;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/pluginAutoUpdate.js

@@ -4,7 +4,7 @@ import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Disposable } 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 { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { IMeteredConnectionService } from '@codingame/monaco-vscode-api/vscode/vs/platform/meteredConnection/common/meteredConnection.service';
 import { IPluginInstallService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginInstallService.service';
 import { IPluginMarketplaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
@@ -16,43 +16,58 @@ let PluginAutoUpdate = class PluginAutoUpdate extends Disposable {
     constructor(
         _pluginMarketplaceService,
         _pluginInstallService,
-        _extensionsWorkbenchService,
-        _logService
+        _logService,
+        _meteredConnectionService
     ) {
         super();
         this._pluginMarketplaceService = _pluginMarketplaceService;
         this._pluginInstallService = _pluginInstallService;
-        this._extensionsWorkbenchService = _extensionsWorkbenchService;
         this._logService = _logService;
+        this._meteredConnectionService = _meteredConnectionService;
         this._updateInFlight = false;
         this._register(autorun(reader => {
-            if (!this._pluginMarketplaceService.hasUpdatesAvailable.read(reader)) {
+            const marketplaceIds = this._pluginMarketplaceService.marketplacesWithUpdates.read(reader);
+            if (marketplaceIds.size === 0) {
                 return;
             }
-            void this._triggerAutoUpdate();
+            void this._triggerAutoUpdate(marketplaceIds);
         }));
+        this._register(
+            this._meteredConnectionService.onDidChangeIsConnectionMetered(isMetered => {
+                if (!isMetered) {
+                    this._triggerQueuedAutoUpdate();
+                }
+            })
+        );
     }
-    async _triggerAutoUpdate() {
-        if (this._updateInFlight) {
-            return;
+    _triggerQueuedAutoUpdate() {
+        const marketplaceIds = this._pluginMarketplaceService.marketplacesWithUpdates.get();
+        if (marketplaceIds.size > 0) {
+            void this._triggerAutoUpdate(marketplaceIds);
         }
-        const autoUpdate = this._extensionsWorkbenchService.getAutoUpdateValue();
-        if (autoUpdate === "off") {
+    }
+    async _triggerAutoUpdate(marketplaceIds) {
+        if (this._store.isDisposed || this._updateInFlight || this._meteredConnectionService.isConnectionMetered) {
             return;
         }
         this._updateInFlight = true;
         try {
             await this._pluginInstallService.updateAllPlugins({
-                silent: true
+                silent: true,
+                automatic: true,
+                marketplaceIds
             }, CancellationToken.None);
         } catch (err) {
             this._logService.error("[PluginAutoUpdate] Failed to auto-update plugins:", err);
         } finally {
+            this._pluginMarketplaceService.clearUpdatesAvailable(marketplaceIds);
             this._updateInFlight = false;
-            this._pluginMarketplaceService.clearUpdatesAvailable();
+            if (!this._store.isDisposed && !this._meteredConnectionService.isConnectionMetered) {
+                this._triggerQueuedAutoUpdate();
+            }
         }
     }
 };
-PluginAutoUpdate = ( __decorate([( __param(0, IPluginMarketplaceService)), ( __param(1, IPluginInstallService)), ( __param(2, IExtensionsWorkbenchService)), ( __param(3, ILogService))], PluginAutoUpdate));
+PluginAutoUpdate = ( __decorate([( __param(0, IPluginMarketplaceService)), ( __param(1, IPluginInstallService)), ( __param(2, ILogService)), ( __param(3, IMeteredConnectionService))], PluginAutoUpdate));
 
 export { PluginAutoUpdate };

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

@@ -37,10 +37,12 @@ export declare class BrowserPluginGitCommandService implements IPluginGitService
     cloneRepository(cloneUrl: string, targetDir: URI, ref?: string, token?: CancellationToken): Promise<void>;
     pull(repoDir: URI, token?: CancellationToken): Promise<boolean>;
     checkout(repoDir: URI, treeish: string, _detached?: boolean, token?: CancellationToken): Promise<void>;
+    checkoutCommit(repoDir: URI, commit: string, token?: CancellationToken): Promise<void>;
     revParse(repoDir: URI, ref: string): Promise<string>;
     fetch(_repoDir: URI, _token?: CancellationToken): Promise<void>;
     fetchRepository(_repoDir: URI, _token?: CancellationToken): Promise<void>;
     revListCount(_repoDir: URI, _fromRef: string, _toRef: string): Promise<number>;
+    private _materializeCommit;
     private _parseOrThrow;
     private _maybeLogTransientError;
     /**

package/vscode/src/vs/workbench/contrib/chat/browser/pluginGitCommandService.js

@@ -75,7 +75,7 @@ let BrowserPluginGitCommandService = class BrowserPluginGitCommandService {
         }
         if (lastErr instanceof GitHubAuthRequiredError) {
             throw ( new Error(( localize(
-                7433,
+                8676,
                 "GitHub authentication is required to install '{0}'. Sign in with an account that has access to this repository, then try again.",
                 `${repo.owner}/${repo.repo}`
             ))));
@@ -133,29 +133,51 @@ let BrowserPluginGitCommandService = class BrowserPluginGitCommandService {
         const requestedRef = treeish.trim();
         const isFullSha = /^[0-9a-f]{40}$/i.test(requestedRef);
         const requestedSha = isFullSha ? requestedRef.toLowerCase() : await resolveGitHubRefToSha(this._requestService, repo, requestedRef, authToken, cancel);
-        if (requestedSha === entry.sha.toLowerCase()) {
+        await this._materializeCommit(
+            repoDir,
+            entry,
+            requestedSha,
+            isFullSha ? entry.ref : requestedRef,
+            authToken,
+            cancel
+        );
+    }
+    async checkoutCommit(repoDir, commit, token) {
+        const expectedCommit = commit.trim().toLowerCase();
+        if (!/^[0-9a-f]{40}$/.test(expectedCommit)) {
+            throw ( new Error(( localize(8677, "Pinned plugin commit '{0}' is not a full SHA-1 hash.", commit))));
+        }
+        const entry = this._getCacheEntry(repoDir);
+        if (!entry) {
+            throw ( new Error(`Cannot checkout plugin: no cached metadata for ${( repoDir.toString())}`));
+        }
+        if (entry.sha.toLowerCase() === expectedCommit) {
             return;
         }
-        try {
-            await fetchAndExtractGitHubRepo(
-                this._requestService,
-                this._fileService,
-                this._logService,
-                repo,
-                requestedSha,
-                repoDir,
-                authToken,
-                cancel
-            );
-            this._setCacheEntry(repoDir, {
-                ...entry,
-                ref: isFullSha ? entry.ref : requestedRef,
-                sha: requestedSha,
-                fetchedAt: Date.now()
-            });
-        } catch (err) {
-            this._maybeLogTransientError(err, repo);
-            throw err;
+        const cancel = token ?? CancellationToken.None;
+        const authToken = await this._lookupGitHubToken();
+        const repo = {
+            owner: entry.owner,
+            repo: entry.repo
+        };
+        const resolvedCommit = (await resolveGitHubRefToSha(this._requestService, repo, expectedCommit, authToken, cancel)).toLowerCase();
+        if (resolvedCommit !== expectedCommit) {
+            throw ( new Error(( localize(
+                8678,
+                "Pinned plugin commit '{0}' resolved to a different commit '{1}'.",
+                commit,
+                resolvedCommit
+            ))));
+        }
+        await this._materializeCommit(repoDir, entry, resolvedCommit, entry.ref, authToken, cancel);
+        const checkedOutCommit = (await this.revParse(repoDir, "HEAD")).toLowerCase();
+        if (checkedOutCommit !== expectedCommit) {
+            throw ( new Error(( localize(
+                8679,
+                "Pinned plugin commit '{0}' was not checked out. The repository is at commit '{1}'.",
+                commit,
+                checkedOutCommit
+            ))));
         }
     }
     async revParse(repoDir, ref) {
@@ -177,11 +199,41 @@ let BrowserPluginGitCommandService = class BrowserPluginGitCommandService {
     async revListCount(_repoDir, _fromRef, _toRef) {
         return 0;
     }
+    async _materializeCommit(repoDir, entry, commit, ref, authToken, token) {
+        if (commit === entry.sha.toLowerCase()) {
+            return;
+        }
+        const repo = {
+            owner: entry.owner,
+            repo: entry.repo
+        };
+        try {
+            await fetchAndExtractGitHubRepo(
+                this._requestService,
+                this._fileService,
+                this._logService,
+                repo,
+                commit,
+                repoDir,
+                authToken,
+                token
+            );
+            this._setCacheEntry(repoDir, {
+                ...entry,
+                ref,
+                sha: commit,
+                fetchedAt: Date.now()
+            });
+        } catch (err) {
+            this._maybeLogTransientError(err, repo);
+            throw err;
+        }
+    }
     _parseOrThrow(cloneUrl) {
         const parsed = parseGitHubCloneUrl(cloneUrl);
         if (!parsed) {
             throw ( new Error(( localize(
-                7434,
+                8680,
                 "Agent plugins in the browser can only be installed from GitHub HTTPS URLs. To install '{0}', use the desktop application or connect to a remote agent host.",
                 cloneUrl
             ))));
@@ -232,7 +284,7 @@ let BrowserPluginGitCommandService = class BrowserPluginGitCommandService {
         } catch (err) {
             this._logService.trace("[BrowserPluginGitCommandService] GitHub session request failed:", err);
             throw ( new Error(( localize(
-                7435,
+                8681,
                 "Sign in to GitHub with an account that has access to '{0}' to install this plugin.",
                 `${repo.owner}/${repo.repo}`
             ))));

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

@@ -12,7 +12,7 @@ import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/s
 import { IAgentPluginRepositoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service";
 import { IInstallPluginFromSourceOptions, IInstallPluginFromSourceResult, IUpdateAllPluginsOptions, IUpdateAllPluginsResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginInstallService";
 import { IPluginInstallService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginInstallService.service";
-import { IMarketplacePlugin } from "../common/plugins/pluginMarketplaceService.js";
+import { IMarketplacePlugin } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService";
 import { IPluginMarketplaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service";
 export declare class PluginInstallService implements IPluginInstallService {
     private readonly _pluginRepositoryService;