@codingame/monaco-vscode-workbench-service-override 37.3.2 → 37.3.4

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentMergeActions.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,468 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Action2, MenuRegistry, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { AgentMergeSettingId, resolveAgentMergeConfiguration, agentMergeMergePullRequestValues, AGENT_MERGE_SETTING_TAG } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentMerge';
+import { AgentHostPullRequestOperationId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostChangesetOperationService';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr, RawContextKey } 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 { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { ANY_AGENT_HOST_PROVIDER_RE, isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { SessionProviderIdContext, SessionIsArchivedContext, SessionHasOpenPullRequestContext, SessionPrimaryPullRequestOperationContext, SessionAgentMergeEnabledContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { CHANGES_OPERATIONS_DROPDOWN_PRIMARY_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/changesView';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { getSessionAgentMergeConfigurationObservable, getGlobalAgentMergeConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionAgentMerge';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const agentMergeCommandPrecondition = ( ContextKeyExpr.and(IsSessionsWindowContext, ChatContextKeys.enabled, ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE)), ( SessionIsArchivedContext.negate()), ( ContextKeyExpr.equals(`config.${AgentMergeSettingId.Enabled}`, true))));
+const agentMergeHasPullRequest = ( ContextKeyExpr.or(SessionHasOpenPullRequestContext, ...( Object.values(AgentHostPullRequestOperationId)).map(id => ( ContextKeyExpr.equals(SessionPrimaryPullRequestOperationContext.key, id)))));
+const agentMergeMenuPrecondition = ( ContextKeyExpr.and(agentMergeCommandPrecondition, agentMergeHasPullRequest));
+const agentMergeOwnsPrimaryButton = ( ContextKeyExpr.or(( ContextKeyExpr.equals(
+    SessionPrimaryPullRequestOperationContext.key,
+    AgentHostPullRequestOperationId.EnableAutoMerge
+)), ( ContextKeyExpr.equals(
+    SessionPrimaryPullRequestOperationContext.key,
+    AgentHostPullRequestOperationId.DisableAutoMerge
+)), ( ContextKeyExpr.and(( ContextKeyExpr.equals(
+    SessionPrimaryPullRequestOperationContext.key,
+    AgentHostPullRequestOperationId.MarkReadyWithAgentMerge
+)), SessionAgentMergeEnabledContext)), ( ContextKeyExpr.and(SessionHasOpenPullRequestContext, ( ContextKeyExpr.equals(SessionPrimaryPullRequestOperationContext.key, ""))))));
+const AgentMergeSessionActionContexts = {
+    addressReviews: new RawContextKey("sessionAgentMergeAddressReviews", false, {
+        type: "boolean",
+        description: ( localize(
+            4259,
+            "True when Agent Merge may address reviews for the active agent session."
+        ))
+    }),
+    fixCI: new RawContextKey("sessionAgentMergeFixCI", false, {
+        type: "boolean",
+        description: ( localize(
+            4260,
+            "True when Agent Merge may fix CI failures for the active agent session."
+        ))
+    }),
+    resolveConflicts: new RawContextKey("sessionAgentMergeResolveConflicts", false, {
+        type: "boolean",
+        description: ( localize(
+            4261,
+            "True when Agent Merge may resolve conflicts for the active agent session."
+        ))
+    })
+};
+const AgentMergeSessionMergePullRequestContext = new RawContextKey("sessionAgentMergeMergePullRequest", "never", {
+    type: "string",
+    description: ( localize(
+        4262,
+        "When Agent Merge may merge the pull request for the active agent session ('always', 'ifUnchanged' or 'never')."
+    ))
+});
+const agentMergeActionLabels = {
+    addressReviews: ( localize(4263, "Address Reviews")),
+    fixCI: ( localize(4264, "Fix CI Failures")),
+    resolveConflicts: ( localize(4265, "Resolve Conflicts and Behind Branches"))
+};
+const agentMergeRepairActions = ( Object.keys(agentMergeActionLabels));
+const agentMergeMergePullRequestLabels = {
+    always: ( localize(4266, "On")),
+    ifUnchanged: ( localize(4267, "Only if Agent Merge Made No Changes")),
+    never: ( localize(4268, "Off"))
+};
+const agentMergeMergePullRequestDescriptions = {
+    always: ( localize(4269, "Merge the pull request whenever it is ready.")),
+    ifUnchanged: ( localize(
+        4270,
+        "Merge the pull request only while Agent Merge has not changed it. Once a repair turn lands a commit this switches itself off."
+    )),
+    never: ( localize(4271, "Do not merge the pull request automatically."))
+};
+let AgentMergeContextContribution = class AgentMergeContextContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.agentMergeContext";
+    }
+    constructor(
+        contextKeyService,
+        configurationService,
+        sessionsService,
+        sessionsProvidersService,
+        logService
+    ) {
+        super();
+        const enabledKey = SessionAgentMergeEnabledContext.bindTo(contextKeyService);
+        const actionKeys = ( new Map(agentMergeRepairActions.map(
+            action => [action, AgentMergeSessionActionContexts[action].bindTo(contextKeyService)]
+        )));
+        const mergePullRequestKey = AgentMergeSessionMergePullRequestContext.bindTo(contextKeyService);
+        let lastLogged;
+        this._register(autorun(reader => {
+            const session = sessionsService.activeSession.read(reader);
+            const state = session ? getSessionAgentMergeConfigurationObservable(session, sessionsProvidersService, configurationService).read(reader) : undefined;
+            const enabled = state?.enabled === true;
+            const effective = state?.actions ?? getGlobalAgentMergeConfiguration(configurationService);
+            enabledKey.set(enabled);
+            for (const [action, key] of actionKeys) {
+                key.set(effective[action]);
+            }
+            mergePullRequestKey.set(effective.mergePullRequest);
+            const authorized = agentMergeRepairActions.filter(action => effective[action]);
+            const signature = `${session?.sessionId ?? "none"}|${enabled}|${authorized.join(",")}|${effective.mergePullRequest}`;
+            if (lastLogged !== signature) {
+                lastLogged = signature;
+                logService.info(
+                    `[AgentMergeActions] Session state: session=${session?.sessionId ?? "none"}, enabled=${enabled}, authorizedActions=[${authorized.join(", ") || "none"}], mergePullRequest=${effective.mergePullRequest}`
+                );
+            }
+        }));
+    }
+};
+AgentMergeContextContribution = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, IConfigurationService)), ( __param(2, ISessionsService)), ( __param(3, ISessionsProvidersService)), ( __param(4, ILogService))], AgentMergeContextContribution));
+registerWorkbenchContribution2(
+    AgentMergeContextContribution.ID,
+    AgentMergeContextContribution,
+    WorkbenchPhase.AfterRestored
+);
+class AgentMergeActionBase extends Action2 {
+    getActiveSession(accessor) {
+        const session = accessor.get(ISessionsService).activeSession.get();
+        const provider = session && accessor.get(ISessionsProvidersService).getProvider(session.providerId);
+        return session && provider && isAgentHostProvider(provider) ? {
+            session,
+            provider
+        } : undefined;
+    }
+    async updateOverrides(accessor, patch) {
+        const active = this.getActiveSession(accessor);
+        if (!active) {
+            return;
+        }
+        const configurationService = accessor.get(IConfigurationService);
+        const logService = accessor.get(ILogService);
+        const state = active.provider.getAgentMergeSessionState(active.session.sessionId);
+        const effective = resolveAgentMergeConfiguration(getGlobalAgentMergeConfiguration(configurationService), state?.overrides);
+        const overrides = {
+            addressReviews: effective.addressReviews,
+            fixCI: effective.fixCI,
+            resolveConflicts: effective.resolveConflicts,
+            mergePullRequest: effective.mergePullRequest,
+            ...patch
+        };
+        await active.provider.setAgentMergeOverrides(active.session.sessionId, overrides);
+        logService.info(
+            `[AgentMergeActions] Overrides updated: session=${active.session.sessionId}, change=${JSON.stringify(patch)}`
+        );
+    }
+}
+MenuRegistry.appendMenuItem(Menus.ChangesOperationsDropdown, {
+    submenu: Menus.ChangesAgentMerge,
+    title: ( localize2(4272, "Agent Merge")),
+    icon: Codicon.gitMerge,
+    group: CHANGES_OPERATIONS_DROPDOWN_PRIMARY_GROUP,
+    order: 1,
+    when: ( ContextKeyExpr.and(agentMergeMenuPrecondition, agentMergeOwnsPrimaryButton))
+});
+const agentMergeTopLevelMenus = [Menus.ChangesOperationsDropdown, Menus.ChangesAgentMerge];
+registerAction2(class EnableAgentMergeInSessionAction extends AgentMergeActionBase {
+    constructor() {
+        super({
+            id: "sessions.agentHost.agentMerge.enableInSession",
+            title: ( localize2(4273, "Enable Agent Merge")),
+            f1: false,
+            menu: agentMergeTopLevelMenus.map(id => ({
+                id,
+                group: "1_agentMerge",
+                order: 1,
+                when: ( ContextKeyExpr.and(agentMergeMenuPrecondition, ( SessionAgentMergeEnabledContext.negate())))
+            }))
+        });
+    }
+    async run(accessor) {
+        const active = this.getActiveSession(accessor);
+        const logService = accessor.get(ILogService);
+        if (!active) {
+            return;
+        }
+        await active.provider.setAgentMergeEnabled(active.session.sessionId, true);
+        logService.info(
+            `[AgentMergeActions] Enabled from the title bar: session=${active.session.sessionId}`
+        );
+    }
+});
+registerAction2(class DisableAgentMergeInSessionAction extends AgentMergeActionBase {
+    constructor() {
+        super({
+            id: "sessions.agentHost.agentMerge.disableInSession",
+            title: ( localize2(4274, "Disable Agent Merge")),
+            f1: false,
+            menu: agentMergeTopLevelMenus.map(id => ({
+                id,
+                group: "1_agentMerge",
+                order: 1,
+                when: ( ContextKeyExpr.and(agentMergeMenuPrecondition, SessionAgentMergeEnabledContext))
+            }))
+        });
+    }
+    async run(accessor) {
+        const active = this.getActiveSession(accessor);
+        const logService = accessor.get(ILogService);
+        if (!active) {
+            return;
+        }
+        await active.provider.setAgentMergeEnabled(active.session.sessionId, false);
+        logService.info(
+            `[AgentMergeActions] Disabled from the title bar: session=${active.session.sessionId}`
+        );
+    }
+});
+for (const id of agentMergeTopLevelMenus) {
+    MenuRegistry.appendMenuItem(id, {
+        submenu: Menus.ChangesAgentMergeConfigure,
+        title: ( localize2(4275, "Configure Agent Merge")),
+        group: "1_agentMerge",
+        order: 2,
+        when: agentMergeMenuPrecondition
+    });
+}
+for (const [index, action] of agentMergeRepairActions.entries()) {
+    registerAction2(class ToggleAgentMergeRepairAction extends AgentMergeActionBase {
+        constructor() {
+            super({
+                id: `sessions.agentHost.agentMerge.toggle.${action}`,
+                title: {
+                    value: agentMergeActionLabels[action],
+                    original: agentMergeActionLabels[action]
+                },
+                toggled: AgentMergeSessionActionContexts[action],
+                f1: false,
+                menu: [{
+                    id: Menus.ChangesAgentMergeConfigure,
+                    group: "1_agentMergeActions",
+                    order: index,
+                    when: agentMergeMenuPrecondition
+                }]
+            });
+        }
+        async run(accessor) {
+            const active = this.getActiveSession(accessor);
+            if (!active) {
+                return;
+            }
+            const state = active.provider.getAgentMergeSessionState(active.session.sessionId);
+            const effective = resolveAgentMergeConfiguration(
+                getGlobalAgentMergeConfiguration(accessor.get(IConfigurationService)),
+                state?.overrides
+            );
+            await this.updateOverrides(accessor, {
+                [action]: !effective[action]
+            });
+        }
+    });
+}
+for (const value of agentMergeMergePullRequestValues) {
+    MenuRegistry.appendMenuItem(Menus.ChangesAgentMergeConfigure, mergePullRequestSubmenuItem(value));
+}
+function mergePullRequestSubmenuItem(value) {
+    const title = ( localize(4276, "Merge Pull Request ({0})", agentMergeMergePullRequestLabels[value]));
+    return {
+        submenu: Menus.ChangesAgentMergeMergePullRequest,
+        title: {
+            value: title,
+            original: title
+        },
+        group: "1_agentMergeActions",
+        order: agentMergeRepairActions.length,
+        when: ( ContextKeyExpr.and(agentMergeMenuPrecondition, ( AgentMergeSessionMergePullRequestContext.isEqualTo(value))))
+    };
+}
+for (const [index, value] of agentMergeMergePullRequestValues.entries()) {
+    registerAction2(class SetAgentMergeMergePullRequestAction extends AgentMergeActionBase {
+        constructor() {
+            super({
+                id: `sessions.agentHost.agentMerge.mergePullRequest.${value}`,
+                title: {
+                    value: agentMergeMergePullRequestLabels[value],
+                    original: agentMergeMergePullRequestLabels[value]
+                },
+                tooltip: agentMergeMergePullRequestDescriptions[value],
+                toggled: ( AgentMergeSessionMergePullRequestContext.isEqualTo(value)),
+                f1: false,
+                menu: [{
+                    id: Menus.ChangesAgentMergeMergePullRequest,
+                    group: "navigation",
+                    order: index
+                }]
+            });
+        }
+        async run(accessor) {
+            await this.updateOverrides(accessor, {
+                mergePullRequest: value
+            });
+        }
+    });
+}
+registerAction2(class OpenAgentMergeDefaultsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.agentHost.agentMerge.openDefaults",
+            title: ( localize2(4277, "Agent Merge Defaults")),
+            f1: false,
+            menu: [{
+                id: Menus.ChangesAgentMergeConfigure,
+                group: "2_agentMergeDefaults",
+                order: 1,
+                when: agentMergeMenuPrecondition
+            }]
+        });
+    }
+    async run(accessor) {
+        const preferencesService = accessor.get(IPreferencesService);
+        const logService = accessor.get(ILogService);
+        await preferencesService.openSettings({
+            jsonEditor: false,
+            query: `@tag:${AGENT_MERGE_SETTING_TAG}`
+        });
+        logService.trace(`[AgentMergeActions] Opened Agent Merge defaults in the settings editor`);
+    }
+});
+registerAction2(class EnableAgentMergeAction extends AgentMergeActionBase {
+    constructor() {
+        super({
+            id: "sessions.agentHost.agentMerge.enable",
+            title: ( localize2(4278, "Enable Agent Merge for Active Session")),
+            f1: true,
+            precondition: ( ContextKeyExpr.and(agentMergeCommandPrecondition, ( SessionAgentMergeEnabledContext.negate())))
+        });
+    }
+    async run(accessor) {
+        const active = this.getActiveSession(accessor);
+        if (!active) {
+            return;
+        }
+        const logService = accessor.get(ILogService);
+        const notificationService = accessor.get(INotificationService);
+        await active.provider.setAgentMergeEnabled(active.session.sessionId, true);
+        logService.info(
+            `[AgentMergeActions] Enable requested: session=${active.session.sessionId}, provider=${active.session.providerId}`
+        );
+        notificationService.info(( localize(4279, "Agent Merge is enabled for the active session.")));
+    }
+});
+registerAction2(class DisableAgentMergeAction extends AgentMergeActionBase {
+    constructor() {
+        super({
+            id: "sessions.agentHost.agentMerge.disable",
+            title: ( localize2(4280, "Disable Agent Merge for Active Session")),
+            f1: true,
+            precondition: ( ContextKeyExpr.and(agentMergeCommandPrecondition, SessionAgentMergeEnabledContext))
+        });
+    }
+    async run(accessor) {
+        const active = this.getActiveSession(accessor);
+        if (!active) {
+            return;
+        }
+        const logService = accessor.get(ILogService);
+        const notificationService = accessor.get(INotificationService);
+        await active.provider.setAgentMergeEnabled(active.session.sessionId, false);
+        logService.info(
+            `[AgentMergeActions] Disable requested: session=${active.session.sessionId}, provider=${active.session.providerId}`
+        );
+        notificationService.info(( localize(4281, "Agent Merge is disabled for the active session.")));
+    }
+});
+registerAction2(class ConfigureAgentMergeAction extends AgentMergeActionBase {
+    constructor() {
+        super({
+            id: "sessions.agentHost.agentMerge.configure",
+            title: ( localize2(4282, "Configure Agent Merge for Active Session")),
+            f1: true,
+            precondition: agentMergeCommandPrecondition
+        });
+    }
+    async run(accessor) {
+        const active = this.getActiveSession(accessor);
+        if (!active) {
+            return;
+        }
+        const configurationService = accessor.get(IConfigurationService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const logService = accessor.get(ILogService);
+        const notificationService = accessor.get(INotificationService);
+        const defaults = getGlobalAgentMergeConfiguration(configurationService);
+        const current = active.provider.getAgentMergeSessionState(active.session.sessionId);
+        const effective = resolveAgentMergeConfiguration(defaults, current?.overrides);
+        const picks = agentMergeRepairActions.map(action => ({
+            action,
+            label: agentMergeActionLabels[action],
+            picked: effective[action]
+        }));
+        const result = await pickAgentMergeActions(quickInputService, picks);
+        if (!result) {
+            return;
+        }
+        const overrides = result.reset ? undefined : toOverrides(result.actions, effective.mergePullRequest);
+        await active.provider.setAgentMergeOverrides(active.session.sessionId, overrides);
+        logService.info(
+            `[AgentMergeActions] Action overrides updated: session=${active.session.sessionId}, provider=${active.session.providerId}, reset=${result.reset}, enabledActions=${[...result.actions].sort().join(",") || "none"}`
+        );
+        notificationService.info(result.reset ? ( localize(
+            4283,
+            "Agent Merge now follows the global action defaults for this session."
+        )) : ( localize(4284, "Agent Merge actions were updated for the active session.")));
+    }
+});
+function pickAgentMergeActions(quickInputService, picks) {
+    const store = ( new DisposableStore());
+    return (new Promise(resolve => {
+        const quickPick = store.add(quickInputService.createQuickPick());
+        quickPick.title = ( localize(4285, "Agent Merge"));
+        quickPick.placeholder = ( localize(4286, "Select actions Agent Merge may perform for this session"));
+        quickPick.canSelectMany = true;
+        quickPick.items = picks;
+        quickPick.selectedItems = picks.filter(pick => pick.picked);
+        quickPick.buttons = [{
+            iconClass: ThemeIcon.asClassName(Codicon.discard),
+            tooltip: ( localize(4287, "Reset to Global Defaults"))
+        }];
+        store.add(quickPick.onDidTriggerButton(() => {
+            resolve({
+                reset: true,
+                actions: ( new Set())
+            });
+            quickPick.hide();
+        }));
+        store.add(quickPick.onDidAccept(() => {
+            resolve({
+                reset: false,
+                actions: ( new Set(quickPick.selectedItems.map(item => item.action)))
+            });
+            quickPick.hide();
+        }));
+        store.add(quickPick.onDidHide(() => {
+            resolve(undefined);
+            store.dispose();
+        }));
+        quickPick.show();
+    }));
+}
+function toOverrides(selected, mergePullRequest) {
+    const overrides = {
+        mergePullRequest
+    };
+    for (const action of agentMergeRepairActions) {
+        overrides[action] = ( selected.has(action));
+    }
+    return overrides;
+}

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/exportDebugLogsAction.d.ts

@@ -0,0 +1,7 @@
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+export declare class ExportAgentHostDebugLogsAction extends Action2 {
+    static readonly ID = "agentHost.exportDebugLogs";
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}

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

@@ -0,0 +1,48 @@
+
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { AGENT_HOST_ENABLED_CONTEXT_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService';
+import { DEFAULT_CHAT_ID } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { exportAgentHostDebugLogs } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+
+class ExportAgentHostDebugLogsAction extends Action2 {
+    static {
+        this.ID = "agentHost.exportDebugLogs";
+    }
+    constructor() {
+        super({
+            id: ExportAgentHostDebugLogsAction.ID,
+            title: ( localize2(4306, "Export Agent Host Debug Logs...")),
+            f1: true,
+            category: Categories.Developer,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.or(IsSessionsWindowContext, AGENT_HOST_ENABLED_CONTEXT_KEY))))
+        });
+    }
+    async run(accessor) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsProvidersService = accessor.get(ISessionsProvidersService);
+        const activeSession = sessionsService.activeSession.get();
+        const provider = activeSession ? sessionsProvidersService.getProvider(activeSession.providerId) : undefined;
+        const activeProvider = provider && isAgentHostProvider(provider) ? provider : undefined;
+        const activeChat = activeSession?.activeChat.get();
+        const activeSessionContext = activeSession && activeProvider ? {
+            resource: activeSession.resource,
+            sessionTitle: activeSession.title.get(),
+            chatTitle: activeChat?.title.get(),
+            isLocal: activeSession.resource.scheme.startsWith("agent-host-"),
+            chatId: activeChat?.resource.fragment || DEFAULT_CHAT_ID,
+            backendChatResource: activeChat ? activeProvider.getBackendChatResource(activeChat.resource) : undefined
+        } : undefined;
+        await exportAgentHostDebugLogs(accessor, activeSessionContext);
+    }
+}
+registerAction2(ExportAgentHostDebugLogsAction);
+
+export { ExportAgentHostDebugLogsAction };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/media/agentHostSessionConfigPicker.css

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.sessions-chat-agent-host-config {
+	display: flex;
+	align-items: center;
+	/* Each config control carries its own surface, so they need a gap. */
+	gap: var(--vscode-spacing-size20);
+	min-width: 0;
+}
+
+.monaco-workbench .sessions-chat-agent-host-config-host[tabindex]:focus {
+	outline: none;
+}
+
+.sessions-chat-agent-host-config:empty {
+	display: none;
+}
+
+.sessions-chat-agent-host-config a.action-label {
+	touch-action: manipulation;
+}
+
+.sessions-chat-agent-host-config .sessions-chat-config-checkbox .action-label {
+	cursor: pointer;
+}
+
+.sessions-chat-agent-host-config .sessions-chat-config-checkbox .monaco-checkbox {
+	margin-right: var(--vscode-spacing-size60);
+}
+
+.sessions-chat-agent-host-config .sessions-chat-config-checkbox .sessions-chat-dropdown-label {
+	margin-left: 0;
+	cursor: pointer;
+}
+
+.sessions-chat-agent-host-config .sessions-chat-config-checkbox.disabled .action-label,
+.sessions-chat-agent-host-config .sessions-chat-config-checkbox.disabled .sessions-chat-dropdown-label,
+.sessions-chat-agent-host-config .sessions-chat-config-checkbox.resolving .action-label,
+.sessions-chat-agent-host-config .sessions-chat-config-checkbox.resolving .sessions-chat-dropdown-label {
+	cursor: default;
+}

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/mobile/mobileAgentHostModePicker.d.ts

@@ -0,0 +1,30 @@
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { IActionListOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatPhoneInputPresenter } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatPhoneInputPresenter.service";
+import { IChatPetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { AgentHostModePicker } from "../agentHostModePicker.js";
+/**
+ * Phone-aware variant of {@link AgentHostModePicker}. On phone-layout
+ * viewports the desktop action-widget popover is replaced with the same
+ * combined Mode + Model bottom sheet used by the workbench picker button and the
+ * empty new-chat picker (see {@link IChatPhoneInputPresenter}). On
+ * desktop the inherited `_showPicker` falls through to the base
+ * implementation, so this class is safe to keep through viewport-class
+ * transitions.
+ */
+export declare class MobileAgentHostModePicker extends AgentHostModePicker {
+    private readonly _phonePresenter;
+    private readonly _chatWidgetService;
+    protected readonly _chatPetService: IChatPetService;
+    constructor(session: IObservable<IActiveSession | undefined>, actionWidgetService: IActionWidgetService, sessionsProvidersService: ISessionsProvidersService, telemetryService: ITelemetryService, hoverService: IHoverService, _phonePresenter: IChatPhoneInputPresenter, _chatWidgetService: IChatWidgetService, _chatPetService: IChatPetService, instantiationService: IInstantiationService, configurationService: IConfigurationService, preferencesService: IPreferencesService);
+    protected _showPicker(anchor?: HTMLElement | undefined, onHide?: () => void, listOptions?: IActionListOptions): boolean;
+}