@codingame/monaco-vscode-api 33.0.9 → 34.0.1

package/vscode/src/vs/platform/actionWidget/browser/actionWidgetDropdown.d.ts

@@ -0,0 +1,77 @@
+import { BaseDropdown, IActionProvider, IBaseDropdownOptions } from "../../../base/browser/ui/dropdown/dropdown.js";
+import { IAction } from "../../../base/common/actions.js";
+import { IMarkdownString } from "../../../base/common/htmlContent.js";
+import { ResolvedKeybinding } from "../../../base/common/keybindings.js";
+import { ThemeIcon } from "../../../base/common/themables.js";
+import { IKeybindingService } from "../../keybinding/common/keybinding.service.js";
+import { ITelemetryService } from "../../telemetry/common/telemetry.service.js";
+import { IActionListItemHover, IActionListOptions } from "./actionList.js";
+import { IActionWidgetService } from "./actionWidget.service.js";
+export interface IActionWidgetDropdownAction extends IAction {
+    category?: {
+        label: string;
+        order: number;
+        showHeader?: boolean;
+    };
+    icon?: ThemeIcon;
+    description?: string | IMarkdownString;
+    /**
+     * Optional detail text displayed as a second line below the label.
+     */
+    detail?: string;
+    /**
+     * Optional flyout hover configuration shown when focusing/hovering over the action.
+     */
+    hover?: IActionListItemHover;
+    /**
+     * Optional toolbar actions shown when the item is focused or hovered.
+     */
+    toolbarActions?: IAction[];
+    /**
+     * Optional keybinding to display next to the action. When provided, this overrides the
+     * keybinding that would otherwise be looked up via {@link IKeybindingService.lookupKeybinding}.
+     * Useful when the active keybinding depends on a scoped context (e.g. focus state) that the
+     * dropdown cannot evaluate at display time.
+     */
+    keybinding?: ResolvedKeybinding;
+}
+export interface IActionWidgetDropdownActionProvider {
+    getActions(): IActionWidgetDropdownAction[];
+}
+export interface IActionWidgetDropdownOptions extends IBaseDropdownOptions {
+    readonly actions?: IActionWidgetDropdownAction[];
+    readonly actionProvider?: IActionWidgetDropdownActionProvider;
+    readonly actionBarActions?: IAction[];
+    readonly actionBarActionProvider?: IActionProvider;
+    readonly showItemKeybindings?: boolean;
+    getAnchor?: () => HTMLElement;
+    /**
+     * Telemetry reporter configuration used when the dropdown closes. The `id` field is required
+     * and is used as the telemetry identifier; `name` is optional additional context. If not
+     * provided, no telemetry will be sent.
+     */
+    readonly reporter?: {
+        id: string;
+        name?: string;
+        includeOptions?: boolean;
+    };
+    /**
+     * Options for the underlying ActionList (filter, collapsible sections).
+     */
+    readonly listOptions?: IActionListOptions;
+}
+/**
+ * Action widget dropdown is a dropdown that uses the action widget under the hood to simulate a native dropdown menu
+ * The benefits of this include non native features such as headers, descriptions, icons, and button bar
+ */
+export declare class ActionWidgetDropdown extends BaseDropdown {
+    private readonly _options;
+    private readonly actionWidgetService;
+    private readonly keybindingService;
+    private readonly telemetryService;
+    private _enabled;
+    constructor(container: HTMLElement, _options: IActionWidgetDropdownOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
+    show(): void;
+    setEnabled(enabled: boolean): void;
+    private _emitCloseEvent;
+}

package/vscode/src/vs/platform/actionWidget/browser/actionWidgetDropdown.js

@@ -0,0 +1,191 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { getActiveElement, isHTMLElement } from '../../../base/browser/dom.js';
+import { BaseDropdown } from '../../../base/browser/ui/dropdown/dropdown.js';
+import { Codicon } from '../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+import { ActionListItemKind } from './actionList.js';
+import { IActionWidgetService } from './actionWidget.service.js';
+
+let ActionWidgetDropdown = class ActionWidgetDropdown extends BaseDropdown {
+    constructor(
+        container,
+        _options,
+        actionWidgetService,
+        keybindingService,
+        telemetryService
+    ) {
+        super(container, _options);
+        this._options = _options;
+        this.actionWidgetService = actionWidgetService;
+        this.keybindingService = keybindingService;
+        this.telemetryService = telemetryService;
+        this._enabled = true;
+    }
+    show() {
+        if (!this._enabled) {
+            return;
+        }
+        const actionBarActions = this._options.actionBarActions ?? this._options.actionBarActionProvider?.getActions() ?? [];
+        const actions = this._options.actions ?? this._options.actionProvider?.getActions() ?? [];
+        const optionBeforeOpen = actions.find(a => a.checked);
+        let selectedOption = optionBeforeOpen;
+        const actionWidgetItems = [];
+        const actionsByCategory = ( new Map());
+        for (const action of actions) {
+            let category = action.category;
+            if (!category) {
+                category = {
+                    label: "",
+                    order: Number.MIN_SAFE_INTEGER
+                };
+            }
+            if (!( actionsByCategory.has(category.label))) {
+                actionsByCategory.set(category.label, []);
+            }
+            actionsByCategory.get(category.label).push(action);
+        }
+        const sortedCategories = Array.from(actionsByCategory.entries()).sort((a, b) => {
+            const aOrder = a[1][0]?.category?.order ?? Number.MAX_SAFE_INTEGER;
+            const bOrder = b[1][0]?.category?.order ?? Number.MAX_SAFE_INTEGER;
+            return aOrder - bOrder;
+        });
+        for (let i = 0; i < sortedCategories.length; i++) {
+            const [categoryLabel, categoryActions] = sortedCategories[i];
+            const showHeader = categoryActions[0]?.category?.showHeader ?? false;
+            if (showHeader && categoryLabel) {
+                actionWidgetItems.push({
+                    kind: ActionListItemKind.Header,
+                    label: categoryLabel,
+                    canPreview: false,
+                    disabled: false,
+                    hideIcon: false
+                });
+            }
+            for (const action of categoryActions) {
+                actionWidgetItems.push({
+                    item: action,
+                    tooltip: action.tooltip,
+                    description: action.description,
+                    detail: action.detail,
+                    hover: action.hover,
+                    toolbarActions: action.toolbarActions,
+                    kind: ActionListItemKind.Action,
+                    canPreview: false,
+                    group: {
+                        title: "",
+                        icon: action.icon ?? ThemeIcon.fromId(action.checked ? Codicon.check.id : Codicon.blank.id)
+                    },
+                    disabled: !action.enabled,
+                    hideIcon: false,
+                    label: action.label,
+                    keybinding: this._options.showItemKeybindings ? (action.keybinding ?? this.keybindingService.lookupKeybinding(action.id)) : undefined
+                });
+            }
+            if (i < sortedCategories.length - 1) {
+                actionWidgetItems.push({
+                    label: "",
+                    kind: ActionListItemKind.Separator,
+                    canPreview: false,
+                    disabled: false,
+                    hideIcon: false
+                });
+            }
+        }
+        const previouslyFocusedElement = getActiveElement();
+        const auxiliaryActionIds = ( new Set(( actionBarActions.map(action => action.id))));
+        const actionWidgetDelegate = {
+            onSelect: (action, preview) => {
+                if (!( auxiliaryActionIds.has(action.id))) {
+                    selectedOption = action;
+                }
+                this.actionWidgetService.hide();
+                action.run();
+            },
+            onHide: () => {
+                this.hide();
+                if (isHTMLElement(previouslyFocusedElement)) {
+                    previouslyFocusedElement.focus();
+                }
+                this._emitCloseEvent(optionBeforeOpen, selectedOption);
+            }
+        };
+        if (actionBarActions.length) {
+            if (actionWidgetItems.length) {
+                actionWidgetItems.push({
+                    label: "",
+                    kind: ActionListItemKind.Separator,
+                    canPreview: false,
+                    disabled: false,
+                    hideIcon: false
+                });
+            }
+            for (const action of actionBarActions) {
+                actionWidgetItems.push({
+                    item: action,
+                    tooltip: action.tooltip,
+                    kind: ActionListItemKind.Action,
+                    canPreview: false,
+                    group: {
+                        title: "",
+                        icon: ThemeIcon.fromId(Codicon.blank.id)
+                    },
+                    disabled: !action.enabled,
+                    hideIcon: false,
+                    label: action.label
+                });
+            }
+        }
+        const accessibilityProvider = {
+            isChecked(element) {
+                return element.kind === ActionListItemKind.Action && !!element?.item?.checked;
+            },
+            getRole: e => {
+                switch (e.kind) {
+                case ActionListItemKind.Action:
+                    return e.item && ( auxiliaryActionIds.has(e.item.id)) ? "menuitem" : "menuitemcheckbox";
+                case ActionListItemKind.Separator:
+                    return "separator";
+                default:
+                    return "separator";
+                }
+            },
+            getWidgetRole: () => "menu"
+        };
+        super.show();
+        this.actionWidgetService.show(
+            this._options.label ?? "",
+            false,
+            actionWidgetItems,
+            actionWidgetDelegate,
+            this._options.getAnchor?.() ?? this.element,
+            undefined,
+            [],
+            accessibilityProvider,
+            this._options.listOptions
+        );
+    }
+    setEnabled(enabled) {
+        this._enabled = enabled;
+    }
+    _emitCloseEvent(optionBeforeOpen, selectedOption) {
+        const optionBefore = optionBeforeOpen;
+        const optionAfter = selectedOption;
+        if (this._options.reporter) {
+            this.telemetryService.publicLog2("actionWidgetDropdownClosed", {
+                id: this._options.reporter.id,
+                name: this._options.reporter.name,
+                selectionChanged: optionBefore?.id !== optionAfter?.id,
+                optionIdBefore: this._options.reporter.includeOptions ? optionBefore?.id : undefined,
+                optionIdAfter: this._options.reporter.includeOptions ? optionAfter?.id : undefined,
+                optionLabelBefore: this._options.reporter.includeOptions ? optionBefore?.label : undefined,
+                optionLabelAfter: this._options.reporter.includeOptions ? optionAfter?.label : undefined
+            });
+        }
+    }
+};
+ActionWidgetDropdown = ( __decorate([( __param(2, IActionWidgetService)), ( __param(3, IKeybindingService)), ( __param(4, ITelemetryService))], ActionWidgetDropdown));
+
+export { ActionWidgetDropdown };

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -262,7 +262,7 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altTitleSection = this._keybindingService.appendKeybinding(altTooltip, this._menuItemAction.alt.id, this._contextKeyService);
             title = ( localize(
-                1812,
+                1814,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -330,9 +330,9 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(1813, "{1} to {0}", this._action.label, kb2));
+                this.label.textContent = ( localize(1815, "{1} to {0}", this._action.label, kb2));
             } else {
-                this.label.textContent = ( localize(1814, "{0} ({1})", this._action.label, kb2));
+                this.label.textContent = ( localize(1816, "{0} ({1})", this._action.label, kb2));
             }
         }
     }
@@ -414,7 +414,8 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         }
         this._defaultAction = this._defaultActionDisposables.add(
             this._instaService.createInstance(MenuEntryActionViewItem, defaultAction, {
-                keybinding: this._getDefaultActionKeybindingLabel(defaultAction)
+                keybinding: this._getDefaultActionKeybindingLabel(defaultAction),
+                hoverDelegate: options?.hoverDelegate
             })
         );
         const dropdownOptions = {
@@ -452,7 +453,8 @@ let DropdownWithDefaultActionViewItem = class DropdownWithDefaultActionViewItem
         }
         this._defaultActionDisposables.clear();
         this._defaultAction = this._defaultActionDisposables.add(this._instaService.createInstance(MenuEntryActionViewItem, lastAction, {
-            keybinding: this._getDefaultActionKeybindingLabel(lastAction)
+            keybinding: this._getDefaultActionKeybindingLabel(lastAction),
+            hoverDelegate: this._options?.hoverDelegate
         }));
         this._defaultAction.actionRunner = this._defaultActionDisposables.add(new (class extends ActionRunner {
             async runAction(action, context) {

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -74,6 +74,10 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         if (this._options?.hiddenItemStrategy !== HiddenItemStrategy.NoHide) {
             for (let i = 0; i < primary.length; i++) {
                 const action = primary[i];
+                if (action instanceof Separator) {
+                    extraSecondary[i] = action;
+                    continue;
+                }
                 if (!(action instanceof MenuItemAction) && !(action instanceof SubmenuItemAction)) {
                     continue;
                 }
@@ -114,7 +118,10 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         }
         coalesceInPlace(primary);
         coalesceInPlace(extraSecondary);
-        super.setActions(Separator.clean(primary), Separator.join(extraSecondary, secondary));
+        super.setActions(
+            Separator.clean(primary),
+            Separator.join(Separator.clean(extraSecondary), secondary)
+        );
         if (toggleActions.length > 0 || primary.length > 0) {
             this._sessionDisposables.add(addDisposableListener(this.getElement(), "contextmenu", e => {
                 const event = ( new StandardMouseEvent(getWindow(this.getElement()), e));
@@ -162,7 +169,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     } else {
                         primaryActions.push(toAction({
                             id: "label",
-                            label: ( localize(1815, "Hide")),
+                            label: ( localize(1817, "Hide")),
                             enabled: false,
                             run() {}
                         }));
@@ -176,7 +183,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(( new Separator()));
                     actions.push(toAction({
                         id: "resetThisMenu",
-                        label: ( localize(1816, "Reset Menu")),
+                        label: ( localize(1818, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }

package/vscode/src/vs/platform/actions/common/actions.d.ts

@@ -244,6 +244,7 @@ export declare class MenuId {
     static readonly ChatExecuteQueue: MenuId;
     static readonly ChatInput: MenuId;
     static readonly ChatInputSecondary: MenuId;
+    static readonly ChatInputStatus: MenuId;
     static readonly ChatInputSide: MenuId;
     static readonly ChatModePicker: MenuId;
     static readonly ChatEditingWidgetToolbar: MenuId;
@@ -285,6 +286,8 @@ export declare class MenuId {
     static readonly DiffEditorSelectionToolbar: MenuId;
     static readonly BrowserNavigationToolbar: MenuId;
     static readonly BrowserActionsToolbar: MenuId;
+    static readonly BrowserChatActionsMenu: MenuId;
+    static readonly BrowserEmulationToolbar: MenuId;
     static readonly AgentSessionsViewerFilterSubMenu: MenuId;
     static readonly AgentSessionsContext: MenuId;
     static readonly AgentSessionSectionContext: MenuId;
@@ -292,6 +295,8 @@ export declare class MenuId {
     static readonly AgentSessionsToolbar: MenuId;
     static readonly AgentSessionItemToolbar: MenuId;
     static readonly AgentSessionSectionToolbar: MenuId;
+    static readonly SessionItemContextMenu: MenuId;
+    static readonly SessionHeaderContext: MenuId;
     static readonly AgentsTitleBarControlMenu: MenuId;
     static readonly AgentsChangesToolbar: MenuId;
     static readonly AgentsChangesPrimaryActionSubMenu: MenuId;

package/vscode/src/vs/platform/actions/common/actions.js

@@ -607,6 +607,9 @@ class MenuId {
     static {
         this.ChatInputSecondary = ( new MenuId("ChatInputSecondary"));
     }
+    static {
+        this.ChatInputStatus = ( new MenuId("ChatInputStatus"));
+    }
     static {
         this.ChatInputSide = ( new MenuId("ChatInputSide"));
     }
@@ -730,6 +733,12 @@ class MenuId {
     static {
         this.BrowserActionsToolbar = ( new MenuId("BrowserActionsToolbar"));
     }
+    static {
+        this.BrowserChatActionsMenu = ( new MenuId("BrowserChatActionsMenu"));
+    }
+    static {
+        this.BrowserEmulationToolbar = ( new MenuId("BrowserEmulationToolbar"));
+    }
     static {
         this.AgentSessionsViewerFilterSubMenu = ( new MenuId("AgentSessionsViewerFilterSubMenu"));
     }
@@ -751,6 +760,12 @@ class MenuId {
     static {
         this.AgentSessionSectionToolbar = ( new MenuId("AgentSessionSectionToolbar"));
     }
+    static {
+        this.SessionItemContextMenu = ( new MenuId("SessionItemContextMenu"));
+    }
+    static {
+        this.SessionHeaderContext = ( new MenuId("SessionsSessionHeaderContext"));
+    }
     static {
         this.AgentsTitleBarControlMenu = ( new MenuId("AgentsTitleBarControlMenu"));
     }

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -9,7 +9,7 @@ class MenuHiddenStatesReset extends Action2 {
     constructor() {
         super({
             id: "menu.resetHiddenStates",
-            title: ( localize2(1817, "Reset All Menus")),
+            title: ( localize2(1819, "Reset All Menus")),
             category: Categories.View,
             f1: true
         });

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -430,7 +430,7 @@ function createMenuHide(menu, command, states) {
     const title = typeof command.title === "string" ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localize(1818, "Hide '{0}'", title)),
+        label: ( localize(1820, "Hide '{0}'", title)),
         run() {
             states.updateHidden(menu, id, true);
         }
@@ -462,7 +462,7 @@ function createConfigureKeybindingAction(
 ) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: ( localize(1819, "Configure Keybinding")),
+        label: ( localize(1821, "Configure Keybinding")),
         enabled,
         run() {
             const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);

package/vscode/src/vs/platform/agentHost/browser/nullAgentHostService.d.ts

@@ -4,10 +4,12 @@ import { IObservable } from "../../../base/common/observable.js";
 import { URI } from "../../../base/common/uri.js";
 import type { IAgentCreateSessionConfig, IAgentHostInspectInfo, IAgentHostSocketInfo, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
 import { IAgentHostService } from "../common/agentService.service.js";
-import type { IAgentSubscription } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/agentSubscription";
+import type { IActiveSubscriptionInfo, IAgentSubscription } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/agentSubscription";
 import type { CompletionsParams, CompletionsResult, CreateTerminalParams, ResolveSessionConfigResult, SessionConfigCompletionsResult } from "../common/state/protocol/commands.js";
+import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "../common/state/protocol/channels-changeset/commands.js";
 import type { ActionEnvelope, INotification, IRootConfigChangedAction, SessionAction, TerminalAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
-import type { ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceWriteParams, ResourceWriteResult } from "../common/state/sessionProtocol.js";
+import type { IRemoteWatchHandle } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentHostFileSystemProvider";
+import type { CreateResourceWatchParams, CreateResourceWatchResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMkdirParams, ResourceMkdirResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceResolveParams, ResourceResolveResult, ResourceWriteParams, ResourceWriteResult } from "../common/state/sessionProtocol.js";
 import type { ComponentToState, RootState, StateComponents } from "../common/state/sessionState.js";
 /**
  * Null implementation of {@link IAgentHostService} for browser contexts
@@ -23,9 +25,10 @@ export declare class NullAgentHostService implements IAgentHostService {
     readonly authenticationPending: IObservable<boolean>;
     setAuthenticationPending(_pending: boolean): void;
     get rootState(): IAgentSubscription<RootState>;
-    getSubscription<T extends StateComponents>(_kind: T, _resource: URI): IReference<IAgentSubscription<ComponentToState[T]>>;
+    getSubscription<T extends StateComponents>(_kind: T, _resource: URI, _owner: string): IReference<IAgentSubscription<ComponentToState[T]>>;
     getSubscriptionUnmanaged<T extends StateComponents>(_kind: T, _resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
-    dispatch(_action: SessionAction | TerminalAction | IRootConfigChangedAction): void;
+    getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
+    dispatch(_channel: string, _action: SessionAction | TerminalAction | IRootConfigChangedAction): void;
     restartAgentHost(): Promise<void>;
     authenticate(_params: AuthenticateParams): Promise<AuthenticateResult>;
     listSessions(): Promise<IAgentSessionMetadata[]>;
@@ -39,10 +42,15 @@ export declare class NullAgentHostService implements IAgentHostService {
     disposeSession(_session: URI): Promise<void>;
     createTerminal(_params: CreateTerminalParams): Promise<void>;
     disposeTerminal(_terminal: URI): Promise<void>;
+    invokeChangesetOperation(_params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
     resourceList(_uri: URI): Promise<ResourceListResult>;
     resourceRead(_uri: URI): Promise<ResourceReadResult>;
     resourceWrite(_params: ResourceWriteParams): Promise<ResourceWriteResult>;
     resourceCopy(_params: ResourceCopyParams): Promise<ResourceCopyResult>;
     resourceDelete(_params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
     resourceMove(_params: ResourceMoveParams): Promise<ResourceMoveResult>;
+    resourceResolve(_params: ResourceResolveParams): Promise<ResourceResolveResult>;
+    resourceMkdir(_params: ResourceMkdirParams): Promise<ResourceMkdirResult>;
+    createResourceWatch(_params: CreateResourceWatchParams): Promise<CreateResourceWatchResult>;
+    watchResource(_params: CreateResourceWatchParams): Promise<IRemoteWatchHandle>;
 }

package/vscode/src/vs/platform/agentHost/browser/nullAgentHostService.js

@@ -19,13 +19,16 @@ class NullAgentHostService {
     get rootState() {
         return notSupported();
     }
-    getSubscription(_kind, _resource) {
+    getSubscription(_kind, _resource, _owner) {
         return notSupported();
     }
     getSubscriptionUnmanaged(_kind, _resource) {
         return undefined;
     }
-    dispatch(_action) {
+    getActiveSubscriptions() {
+        return [];
+    }
+    dispatch(_channel, _action) {
         notSupported();
     }
     async restartAgentHost() {
@@ -65,6 +68,9 @@ class NullAgentHostService {
         notSupported();
     }
     async disposeTerminal(_terminal) {}
+    async invokeChangesetOperation(_params) {
+        return notSupported();
+    }
     async resourceList(_uri) {
         return notSupported();
     }
@@ -83,6 +89,18 @@ class NullAgentHostService {
     async resourceMove(_params) {
         return notSupported();
     }
+    async resourceResolve(_params) {
+        return notSupported();
+    }
+    async resourceMkdir(_params) {
+        return notSupported();
+    }
+    async createResourceWatch(_params) {
+        return notSupported();
+    }
+    async watchResource(_params) {
+        return notSupported();
+    }
 }
 
 export { NullAgentHostService };

package/vscode/src/vs/platform/agentHost/common/agentHostResourceService.service.d.ts

@@ -0,0 +1,70 @@
+import { IDisposable } from "../../../base/common/lifecycle.js";
+import { IObservable } from "../../../base/common/observable.js";
+import { URI } from "../../../base/common/uri.js";
+import { IResourceListResult, IResourceReadResult, AgentHostPermissionMode, IPendingResourceRequest } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentHostResourceService";
+import { ResourceRequestParams } from "./state/protocol/commands.js";
+import { ResourceWriteParams, ResourceDeleteParams, ResourceMoveParams, ResourceCopyParams, ResourceResolveParams, ResourceResolveResult, ResourceMkdirParams } from "./state/sessionProtocol.js";
+export declare const IAgentHostResourceService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostResourceService>;
+/**
+* Single owner of agent-host-facing filesystem operations and the
+* permission policy that gates them. Combines what were previously two
+* services (`IAgentHostPermissionService` + `IAgentHostVirtualResourceProvider`)
+* into one consistent interface used by both the in-process local channel
+* and the remote protocol client.
+*
+* Each FS method is gated by a permission check keyed on `address`: a
+* normalized network host for remote agent hosts, or
+* {@link LOCAL_AGENT_HOST_ADDRESS} for the local utility-process host.
+* Denied operations throw {@link AgentHostResourcePermissionError} carrying
+* the {@link ResourceRequestParams} that, if granted, would unlock the
+* operation.
+*
+* Read operations transparently fall back to virtual content (untitled
+* documents, notebook cells, ...) when the local file service cannot
+* resolve the URI.
+*/
+export interface IAgentHostResourceService {
+    readonly _serviceBrand: undefined;
+    list(address: string, uri: URI): Promise<IResourceListResult>;
+    read(address: string, uri: URI): Promise<IResourceReadResult>;
+    write(address: string, params: ResourceWriteParams): Promise<void>;
+    del(address: string, params: ResourceDeleteParams): Promise<void>;
+    move(address: string, params: ResourceMoveParams): Promise<void>;
+    copy(address: string, params: ResourceCopyParams): Promise<void>;
+    resolve(address: string, params: ResourceResolveParams): Promise<ResourceResolveResult>;
+    mkdir(address: string, params: ResourceMkdirParams): Promise<void>;
+    /**
+    * Returns whether {@link uri} is already granted for {@link mode} on
+    * {@link address}. Useful as a pre-check before sending data to a host
+    * that will read it back. The same gating runs implicitly inside every
+    * FS method on this service.
+    */
+    check(address: string, uri: URI, mode: AgentHostPermissionMode): Promise<boolean>;
+    /**
+    * Handle an inbound `resourceRequest` from a host. Resolves once access
+    * is granted (immediately, if already covered); rejects with a
+    * `CancellationError` if the user denies or the connection closes.
+    */
+    request(address: string, params: ResourceRequestParams): Promise<void>;
+    /** Per-address observable of pending requests for UI surfaces. */
+    pendingFor(address: string): IObservable<readonly IPendingResourceRequest[]>;
+    /** Observable of all pending requests across every address. */
+    readonly allPending: IObservable<readonly IPendingResourceRequest[]>;
+    /**
+    * Find a pending request by id, across all addresses. Returns
+    * `undefined` once the request has been resolved or rejected.
+    */
+    findPending(id: string): IPendingResourceRequest | undefined;
+    /**
+    * Register an implicit read grant for {@link uri} (and descendants) on
+    * {@link address}. Used by call sites that are about to send a URI to a
+    * host and therefore expect that host to read it back. The returned
+    * disposable revokes the grant.
+    */
+    grantImplicitRead(address: string, uri: URI): IDisposable;
+    /**
+    * Notify that the connection at {@link address} has closed. Drops all
+    * implicit grants and rejects any outstanding pending requests.
+    */
+    connectionClosed(address: string): void;
+}

package/vscode/src/vs/platform/agentHost/common/agentHostResourceService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const IAgentHostResourceService = ( createDecorator("agentHostResourceService"));
+
+export { IAgentHostResourceService };

package/vscode/src/vs/platform/agentHost/common/agentPluginManager.d.ts

@@ -1,11 +1,11 @@
 import { URI } from "../../../base/common/uri.js";
-import type { SessionCustomization } from "./state/sessionState.js";
+import type { PluginCustomization } from "./state/sessionState.js";
 /**
  * A synced customization with its local plugin directory (when available).
  */
 export interface ISyncedCustomization {
     /** The session customization with loading/error status. */
-    readonly customization: SessionCustomization;
+    readonly customization: PluginCustomization;
     /** Local plugin directory URI, defined when the sync was successful. */
     readonly pluginDir?: URI;
 }