@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/policyBlocked/browser/sessionsPolicyBlocked.js

@@ -2,8 +2,8 @@
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import * as sessionsPolicyBlocked from './media/sessionsPolicyBlocked.css';
-import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { append, $, addDisposableListener, getWindow, EventType, addDisposableGenericMouseDownListener, createTextNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable, toDisposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { getActiveElement, append, $, isHTMLElement, addDisposableListener, EventType, scheduleAtNextAnimationFrame, getWindow, addDisposableGenericMouseDownListener, createTextNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
 import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
@@ -11,9 +11,15 @@ import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 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 { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
 import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
 import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
 import { ManagedSettingsFreshnessFailure } from '@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/managedSettingsFreshness';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
 
 registerCss(sessionsPolicyBlocked, 1);
 var SessionsBlockedReason;
@@ -22,6 +28,7 @@ var SessionsBlockedReason;
     SessionsBlockedReason["Loading"] = "loading";
     SessionsBlockedReason["AccountPolicyGate"] = "accountPolicyGate";
     SessionsBlockedReason["ManagedSettingsRefresh"] = "managedSettingsRefresh";
+    SessionsBlockedReason["UpdateRequired"] = "updateRequired";
 })(SessionsBlockedReason || (SessionsBlockedReason = {}));
 let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Disposable {
     constructor(
@@ -31,26 +38,101 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
         openerService,
         productService,
         defaultAccountService,
-        layoutService
+        layoutService,
+        sessionsPartService,
+        sessionsService
     ) {
         super();
+        this.options = options;
         this.commandService = commandService;
         this.openerService = openerService;
         this.productService = productService;
         this.defaultAccountService = defaultAccountService;
+        this.sessionsPartService = sessionsPartService;
+        this.sessionsService = sessionsService;
+        this.previouslyFocused = getActiveElement();
         this.overlay = append(container, $(".sessions-policy-blocked-overlay"));
-        this.overlay.setAttribute("role", "dialog");
-        this.overlay.setAttribute("aria-modal", "true");
+        this.overlay.setAttribute(
+            "role",
+            options.reason === SessionsBlockedReason.UpdateRequired ? "region" : "dialog"
+        );
+        if (options.reason !== SessionsBlockedReason.UpdateRequired) {
+            this.overlay.setAttribute("aria-modal", "true");
+        }
         this.overlay.tabIndex = -1;
-        this.overlay.focus();
+        if (options.shouldFocus !== false) {
+            this.overlay.focus();
+        }
         this._register(toDisposable(() => this.overlay.remove()));
         const workbenchRoot = layoutService.mainContainer;
         workbenchRoot.classList.add("sessions-policy-blocked");
         this._register(
             toDisposable(() => workbenchRoot.classList.remove("sessions-policy-blocked"))
         );
-        const card = append(this.overlay, $(".sessions-policy-blocked-card"));
+        const scrollContent = options.reason === SessionsBlockedReason.UpdateRequired ? $(".sessions-policy-blocked-scroll-content") : this.overlay;
+        const scrollable = options.reason === SessionsBlockedReason.UpdateRequired ? this._register(( new DomScrollableElement(scrollContent, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: false
+        }))) : undefined;
+        const revealFocusedAction = () => {
+            const focusedElement = getActiveElement();
+            if (isHTMLElement(focusedElement) && scrollContent.contains(focusedElement)) {
+                focusedElement.scrollIntoView({
+                    block: "nearest",
+                    inline: "nearest"
+                });
+                scrollable?.scanDomNode();
+            }
+        };
+        if (scrollable) {
+            const scrollContainer = append(this.overlay, scrollable.getDomNode());
+            scrollContainer.classList.add("sessions-policy-blocked-scrollable");
+            this._register(
+                addDisposableListener(scrollContent, EventType.SCROLL, () => scrollable.setScrollPosition({
+                    scrollTop: scrollContent.scrollTop
+                }))
+            );
+            const focusScroll = this._register(( new MutableDisposable()));
+            this._register(addDisposableListener(scrollContent, EventType.FOCUS_IN, () => {
+                focusScroll.value = scheduleAtNextAnimationFrame(getWindow(scrollContent), revealFocusedAction);
+            }));
+        }
+        const card = append(scrollContent, $(".sessions-policy-blocked-card"));
+        if (options.reason === SessionsBlockedReason.UpdateRequired) {
+            this.overlay.classList.add("update-required");
+            const inertParts = ( new Map());
+            this._register(toDisposable(() => {
+                for (const [part, inert] of inertParts) {
+                    part.inert = inert;
+                }
+            }));
+            const layout = () => {
+                this.overlay.style.top = `${layoutService.mainContainerOffset.top}px`;
+                for (const id of [
+                    Parts.SESSIONS_PART,
+                    Parts.SIDEBAR_PART,
+                    Parts.EDITOR_PART,
+                    Parts.PANEL_PART,
+                    Parts.AUXILIARYBAR_PART,
+                    Parts.CUSTOM_VIEW_GRID_PART
+                ]) {
+                    const part = layoutService.getContainer(mainWindow, id);
+                    if (part && !( inertParts.has(part))) {
+                        inertParts.set(part, part.inert);
+                        part.inert = true;
+                    }
+                }
+                scrollable?.scanDomNode();
+                revealFocusedAction();
+            };
+            layout();
+            this._register(layoutService.onDidLayoutMainContainer(layout));
+        }
         this._register(addDisposableListener(getWindow(this.overlay), EventType.KEY_DOWN, e => {
+            if (options.reason === SessionsBlockedReason.UpdateRequired) {
+                return;
+            }
             if (card.contains(e.target)) {
                 return;
             }
@@ -77,16 +159,71 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
         case SessionsBlockedReason.ManagedSettingsRefresh:
             this._renderManagedSettingsRefresh(card, options.freshness);
             break;
+        case SessionsBlockedReason.UpdateRequired:
+            {
+                const button = this._renderUpdateRequired(card, options.updateInfo);
+                scrollable?.scanDomNode();
+                if (options.shouldFocus !== false) {
+                    button.focus();
+                }
+                break;
+            }
+        }
+    }
+    hasFocus() {
+        return this.overlay.contains(getActiveElement());
+    }
+    dispose() {
+        const restoreFocus = this.options.reason === SessionsBlockedReason.UpdateRequired && this.hasFocus();
+        super.dispose();
+        if (!restoreFocus) {
+            return;
         }
+        if (isHTMLElement(this.previouslyFocused) && this.previouslyFocused.isConnected && this.previouslyFocused !== this.previouslyFocused.ownerDocument.body && this.previouslyFocused !== this.previouslyFocused.ownerDocument.documentElement) {
+            this.previouslyFocused.focus({
+                preventScroll: true
+            });
+            if (getActiveElement() === this.previouslyFocused) {
+                return;
+            }
+        }
+        this.sessionsPartService.focusSession(this.sessionsService.activeSession.get());
+    }
+    _renderUpdateRequired(card, info) {
+        this.overlay.setAttribute("aria-label", info.title);
+        append(card, $("h2", undefined, info.title));
+        append(card, $("p", undefined, info.message));
+        if (info.detail) {
+            append(card, $("p", undefined, info.detail));
+        }
+        if (info.updateStatus) {
+            append(card, $("p", undefined, info.updateStatus));
+        }
+        let updateButton;
+        if (info.action) {
+            const action = info.action;
+            updateButton = this._register(( new Button(card, defaultButtonStyles)));
+            updateButton.label = action.label;
+            this._register(updateButton.onDidClick(() => this.openerService.open(action.href, {
+                allowCommands: true
+            })));
+        }
+        const button = this._register(( new Button(card, {
+            ...defaultButtonStyles,
+            secondary: true
+        })));
+        button.label = ( localize(4804, "Open Editor Window"));
+        this._register(button.onDidClick(() => this._openVSCode()));
+        return updateButton ?? button;
     }
     _renderAgentDisabled(card) {
-        this.overlay.setAttribute("aria-label", ( localize(4166, "Agents disabled by organization policy")));
-        append(card, $("h2", undefined, ( localize(4167, "Agents Disabled"))));
+        this.overlay.setAttribute("aria-label", ( localize(4805, "Agents disabled by organization policy")));
+        append(card, $("h2", undefined, ( localize(4806, "Agents Disabled"))));
         const description = append(card, $("p"));
-        append(description, createTextNode(( localize(4168, "Your organization has disabled Agents via policy."))));
+        append(description, createTextNode(( localize(4807, "Your organization has disabled Agents via policy."))));
         append(description, createTextNode(" "));
         const learnMore = append(description, $("a.sessions-policy-blocked-link"));
-        learnMore.textContent = ( localize(4169, "Learn more"));
+        learnMore.textContent = ( localize(4808, "Learn more"));
         learnMore.href = "https://aka.ms/VSCode/Agents/docs";
         this._register(addDisposableListener(learnMore, EventType.CLICK, e => {
             e.preventDefault();
@@ -96,11 +233,11 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
             ...defaultButtonStyles,
             secondary: true
         })));
-        button.label = ( localize(4170, "Open VS Code"));
+        button.label = ( localize(4809, "Open VS Code"));
         this._register(button.onDidClick(() => this._openVSCode()));
     }
     _renderLoading(card) {
-        this.overlay.setAttribute("aria-label", ( localize(4171, "Loading")));
+        this.overlay.setAttribute("aria-label", ( localize(4810, "Loading")));
         append(card, $(
             "div.sessions-policy-blocked-progress-bar",
             undefined,
@@ -108,18 +245,18 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
         ));
     }
     _renderAccountPolicyGate(card, options) {
-        this.overlay.setAttribute("aria-label", ( localize(4172, "Sign-in required by your administrator")));
-        append(card, $("h2", undefined, ( localize(4173, "Sign-In Required"))));
+        this.overlay.setAttribute("aria-label", ( localize(4811, "Sign-in required by your administrator")));
+        append(card, $("h2", undefined, ( localize(4812, "Sign-In Required"))));
         const description = append(card, $("p"));
         if (options.accountName) {
             append(description, createTextNode(( localize(
-                4174,
+                4813,
                 "The account \"{0}\" is not a member of an organization that your administrator allows for Agents.",
                 options.accountName
             ))));
         } else {
             append(description, createTextNode(( localize(
-                4175,
+                4814,
                 "Your administrator restricts Agents to members of the organizations below."
             ))));
         }
@@ -129,7 +266,7 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
             const orgSection = append(card, $("div.sessions-policy-blocked-orgs"));
             append(
                 orgSection,
-                $("p.sessions-policy-blocked-orgs-label", undefined, ( localize(4176, "Allowed organizations:")))
+                $("p.sessions-policy-blocked-orgs-label", undefined, ( localize(4815, "Allowed organizations:")))
             );
             const orgList = append(orgSection, $("ul"));
             for (const org of approvedOrgs) {
@@ -137,10 +274,10 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
             }
         }
         const footer = append(card, $("p.sessions-policy-blocked-footer"));
-        append(footer, createTextNode(( localize(4177, "Contact your administrator for more information."))));
+        append(footer, createTextNode(( localize(4816, "Contact your administrator for more information."))));
         append(footer, createTextNode(" "));
         const learnMore = append(footer, $("a.sessions-policy-blocked-link"));
-        learnMore.textContent = ( localize(4178, "Learn more"));
+        learnMore.textContent = ( localize(4817, "Learn more"));
         learnMore.href = "https://code.visualstudio.com/docs/enterprise/overview";
         this._register(addDisposableListener(learnMore, EventType.CLICK, e => {
             e.preventDefault();
@@ -149,31 +286,31 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
         const signInButton = this._register(( new Button(card, {
             ...defaultButtonStyles
         })));
-        signInButton.label = ( localize(4179, "Sign In"));
+        signInButton.label = ( localize(4818, "Sign In"));
         this._register(signInButton.onDidClick(() => {
             this.commandService.executeCommand("workbench.action.agenticSignIn");
         }));
     }
     _renderManagedSettingsRefresh(card, freshness) {
-        this.overlay.setAttribute("aria-label", ( localize(4180, "Managed settings refresh required")));
-        append(card, $("h2", undefined, ( localize(4181, "Managed Settings Unavailable"))));
+        this.overlay.setAttribute("aria-label", ( localize(4819, "Managed settings refresh required")));
+        append(card, $("h2", undefined, ( localize(4820, "Managed Settings Unavailable"))));
         const message = freshness?.failure === ManagedSettingsFreshnessFailure.NoToken ? ( localize(
-            4182,
+            4821,
             "Sign in so {0} can refresh your organization's managed settings before starting an agent.",
             this.productService.nameShort
         )) : freshness?.failure === ManagedSettingsFreshnessFailure.RateLimited ? ( localize(
-            4183,
+            4822,
             "Your organization's managed settings service is rate limiting requests. Try again later."
         )) : freshness?.failure === ManagedSettingsFreshnessFailure.NoUrl ? ( localize(
-            4184,
+            4823,
             "{0} cannot locate your organization's managed settings service. Contact your administrator.",
             this.productService.nameShort
         )) : freshness?.failure === ManagedSettingsFreshnessFailure.UpdateRequired ? ( localize(
-            4185,
+            4824,
             "Update {0} to a version that supports your organization's managed settings before starting an agent.",
             this.productService.nameShort
         )) : ( localize(
-            4186,
+            4825,
             "Your organization requires {0} to refresh managed settings whenever it starts or reloads. An error prevented the required policy from being retrieved, so agents are unavailable. Retry, or contact your organization's administrator if the issue persists.",
             this.productService.nameShort
         ));
@@ -182,7 +319,7 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
             const signInButton = this._register(( new Button(card, {
                 ...defaultButtonStyles
             })));
-            signInButton.label = ( localize(4187, "Sign In"));
+            signInButton.label = ( localize(4826, "Sign In"));
             this._register(
                 signInButton.onDidClick(() => this.commandService.executeCommand("workbench.action.agenticSignIn"))
             );
@@ -190,7 +327,7 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
             const retryButton = this._register(( new Button(card, {
                 ...defaultButtonStyles
             })));
-            retryButton.label = ( localize(4188, "Retry"));
+            retryButton.label = ( localize(4827, "Retry"));
             this._register(retryButton.onDidClick(() => this.defaultAccountService.refresh({
                 forceRefresh: true,
                 retryManagedSettings: true
@@ -200,7 +337,7 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
             ...defaultButtonStyles,
             secondary: true
         })));
-        openVSCodeButton.label = ( localize(4189, "Open VS Code"));
+        openVSCodeButton.label = ( localize(4828, "Open VS Code"));
         this._register(openVSCodeButton.onDidClick(() => this._openVSCode()));
     }
     _openVSCode() {
@@ -213,6 +350,6 @@ let SessionsPolicyBlockedOverlay = class SessionsPolicyBlockedOverlay extends Di
         });
     }
 };
-SessionsPolicyBlockedOverlay = ( __decorate([( __param(2, ICommandService)), ( __param(3, IOpenerService)), ( __param(4, IProductService)), ( __param(5, IDefaultAccountService)), ( __param(6, IWorkbenchLayoutService))], SessionsPolicyBlockedOverlay));
+SessionsPolicyBlockedOverlay = ( __decorate([( __param(2, ICommandService)), ( __param(3, IOpenerService)), ( __param(4, IProductService)), ( __param(5, IDefaultAccountService)), ( __param(6, IWorkbenchLayoutService)), ( __param(7, ISessionsPartService)), ( __param(8, ISessionsService))], SessionsPolicyBlockedOverlay));
 
 export { SessionsBlockedReason, SessionsPolicyBlockedOverlay };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostForkActions.js

@@ -9,13 +9,13 @@ import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/session
 import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
 
 registerAction2(class extends ForkConversationAction {
-    async _tryForkAsChat(instantiationService, sourceSessionResource, request) {
+    async _tryForkAsChat(instantiationService, sourceSessionResource, request, options) {
         return instantiationService.invokeFunction(async accessor => {
             const sessionsManagementService = accessor.get(ISessionsManagementService);
             const sessionsService = accessor.get(ISessionsService);
             const chatService = accessor.get(IChatService);
             const logService = accessor.get(ILogService);
-            const session = sessionsManagementService.getSession(sourceSessionResource) ?? sessionsManagementService.getSessions().find(s => ( s.chats.get().some(c => ( c.resource.toString()) === ( sourceSessionResource.toString()))));
+            const session = sessionsManagementService.getSession(sourceSessionResource) ?? sessionsManagementService.getSessionForChatResource(sourceSessionResource)?.session;
             if (!session?.capabilities.get().supportsMultipleChats || !isAgentHostProviderId(session.providerId)) {
                 return false;
             }
@@ -34,17 +34,28 @@ registerAction2(class extends ForkConversationAction {
                 return false;
             }
             const newChat = await sessionsManagementService.forkChatInSession(session, sourceSessionResource, turnId);
-            await sessionsService.openChat(session, newChat.resource);
+            if (options?.toSide) {
+                await sessionsService.openChatToSide(session, newChat.resource, {
+                    referenceChatResource: sourceSessionResource
+                });
+            } else {
+                await sessionsService.openChat(session, newChat.resource);
+            }
             logService.trace(`[AgentHostSessions] Forked conversation into new chat ${( newChat.resource.toString())} in session ${session.sessionId}`);
             return true;
         });
     }
-    _openForkedSession(instantiationService, parentSessionResource, forkedSessionResource) {
+    _openForkedSession(
+        instantiationService,
+        parentSessionResource,
+        forkedSessionResource,
+        options
+    ) {
         return instantiationService.invokeFunction(async accessor => {
             const sessionsManagementService = accessor.get(ISessionsManagementService);
             const sessionsService = accessor.get(ISessionsService);
             const logService = accessor.get(ILogService);
-            const parentSession = sessionsManagementService.getSession(parentSessionResource);
+            const parentSession = sessionsManagementService.getSession(parentSessionResource) ?? sessionsManagementService.getSessionForChatResource(parentSessionResource)?.session;
             if (!parentSession) {
                 logService.error(`Parent session ${( parentSessionResource.toString())} not found when forking conversation`);
                 return super._openForkedSession(instantiationService, parentSessionResource, forkedSessionResource);
@@ -64,9 +75,20 @@ registerAction2(class extends ForkConversationAction {
                     return;
                 }
             }
-            await sessionsService.openSession(forkedSessionResource, {
-                source: "fork"
-            });
+            if (options?.toSide) {
+                const forkedSession = sessionsManagementService.getSession(forkedSessionResource);
+                if (!forkedSession) {
+                    throw ( new Error(`Forked session ${( forkedSessionResource.toString())} is no longer available`));
+                }
+                await sessionsService.openSessionToSide(forkedSession, {
+                    source: "fork",
+                    referenceSessionId: parentSession.sessionId
+                });
+            } else {
+                await sessionsService.openSession(forkedSessionResource, {
+                    source: "fork"
+                });
+            }
         });
     }
 });

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSessionBranchActions.js

@@ -6,15 +6,11 @@ import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { IAgentHostConnectionsService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service';
 import { buildExternalOpenSessionLinkUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/openSessionLink';
-import { ANY_AGENT_HOST_PROVIDER_RE } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ANY_AGENT_HOST_PROVIDER_RE, isAgentHostProviderId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
 import { SessionProviderIdContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
 import { COPY_AGENT_HOST_SESSION_LINK_COMMAND_ID, COPY_AGENT_HOST_CHAT_LINK_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
 import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
-import { SessionItemContextMenuId, SessionItemHasBranchNameContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
 
-function getSession(context) {
-    return Array.isArray(context) ? context[0] : context;
-}
 function buildExternalLink(accessor, session, chatId) {
     const identity = accessor.get(IAgentHostConnectionsService).resolveSessionResourceIdentity(session.resource);
     if (!identity) {
@@ -26,9 +22,9 @@ registerAction2(class CopyAgentHostSessionLinkAction extends Action2 {
     constructor() {
         super({
             id: COPY_AGENT_HOST_SESSION_LINK_COMMAND_ID,
-            title: ( localize2(4210, "Copy Link")),
+            title: ( localize2(4861, "Copy Link")),
             menu: [{
-                id: SessionItemContextMenuId,
+                id: Menus.SessionItemContextMenu,
                 group: "2_open",
                 order: 2,
                 when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
@@ -41,21 +37,21 @@ registerAction2(class CopyAgentHostSessionLinkAction extends Action2 {
         });
     }
     async run(accessor, context) {
-        const session = getSession(context);
-        if (!session) {
+        const sessions = (Array.isArray(context) ? context : context ? [context] : []).filter(session => isAgentHostProviderId(session.providerId));
+        if (sessions.length === 0) {
             return;
         }
-        await accessor.get(IClipboardService).writeText(buildExternalLink(accessor, session));
+        await accessor.get(IClipboardService).writeText(sessions.map(session => buildExternalLink(accessor, session)).join("\n"));
     }
 });
 registerAction2(class CopyAgentHostChatLinkAction extends Action2 {
     constructor() {
         super({
             id: COPY_AGENT_HOST_CHAT_LINK_COMMAND_ID,
-            title: ( localize2(4211, "Copy Link")),
+            title: ( localize2(4862, "Copy Link")),
             menu: [{
                 id: Menus.SessionChatItemContext,
-                group: "2_copy",
+                group: "3_copy",
                 order: 1,
                 when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
             }]
@@ -70,25 +66,3 @@ registerAction2(class CopyAgentHostChatLinkAction extends Action2 {
         );
     }
 });
-registerAction2(class CopySessionBranchNameAction extends Action2 {
-    constructor() {
-        super({
-            id: "sessionsViewPane.agentHost.copySessionBranchName",
-            title: ( localize2(4212, "Copy Branch Name")),
-            menu: [{
-                id: SessionItemContextMenuId,
-                group: "2_open",
-                order: 3,
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE)), SessionItemHasBranchNameContext))
-            }]
-        });
-    }
-    async run(accessor, context) {
-        const session = getSession(context);
-        const branchName = session?.workspace.get()?.folders[0]?.gitRepository?.branchName?.trim();
-        if (!branchName) {
-            return;
-        }
-        await accessor.get(IClipboardService).writeText(branchName);
-    }
-});