@codingame/monaco-vscode-api 30.0.1 → 31.0.0

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

@@ -1,7 +1,7 @@
 
 import { registerCss } from '../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { createElement, addDisposableListener, EventType, trackFocus, getActiveElement, $ } from '../../../base/browser/dom.js';
+import { createElement, addDisposableGenericMouseDownListener, addDisposableListener, EventType, trackFocus, getActiveElement, $ } from '../../../base/browser/dom.js';
 import { ActionBar } from '../../../base/browser/ui/actionbar/actionbar.js';
 import { KeyMod as KeyMod$1, KeyCode } from '../../../base/common/keyCodes.js';
 import { Disposable, MutableDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
@@ -29,10 +29,10 @@ import '../../theme/common/colors/searchColors.js';
 import { IActionWidgetService } from './actionWidget.service.js';
 
 registerCss(actionWidget);
-registerColor("actionBar.toggledBackground", inputActiveOptionBackground, ( localize(1785, "Background color for toggled action items in action bar.")));
+registerColor("actionBar.toggledBackground", inputActiveOptionBackground, ( localize(1786, "Background color for toggled action items in action bar.")));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey("codeActionMenuVisible", false, ( localize(1786, "Whether the action widget list is visible")))),
-    FilterFocused: ( new RawContextKey("codeActionMenuFilterFocused", false, ( localize(1787, "Whether the action widget filter input is focused"))))
+    Visible: ( new RawContextKey("codeActionMenuVisible", false, ( localize(1787, "Whether the action widget list is visible")))),
+    FilterFocused: ( new RawContextKey("codeActionMenuFilterFocused", false, ( localize(1788, "Whether the action widget filter input is focused"))))
 };
 let ActionWidgetService = class ActionWidgetService extends Disposable {
     get isVisible() {
@@ -127,9 +127,7 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
         const menuBlock = createElement("div");
         const block = element.appendChild(menuBlock);
         block.classList.add("context-view-block");
-        renderDisposables.add(
-            addDisposableListener(block, EventType.MOUSE_DOWN, e => e.stopPropagation())
-        );
+        renderDisposables.add(addDisposableGenericMouseDownListener(block, e => e.stopPropagation()));
         const pointerBlockDiv = createElement("div");
         const pointerBlock = element.appendChild(pointerBlockDiv);
         pointerBlock.classList.add("context-view-pointerBlock");
@@ -137,7 +135,7 @@ let ActionWidgetService = class ActionWidgetService extends Disposable {
             addDisposableListener(pointerBlock, EventType.POINTER_MOVE, () => pointerBlock.remove())
         );
         renderDisposables.add(
-            addDisposableListener(pointerBlock, EventType.MOUSE_DOWN, () => pointerBlock.remove())
+            addDisposableGenericMouseDownListener(pointerBlock, () => pointerBlock.remove())
         );
         let actionBarWidth = 0;
         if (actionBarActions.length) {
@@ -196,7 +194,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "hideCodeActionWidget",
-            title: ( localize2(1788, "Hide action widget")),
+            title: ( localize2(1789, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -213,7 +211,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "clearFilterCodeActionWidget",
-            title: ( localize2(1789, "Clear action widget filter")),
+            title: ( localize2(1790, "Clear action widget filter")),
             precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ActionWidgetContextKeys.FilterFocused)),
             keybinding: {
                 weight: weight + 1,
@@ -234,7 +232,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "selectPrevCodeAction",
-            title: ( localize2(1790, "Select previous action")),
+            title: ( localize2(1791, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -258,7 +256,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "selectNextCodeAction",
-            title: ( localize2(1791, "Select next action")),
+            title: ( localize2(1792, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -282,7 +280,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "collapseSectionCodeAction",
-            title: ( localize2(1792, "Collapse section")),
+            title: ( localize2(1793, "Collapse section")),
             precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ( ActionWidgetContextKeys.FilterFocused.negate()))),
             keybinding: {
                 weight,
@@ -301,7 +299,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "expandSectionCodeAction",
-            title: ( localize2(1793, "Expand section")),
+            title: ( localize2(1794, "Expand section")),
             precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ( ActionWidgetContextKeys.FilterFocused.negate()))),
             keybinding: {
                 weight,
@@ -320,7 +318,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "toggleSectionCodeAction",
-            title: ( localize2(1794, "Toggle section")),
+            title: ( localize2(1795, "Toggle section")),
             precondition: ( ContextKeyExpr.and(ActionWidgetContextKeys.Visible, ( ActionWidgetContextKeys.FilterFocused.negate()))),
             keybinding: {
                 weight,
@@ -341,7 +339,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(1795, "Accept selected action")),
+            title: ( localize2(1796, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -361,7 +359,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(1796, "Preview selected action")),
+            title: ( localize2(1797, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

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(
-                1798,
+                1799,
                 "{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(1799, "{1} to {0}", this._action.label, kb2));
+                this.label.textContent = ( localize(1800, "{1} to {0}", this._action.label, kb2));
             } else {
-                this.label.textContent = ( localize(1800, "{0} ({1})", this._action.label, kb2));
+                this.label.textContent = ( localize(1801, "{0} ({1})", this._action.label, kb2));
             }
         }
     }

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

@@ -162,7 +162,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     } else {
                         primaryActions.push(toAction({
                             id: "label",
-                            label: ( localize(1801, "Hide")),
+                            label: ( localize(1802, "Hide")),
                             enabled: false,
                             run() {}
                         }));
@@ -176,7 +176,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(( new Separator()));
                     actions.push(toAction({
                         id: "resetThisMenu",
-                        label: ( localize(1802, "Reset Menu")),
+                        label: ( localize(1803, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }

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

@@ -83,6 +83,7 @@ export declare class MenuId {
     static readonly EditorTabsBarShowTabsSubmenu: MenuId;
     static readonly EditorTabsBarShowTabsZenModeSubmenu: MenuId;
     static readonly EditorActionsPositionSubmenu: MenuId;
+    static readonly EditorRenderWhitespaceSubmenu: MenuId;
     static readonly EditorSplitMoveSubmenu: MenuId;
     static readonly ExplorerContext: MenuId;
     static readonly ExplorerContextShare: MenuId;

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

@@ -124,6 +124,9 @@ class MenuId {
     static {
         this.EditorActionsPositionSubmenu = ( new MenuId("EditorActionsPositionSubmenu"));
     }
+    static {
+        this.EditorRenderWhitespaceSubmenu = ( new MenuId("EditorRenderWhitespaceSubmenu"));
+    }
     static {
         this.EditorSplitMoveSubmenu = ( new MenuId("EditorSplitMoveSubmenu"));
     }

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

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

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

@@ -429,7 +429,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(1804, "Hide '{0}'", title)),
+        label: ( localize(1805, "Hide '{0}'", title)),
         run() {
             states.updateHidden(menu, id, true);
         }
@@ -461,7 +461,7 @@ function createConfigureKeybindingAction(
 ) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: ( localize(1805, "Configure Keybinding")),
+        label: ( localize(1806, "Configure Keybinding")),
         enabled,
         run() {
             const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);

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

@@ -0,0 +1,45 @@
+import { Event } from "../../../base/common/event.js";
+import { IReference } from "../../../base/common/lifecycle.js";
+import { IObservable } from "../../../base/common/observable.js";
+import { URI } from "../../../base/common/uri.js";
+import type { IAgentCreateSessionConfig, IAgentHostSocketInfo, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, IAuthenticateParams, IAuthenticateResult } 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 { ICreateTerminalParams, IResolveSessionConfigResult, ISessionConfigCompletionsResult } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import type { IActionEnvelope, INotification, ISessionAction, ITerminalAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
+import type { IResourceCopyParams, IResourceCopyResult, IResourceDeleteParams, IResourceDeleteResult, IResourceListResult, IResourceMoveParams, IResourceMoveResult, IResourceReadResult, IResourceWriteParams, IResourceWriteResult } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionProtocol";
+import type { ComponentToState, IRootState, StateComponents } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+/**
+ * Null implementation of {@link IAgentHostService} for browser contexts
+ * where a local agent host process is not available.
+ */
+export declare class NullAgentHostService implements IAgentHostService {
+    readonly _serviceBrand: undefined;
+    readonly clientId = "";
+    readonly onAgentHostExit: Event<any>;
+    readonly onAgentHostStart: Event<any>;
+    readonly onDidNotification: Event<INotification>;
+    readonly onDidAction: Event<IActionEnvelope>;
+    readonly authenticationPending: IObservable<boolean>;
+    setAuthenticationPending(_pending: boolean): void;
+    get rootState(): IAgentSubscription<IRootState>;
+    getSubscription<T extends StateComponents>(_kind: T, _resource: URI): IReference<IAgentSubscription<ComponentToState[T]>>;
+    getSubscriptionUnmanaged<T extends StateComponents>(_kind: T, _resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
+    dispatch(_action: ISessionAction | ITerminalAction): void;
+    restartAgentHost(): Promise<void>;
+    authenticate(_params: IAuthenticateParams): Promise<IAuthenticateResult>;
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    createSession(_config?: IAgentCreateSessionConfig): Promise<URI>;
+    resolveSessionConfig(_params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
+    sessionConfigCompletions(_params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
+    startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+    disposeSession(_session: URI): Promise<void>;
+    createTerminal(_params: ICreateTerminalParams): Promise<void>;
+    disposeTerminal(_terminal: URI): Promise<void>;
+    resourceList(_uri: URI): Promise<IResourceListResult>;
+    resourceRead(_uri: URI): Promise<IResourceReadResult>;
+    resourceWrite(_params: IResourceWriteParams): Promise<IResourceWriteResult>;
+    resourceCopy(_params: IResourceCopyParams): Promise<IResourceCopyResult>;
+    resourceDelete(_params: IResourceDeleteParams): Promise<IResourceDeleteResult>;
+    resourceMove(_params: IResourceMoveParams): Promise<IResourceMoveResult>;
+}

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

@@ -0,0 +1,77 @@
+
+import { Event } from '../../../base/common/event.js';
+import '../../../base/common/observableInternal/index.js';
+import { constObservable } from '../../../base/common/observableInternal/observables/constObservable.js';
+
+const notSupported = () => {
+    throw ( new Error("Local agent host is not supported in the browser."));
+};
+class NullAgentHostService {
+    constructor() {
+        this.clientId = "";
+        this.onAgentHostExit = Event.None;
+        this.onAgentHostStart = Event.None;
+        this.onDidNotification = Event.None;
+        this.onDidAction = Event.None;
+        this.authenticationPending = constObservable(false);
+    }
+    setAuthenticationPending(_pending) {}
+    get rootState() {
+        return notSupported();
+    }
+    getSubscription(_kind, _resource) {
+        return notSupported();
+    }
+    getSubscriptionUnmanaged(_kind, _resource) {
+        return undefined;
+    }
+    dispatch(_action) {
+        notSupported();
+    }
+    async restartAgentHost() {
+        notSupported();
+    }
+    async authenticate(_params) {
+        return notSupported();
+    }
+    async listSessions() {
+        return [];
+    }
+    async createSession(_config) {
+        return notSupported();
+    }
+    async resolveSessionConfig(_params) {
+        return notSupported();
+    }
+    async sessionConfigCompletions(_params) {
+        return notSupported();
+    }
+    async startWebSocketServer() {
+        return notSupported();
+    }
+    async disposeSession(_session) {}
+    async createTerminal(_params) {
+        notSupported();
+    }
+    async disposeTerminal(_terminal) {}
+    async resourceList(_uri) {
+        return notSupported();
+    }
+    async resourceRead(_uri) {
+        return notSupported();
+    }
+    async resourceWrite(_params) {
+        return notSupported();
+    }
+    async resourceCopy(_params) {
+        return notSupported();
+    }
+    async resourceDelete(_params) {
+        return notSupported();
+    }
+    async resourceMove(_params) {
+        return notSupported();
+    }
+}
+
+export { NullAgentHostService };

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

@@ -0,0 +1,18 @@
+import { Event } from "../../../base/common/event.js";
+import type { ISSHAgentHostConnection, ISSHAgentHostConfig, ISSHConnectProgress, ISSHResolvedConfig } from "../common/sshRemoteAgentHost.js";
+import { ISSHRemoteAgentHostService } from "../common/sshRemoteAgentHost.service.js";
+/**
+ * Null implementation of {@link ISSHRemoteAgentHostService} for browser contexts
+ * where SSH is not available.
+ */
+export declare class NullSSHRemoteAgentHostService implements ISSHRemoteAgentHostService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeConnections: Event<any>;
+    readonly onDidReportConnectProgress: Event<ISSHConnectProgress>;
+    readonly connections: readonly ISSHAgentHostConnection[];
+    connect(_config: ISSHAgentHostConfig): Promise<ISSHAgentHostConnection>;
+    disconnect(_host: string): Promise<void>;
+    listSSHConfigHosts(): Promise<string[]>;
+    resolveSSHConfig(_host: string): Promise<ISSHResolvedConfig>;
+    reconnect(_sshConfigHost: string, _name: string): Promise<ISSHAgentHostConnection>;
+}

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

@@ -0,0 +1,25 @@
+
+import { Event } from '../../../base/common/event.js';
+
+class NullSSHRemoteAgentHostService {
+    constructor() {
+        this.onDidChangeConnections = Event.None;
+        this.onDidReportConnectProgress = Event.None;
+        this.connections = [];
+    }
+    async connect(_config) {
+        throw ( new Error("SSH connections are not supported in the browser."));
+    }
+    async disconnect(_host) {}
+    async listSSHConfigHosts() {
+        return [];
+    }
+    async resolveSSHConfig(_host) {
+        throw ( new Error("SSH is not supported in the browser."));
+    }
+    async reconnect(_sshConfigHost, _name) {
+        throw ( new Error("SSH connections are not supported in the browser."));
+    }
+}
+
+export { NullSSHRemoteAgentHostService };

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

@@ -0,0 +1,58 @@
+import { URI } from "../../../base/common/uri.js";
+import type { ResourceLabelFormatter } from "../../label/common/label.js";
+/**
+ * The URI scheme for accessing files on a remote agent host.
+ *
+ * URIs encode the original scheme, authority, and path so that any
+ * remote resource can be represented without assuming `file://`:
+ *
+ * ```
+ * vscode-agent-host://[connectionAuthority]/[originalScheme]/[originalAuthority]/[originalPath]
+ * ```
+ *
+ * For example, `file:///home/user/foo.ts` on remote `my-server` becomes:
+ * ```
+ * vscode-agent-host://my-server/file//home/user/foo.ts
+ * ```
+ */
+export declare const AGENT_HOST_SCHEME = "vscode-agent-host";
+/**
+ * Wraps a remote URI into a {@link AGENT_HOST_SCHEME} URI that can be
+ * resolved through the agent host filesystem provider.
+ *
+ * @param originalUri The URI on the remote (e.g. `file:///path` or
+ *   `agenthost-content:///sessionId/...`)
+ * @param connectionAuthority The sanitized connection identifier used as
+ *   the URI authority (from {@link agentHostAuthority}).
+ */
+export declare function toAgentHostUri(originalUri: URI, connectionAuthority: string): URI;
+/**
+ * Extracts the original URI from a {@link AGENT_HOST_SCHEME} URI.
+ *
+ * The inverse of {@link toAgentHostUri}.
+ */
+export declare function fromAgentHostUri(agentHostUri: URI): URI;
+/**
+ * Strips the redundant `ws://` scheme from an address. The transport layer
+ * already defaults to `ws://`, so only `wss://` needs to be preserved.
+ */
+export declare function normalizeRemoteAgentHostAddress(address: string): string;
+/**
+ * Encode a remote address into an identifier that is safe for use in
+ * both URI schemes and URI authorities, and is collision-free.
+ *
+ * Three tiers:
+ * 1. Purely alphanumeric addresses are returned as-is.
+ * 2. "Normal" addresses containing only `[a-zA-Z0-9.:-]` get colons
+ *    replaced with `__` (double underscore) for human readability.
+ *    Addresses containing `_` skip this tier to keep the encoding
+ *    collision-free (`__` can only appear from colon replacement).
+ * 3. Everything else is url-safe base64-encoded with a `b64-` prefix.
+ */
+export declare function agentHostAuthority(address: string): string;
+/**
+ * Label formatter for {@link AGENT_HOST_SCHEME} URIs. Strips the two
+ * leading path segments (`/scheme/authority`) to display the original
+ * file path.
+ */
+export declare const AGENT_HOST_LABEL_FORMATTER: ResourceLabelFormatter;

package/vscode/src/vs/platform/agentHost/common/agentHostUri.js

@@ -0,0 +1,73 @@
+
+import { encodeBase64, VSBuffer } from '../../../base/common/buffer.js';
+import { Schemas } from '../../../base/common/network.js';
+import { URI } from '../../../base/common/uri.js';
+
+const AGENT_HOST_SCHEME = "vscode-agent-host";
+function toAgentHostUri(originalUri, connectionAuthority) {
+    if (connectionAuthority === "local" && originalUri.scheme === Schemas.file) {
+        return originalUri;
+    }
+    const originalAuthority = originalUri.authority || "";
+    return ( URI.from({
+        scheme: AGENT_HOST_SCHEME,
+        authority: connectionAuthority,
+        path: `/${originalUri.scheme}/${originalAuthority || "-"}${originalUri.path}`
+    }));
+}
+function fromAgentHostUri(agentHostUri) {
+    const path = agentHostUri.path;
+    const schemeEnd = path.indexOf("/", 1);
+    if (schemeEnd === -1) {
+        return ( URI.from({
+            scheme: "file",
+            path
+        }));
+    }
+    const originalScheme = path.substring(1, schemeEnd);
+    const authorityEnd = path.indexOf("/", schemeEnd + 1);
+    if (authorityEnd === -1) {
+        const originalAuthority = path.substring(schemeEnd + 1);
+        return ( URI.from({
+            scheme: originalScheme,
+            authority: originalAuthority,
+            path: "/"
+        }));
+    }
+    let originalAuthority = path.substring(schemeEnd + 1, authorityEnd);
+    if (originalAuthority === "-") {
+        originalAuthority = "";
+    }
+    const originalPath = path.substring(authorityEnd);
+    return ( URI.from({
+        scheme: originalScheme,
+        authority: originalAuthority || undefined,
+        path: originalPath
+    }));
+}
+function normalizeRemoteAgentHostAddress(address) {
+    if (address.startsWith("ws://")) {
+        return address.slice("ws://".length);
+    }
+    return address;
+}
+function agentHostAuthority(address) {
+    const normalized = normalizeRemoteAgentHostAddress(address);
+    if (/^[a-zA-Z0-9]+$/.test(normalized)) {
+        return normalized;
+    }
+    if (/^[a-zA-Z0-9.:\-]+$/.test(normalized)) {
+        return normalized.replaceAll(":", "__");
+    }
+    return "b64-" + encodeBase64(VSBuffer.fromString(normalized), false, true);
+}
+const AGENT_HOST_LABEL_FORMATTER = {
+    scheme: AGENT_HOST_SCHEME,
+    formatting: {
+        label: "${path}",
+        separator: "/",
+        stripPathSegments: 2
+    }
+};
+
+export { AGENT_HOST_LABEL_FORMATTER, AGENT_HOST_SCHEME, agentHostAuthority, fromAgentHostUri, normalizeRemoteAgentHostAddress, toAgentHostUri };

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

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

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

@@ -0,0 +1,119 @@
+import { Event } from "../../../base/common/event.js";
+import { IObservable } from "../../../base/common/observable.js";
+import { URI } from "../../../base/common/uri.js";
+import { IAuthenticateParams, IAuthenticateResult, IAgentSessionMetadata, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, type IAgentConnection, type IAgentHostSocketInfo } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { IResolveSessionConfigResult, ISessionConfigCompletionsResult, ICreateTerminalParams } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { IActionEnvelope, INotification, ISessionAction, ITerminalAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
+import { IResourceListResult, IResourceReadResult, IResourceWriteParams, IResourceWriteResult, IResourceCopyParams, IResourceCopyResult, IResourceDeleteParams, IResourceDeleteResult, IResourceMoveParams, IResourceMoveResult } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionProtocol";
+import { ISnapshot as IStateSnapshot } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+export declare const IAgentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentService>;
+/**
+* Service contract for communicating with the agent host process. Methods here
+* are proxied across MessagePort via `ProxyChannel`.
+*
+* State is synchronized via the subscribe/unsubscribe/dispatchAction protocol.
+* Clients observe root state (agents, models) and session state via subscriptions,
+* and mutate state by dispatching actions (e.g. session/turnStarted, session/turnCancelled).
+*/
+export interface IAgentService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Authenticate for a protected resource on the server.
+    * The {@link IAuthenticateParams.resource} must match a resource from
+    * the agent's protectedResources in root state. Analogous to RFC 6750
+    * bearer token delivery.
+    */
+    authenticate(params: IAuthenticateParams): Promise<IAuthenticateResult>;
+    /** List all available sessions from the Copilot CLI. */
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    /** Create a new session. Returns the session URI. */
+    createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    /** Resolve the dynamic configuration schema for creating a session. */
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
+    /** Return dynamic completions for a session configuration property. */
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
+    /** Dispose a session in the agent host, freeing SDK resources. */
+    disposeSession(session: URI): Promise<void>;
+    /** Create a new terminal on the agent host. */
+    createTerminal(params: ICreateTerminalParams): Promise<void>;
+    /** Dispose a terminal and kill its process if still running. */
+    disposeTerminal(terminal: URI): Promise<void>;
+    /** Gracefully shut down all sessions and the underlying client. */
+    shutdown(): Promise<void>;
+    /**
+    * Subscribe to state at the given URI. Returns a snapshot of the current
+    * state and the serverSeq at snapshot time. Subsequent actions for this
+    * resource arrive via {@link onDidAction}.
+    */
+    subscribe(resource: URI): Promise<IStateSnapshot>;
+    /** Unsubscribe from state updates for the given URI. */
+    unsubscribe(resource: URI): void;
+    /**
+    * Fires when the server applies an action to subscribable state.
+    * Clients use this alongside {@link subscribe} to keep their local
+    * state in sync.
+    */
+    readonly onDidAction: Event<IActionEnvelope>;
+    /**
+    * Fires when the server broadcasts an ephemeral notification
+    * (e.g. sessionAdded, sessionRemoved).
+    */
+    readonly onDidNotification: Event<INotification>;
+    /**
+    * Dispatch a client-originated action to the server. The server applies
+    * it to state, triggers side effects, and echoes it back via
+    * {@link onDidAction} with the client's origin for reconciliation.
+    */
+    dispatchAction(action: ISessionAction | ITerminalAction, clientId: string, clientSeq: number): void;
+    /**
+    * List the contents of a directory on the agent host's filesystem.
+    * Used by the client to drive a remote folder picker before session creation.
+    */
+    resourceList(uri: URI): Promise<IResourceListResult>;
+    /**
+    * Read stored content by URI from the agent host (e.g. file edit snapshots,
+    * or reading files from the remote filesystem).
+    */
+    resourceRead(uri: URI): Promise<IResourceReadResult>;
+    /**
+    * Write content to a file on the agent host's filesystem.
+    * Used for undo/redo operations on file edits.
+    */
+    resourceWrite(params: IResourceWriteParams): Promise<IResourceWriteResult>;
+    /**
+    * Copy a resource from one URI to another on the agent host's filesystem.
+    */
+    resourceCopy(params: IResourceCopyParams): Promise<IResourceCopyResult>;
+    /**
+    * Delete a resource at a URI on the agent host's filesystem.
+    */
+    resourceDelete(params: IResourceDeleteParams): Promise<IResourceDeleteResult>;
+    /**
+    * Move (rename) a resource from one URI to another on the agent host's filesystem.
+    */
+    resourceMove(params: IResourceMoveParams): Promise<IResourceMoveResult>;
+}
+export declare const IAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostService>;
+/**
+* The local wrapper around the agent host process (manages lifecycle, restart,
+* exposes the proxied service). Consumed by the main process and workbench.
+*/
+export interface IAgentHostService extends IAgentConnection {
+    readonly onAgentHostExit: Event<number>;
+    readonly onAgentHostStart: Event<void>;
+    /**
+    * `true` while we are in the middle of authenticating against the local
+    * agent host (resolving tokens for any advertised `protectedResources` and
+    * pushing them via {@link authenticate}). Defaults to `true` at startup so
+    * that the period before the first auth pass is also covered.
+    *
+    * Producers (the workbench `AgentHostContribution`) flip this around their
+    * auth pass; consumers (e.g. the local sessions provider) read it to mark
+    * sessions as still loading.
+    */
+    readonly authenticationPending: IObservable<boolean>;
+    /** Update {@link authenticationPending}. Internal — only the auth driver should call this. */
+    setAuthenticationPending(pending: boolean): void;
+    restartAgentHost(): Promise<void>;
+    startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+}

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

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