@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.0-next.0

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetectionCapability.d.ts

@@ -0,0 +1,32 @@
+import { IMarker } from 'xterm-headless';
+
+interface ICurrentPartialCommand {
+    previousCommandMarker?: IMarker;
+    promptStartMarker?: IMarker;
+    commandStartMarker?: IMarker;
+    commandStartX?: number;
+    commandStartLineContent?: string;
+    commandRightPromptStartX?: number;
+    commandRightPromptEndX?: number;
+    commandLines?: IMarker;
+    commandExecutedMarker?: IMarker;
+    commandExecutedX?: number;
+    commandFinishedMarker?: IMarker;
+    currentContinuationMarker?: IMarker;
+    continuations?: {
+        marker: IMarker;
+        end: number;
+    }[];
+    command?: string;
+    /**
+     * Whether the command line is trusted via a nonce.
+     */
+    isTrusted?: boolean;
+    /**
+     * Something invalidated the command before it finished, this will prevent the onCommandFinished
+     * event from firing.
+     */
+    isInvalid?: boolean;
+}
+
+export type { ICurrentPartialCommand };

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetectionCapability.js

@@ -2,7 +2,8 @@ import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
 import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
 import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-class CommandDetectionCapability {
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class CommandDetectionCapability extends Disposable {
     get commands() { return this._commands; }
     get executingCommand() { return this._currentCommand.command; }
     get executingCommandObject() {
@@ -11,6 +12,9 @@ class CommandDetectionCapability {
         }
         return undefined;
     }
+    get currentCommand() {
+        return this._currentCommand;
+    }
     get cwd() { return this._cwd; }
     get _isInputting() {
         return !!(this._currentCommand.commandStartMarker && !this._currentCommand.commandExecutedMarker);
@@ -29,6 +33,7 @@ class CommandDetectionCapability {
         return true;
     }
     constructor(_terminal, _logService) {
+        super();
         this._terminal = _terminal;
         this._logService = _logService;
         this.type = 2 ;
@@ -37,24 +42,24 @@ class CommandDetectionCapability {
         this._isWindowsPty = false;
         this._commandMarkers = [];
         this.__isCommandStorageDisabled = false;
-        this._onCommandStarted = ( new Emitter());
+        this._onCommandStarted = this._register(( new Emitter()));
         this.onCommandStarted = this._onCommandStarted.event;
-        this._onBeforeCommandFinished = ( new Emitter());
+        this._onBeforeCommandFinished = this._register(( new Emitter()));
         this.onBeforeCommandFinished = this._onBeforeCommandFinished.event;
-        this._onCommandFinished = ( new Emitter());
+        this._onCommandFinished = this._register(( new Emitter()));
         this.onCommandFinished = this._onCommandFinished.event;
-        this._onCommandExecuted = ( new Emitter());
+        this._onCommandExecuted = this._register(( new Emitter()));
         this.onCommandExecuted = this._onCommandExecuted.event;
-        this._onCommandInvalidated = ( new Emitter());
+        this._onCommandInvalidated = this._register(( new Emitter()));
         this.onCommandInvalidated = this._onCommandInvalidated.event;
-        this._onCurrentCommandInvalidated = ( new Emitter());
+        this._onCurrentCommandInvalidated = this._register(( new Emitter()));
         this.onCurrentCommandInvalidated = this._onCurrentCommandInvalidated.event;
         this._dimensions = {
             cols: this._terminal.cols,
             rows: this._terminal.rows
         };
-        this._terminal.onResize(e => this._handleResize(e));
-        this._terminal.onCursorMove(() => this._handleCursorMove());
+        this._register(this._terminal.onResize(e => this._handleResize(e)));
+        this._register(this._terminal.onCursorMove(() => this._handleCursorMove()));
         this._setupClearListeners();
     }
     _handleResize(e) {

package/vscode/src/vs/platform/terminal/common/capabilities/cwdDetectionCapability.js

@@ -1,10 +1,12 @@
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-class CwdDetectionCapability {
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class CwdDetectionCapability extends Disposable {
     constructor() {
+        super(...arguments);
         this.type = 0 ;
         this._cwd = '';
         this._cwds = ( new Map());
-        this._onDidChangeCwd = ( new Emitter());
+        this._onDidChangeCwd = this._register(( new Emitter()));
         this.onDidChangeCwd = this._onDidChangeCwd.event;
     }
     get cwds() {

package/vscode/src/vs/platform/terminal/common/capabilities/terminalCapabilityStore.js

@@ -4,6 +4,10 @@ class TerminalCapabilityStore extends Disposable {
     constructor() {
         super(...arguments);
         this._map = ( new Map());
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
         this._onDidRemoveCapability = this._register(( new Emitter()));
         this.onDidRemoveCapability = this._onDidRemoveCapability.event;
         this._onDidAddCapability = this._register(( new Emitter()));
@@ -14,17 +18,20 @@ class TerminalCapabilityStore extends Disposable {
     }
     add(capability, impl) {
         this._map.set(capability, impl);
-        this._onDidAddCapability.fire(capability);
+        this._onDidAddCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
     }
     get(capability) {
         return this._map.get(capability);
     }
     remove(capability) {
-        if (!( this._map.has(capability))) {
+        const impl = this._map.get(capability);
+        if (!impl) {
             return;
         }
         this._map.delete(capability);
-        this._onDidRemoveCapability.fire(capability);
+        this._onDidRemoveCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
     }
     has(capability) {
         return ( this._map.has(capability));
@@ -34,6 +41,10 @@ class TerminalCapabilityStoreMultiplexer extends Disposable {
     constructor() {
         super(...arguments);
         this._stores = [];
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
         this._onDidRemoveCapability = this._register(( new Emitter()));
         this.onDidRemoveCapability = this._onDidRemoveCapability.event;
         this._onDidAddCapability = this._register(( new Emitter()));
@@ -71,9 +82,12 @@ class TerminalCapabilityStoreMultiplexer extends Disposable {
     add(store) {
         this._stores.push(store);
         for (const capability of store.items) {
-            this._onDidAddCapability.fire(capability);
+            this._onDidAddCapabilityType.fire(capability);
+            this._onDidAddCapability.fire({ id: capability, capability: store.get(capability) });
         }
+        store.onDidAddCapabilityType(e => this._onDidAddCapabilityType.fire(e));
         store.onDidAddCapability(e => this._onDidAddCapability.fire(e));
+        store.onDidRemoveCapabilityType(e => this._onDidRemoveCapabilityType.fire(e));
         store.onDidRemoveCapability(e => this._onDidRemoveCapability.fire(e));
     }
 }

package/vscode/src/vs/platform/terminal/common/environmentVariable.d.ts

@@ -72,4 +72,4 @@ interface IMergedEnvironmentVariableCollection {
     diff(other: IMergedEnvironmentVariableCollection, scope: EnvironmentVariableScope | undefined): IMergedEnvironmentVariableCollectionDiff | undefined;
 }
 
-export { EnvironmentVariableMutatorType, EnvironmentVariableScope, IEnvironmentVariableCollection, IEnvironmentVariableCollectionDescription, IEnvironmentVariableMutator, IEnvironmentVariableMutatorOptions, IExtensionOwnedEnvironmentVariableMutator, IMergedEnvironmentVariableCollection, IMergedEnvironmentVariableCollectionDiff, ISerializableEnvironmentDescriptionMap, ISerializableEnvironmentVariableCollection, ISerializableEnvironmentVariableCollections };
+export { EnvironmentVariableMutatorType, type EnvironmentVariableScope, type IEnvironmentVariableCollection, type IEnvironmentVariableCollectionDescription, type IEnvironmentVariableMutator, type IEnvironmentVariableMutatorOptions, type IExtensionOwnedEnvironmentVariableMutator, type IMergedEnvironmentVariableCollection, type IMergedEnvironmentVariableCollectionDiff, type ISerializableEnvironmentDescriptionMap, type ISerializableEnvironmentVariableCollection, type ISerializableEnvironmentVariableCollections };

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

@@ -612,4 +612,4 @@ interface ITerminalLogService extends ILogService {
     readonly _logBrand: undefined;
 }
 
-export { IBaseUnresolvedTerminalProfile, ICreateContributedTerminalProfileOptions, IExtensionTerminalProfile, IFixedTerminalDimensions, IProcessDataEvent, IProcessProperty, IProcessPropertyMap, IProcessReadyEvent, IProcessReadyWindowsPty, IPtyHostAttachTarget, IPtyHostLatencyMeasurement, IRawTerminalInstanceLayoutInfo, IRawTerminalTabLayoutInfo, IRawTerminalsLayoutInfo, IReconnectionProperties, IShellIntegration, IShellLaunchConfig, IShellLaunchConfigDto, ITerminalBackend, ITerminalChildProcess, ITerminalDimensions, ITerminalDimensionsOverride, ITerminalEnvironment, ITerminalExecutable, ITerminalLaunchError, ITerminalLogService, ITerminalOutputMatch, ITerminalOutputMatcher, ITerminalProcessOptions, ITerminalProfile, ITerminalProfileContribution, ITerminalProfileObject, ITerminalProfileSource, ITerminalTabLayoutInfoById, ITerminalUnsafePath, ITerminalsLayoutInfo, ITerminalsLayoutInfoById, PosixShellType, ProcessPropertyType, ProfileSource, ShellIntegrationStatus, TerminalExitReason, TerminalIcon, TerminalLocation, TerminalLocationString, TerminalShellType, TerminalType, TitleEventSource, WaitOnExitValue, WindowsShellType };
+export { type IBaseUnresolvedTerminalProfile, type ICreateContributedTerminalProfileOptions, type IExtensionTerminalProfile, type IFixedTerminalDimensions, type IProcessDataEvent, type IProcessProperty, type IProcessPropertyMap, type IProcessReadyEvent, type IProcessReadyWindowsPty, type IPtyHostAttachTarget, type IPtyHostLatencyMeasurement, type IRawTerminalInstanceLayoutInfo, type IRawTerminalTabLayoutInfo, type IRawTerminalsLayoutInfo, type IReconnectionProperties, type IShellIntegration, type IShellLaunchConfig, type IShellLaunchConfigDto, type ITerminalBackend, type ITerminalChildProcess, type ITerminalDimensions, type ITerminalDimensionsOverride, type ITerminalEnvironment, type ITerminalExecutable, type ITerminalLaunchError, ITerminalLogService, type ITerminalOutputMatch, type ITerminalOutputMatcher, type ITerminalProcessOptions, type ITerminalProfile, type ITerminalProfileContribution, type ITerminalProfileObject, type ITerminalProfileSource, type ITerminalTabLayoutInfoById, type ITerminalUnsafePath, type ITerminalsLayoutInfo, type ITerminalsLayoutInfoById, PosixShellType, ProcessPropertyType, ProfileSource, ShellIntegrationStatus, TerminalExitReason, type TerminalIcon, TerminalLocation, TerminalLocationString, type TerminalShellType, type TerminalType, TitleEventSource, type WaitOnExitValue, WindowsShellType };

package/vscode/src/vs/platform/terminal/common/terminalProcess.d.ts

@@ -23,4 +23,4 @@ interface IProcessDetails {
     shellIntegrationNonce: string;
 }
 
-export { IProcessDetails };
+export type { IProcessDetails };

package/vscode/src/vs/platform/terminal/common/xterm/shellIntegrationAddon.js

@@ -40,6 +40,9 @@ class ShellIntegrationAddon extends Disposable {
         this._register(xterm.parser.registerOscHandler(9 , data => this._doHandleSetWindowsFriendlyCwd(data)));
         this._ensureCapabilitiesOrAddFailureTelemetry();
     }
+    getMarkerId(terminal, vscodeMarkerId) {
+        this._createOrGetBufferMarkDetection(terminal).getMark(vscodeMarkerId);
+    }
     _handleFinalTermSequence(data) {
         const didHandle = this._doHandleFinalTermSequence(data);
         if (this._status === 0 ) {
@@ -260,7 +263,7 @@ class ShellIntegrationAddon extends Disposable {
     _createOrGetCwdDetection() {
         let cwdDetection = this.capabilities.get(0 );
         if (!cwdDetection) {
-            cwdDetection = ( new CwdDetectionCapability());
+            cwdDetection = this._register(( new CwdDetectionCapability()));
             this.capabilities.add(0 , cwdDetection);
         }
         return cwdDetection;
@@ -268,7 +271,7 @@ class ShellIntegrationAddon extends Disposable {
     _createOrGetCommandDetection(terminal) {
         let commandDetection = this.capabilities.get(2 );
         if (!commandDetection) {
-            commandDetection = ( new CommandDetectionCapability(terminal, this._logService));
+            commandDetection = this._register(( new CommandDetectionCapability(terminal, this._logService)));
             this.capabilities.add(2 , commandDetection);
         }
         return commandDetection;
@@ -276,7 +279,7 @@ class ShellIntegrationAddon extends Disposable {
     _createOrGetBufferMarkDetection(terminal) {
         let bufferMarkDetection = this.capabilities.get(4 );
         if (!bufferMarkDetection) {
-            bufferMarkDetection = ( new BufferMarkCapability(terminal));
+            bufferMarkDetection = this._register(( new BufferMarkCapability(terminal)));
             this.capabilities.add(4 , bufferMarkDetection);
         }
         return bufferMarkDetection;

package/vscode/src/vs/platform/theme/common/colorRegistry.d.ts

@@ -53,4 +53,4 @@ interface ColorDefaults {
 type ColorValue = Color | string | ColorIdentifier | ColorTransform;
 declare function registerColor(id: string, defaults: ColorDefaults | null, description: string, needsTransparency?: boolean, deprecationMessage?: string): ColorIdentifier;
 
-export { ColorDefaults, ColorIdentifier, ColorTransform, ColorTransformType, ColorValue, registerColor };
+export { type ColorDefaults, type ColorIdentifier, type ColorTransform, ColorTransformType, type ColorValue, registerColor };

package/vscode/src/vs/platform/theme/common/iconRegistry.d.ts

@@ -79,4 +79,4 @@ interface IIconRegistry {
     getIconFont(id: string): IconFontDefinition | undefined;
 }
 
-export { IIconRegistry, IconContribution, IconDefaults, IconDefinition, IconFontContribution, IconFontDefinition, IconFontSource };
+export { type IIconRegistry, IconContribution, type IconDefaults, type IconDefinition, type IconFontContribution, IconFontDefinition, type IconFontSource };

package/vscode/src/vs/platform/theme/common/themeService.d.ts

@@ -77,4 +77,4 @@ declare class Themable extends Disposable {
     protected getColor(id: string, modify?: (color: Color, theme: IColorTheme) => Color): string | null;
 }
 
-export { IColorTheme, IFileIconTheme, IProductIconTheme, IThemeService, ITokenStyle, Themable };
+export { type IColorTheme, type IFileIconTheme, type IProductIconTheme, IThemeService, type ITokenStyle, Themable };

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

@@ -40,4 +40,4 @@ interface ProvidedPortAttributes {
     autoForwardAction: ProvidedOnAutoForward;
 }
 
-export { ProvidedOnAutoForward, ProvidedPortAttributes, TunnelCreationOptions, TunnelOptions, TunnelPrivacyId, TunnelProviderFeatures };
+export { ProvidedOnAutoForward, type ProvidedPortAttributes, type TunnelCreationOptions, type TunnelOptions, TunnelPrivacyId, type TunnelProviderFeatures };

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

@@ -31,4 +31,4 @@ interface IUserDataProfile {
     readonly isTransient?: boolean;
 }
 
-export { IUserDataProfile, ProfileResourceType, UseDefaultProfileFlags };
+export { type IUserDataProfile, ProfileResourceType, type UseDefaultProfileFlags };

package/vscode/src/vs/platform/webview/common/webviewPortMapping.js

@@ -48,7 +48,11 @@ class WebviewPortMappingManager {
         if (existing) {
             return existing;
         }
-        const tunnel = await this.tunnelService.openTunnel({ getAddress: async () => remoteAuthority }, undefined, remotePort);
+        const tunnelOrError = await this.tunnelService.openTunnel({ getAddress: async () => remoteAuthority }, undefined, remotePort);
+        let tunnel;
+        if (typeof tunnelOrError === 'string') {
+            tunnel = undefined;
+        }
         if (tunnel) {
             this._tunnels.set(remotePort, tunnel);
         }

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

@@ -76,4 +76,4 @@ interface IPathData<T = IEditorOptions> {
     readonly openOnlyIfExists?: boolean;
 }
 
-export { IBaseOpenWindowsOptions, IBaseWindowOpenable, IFileToOpen, IFolderToOpen, IOpenEmptyWindowOptions, IOpenWindowOptions, IPath, IPathData, IWindowOpenable, IWorkspaceToOpen };
+export type { IBaseOpenWindowsOptions, IBaseWindowOpenable, IFileToOpen, IFolderToOpen, IOpenEmptyWindowOptions, IOpenWindowOptions, IPath, IPathData, IWindowOpenable, IWorkspaceToOpen };

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

@@ -189,4 +189,4 @@ declare class WorkspaceFolder implements IWorkspaceFolder {
     toJSON(): IWorkspaceFolderData;
 }
 
-export { IAnyWorkspaceIdentifier, IBaseWorkspaceIdentifier, IEmptyWorkspaceIdentifier, IRawFileWorkspaceFolder, IRawUriWorkspaceFolder, ISingleFolderWorkspaceIdentifier, IWorkspace, IWorkspaceContextService, IWorkspaceFolder, IWorkspaceFolderData, IWorkspaceFoldersChangeEvent, IWorkspaceFoldersWillChangeEvent, IWorkspaceIdentifier, WorkbenchState, Workspace, WorkspaceFolder };
+export { type IAnyWorkspaceIdentifier, type IBaseWorkspaceIdentifier, type IEmptyWorkspaceIdentifier, type IRawFileWorkspaceFolder, type IRawUriWorkspaceFolder, type ISingleFolderWorkspaceIdentifier, type IWorkspace, IWorkspaceContextService, type IWorkspaceFolder, type IWorkspaceFolderData, type IWorkspaceFoldersChangeEvent, type IWorkspaceFoldersWillChangeEvent, type IWorkspaceIdentifier, WorkbenchState, Workspace, WorkspaceFolder };

package/vscode/src/vs/platform/workspace/common/workspaceTrust.d.ts

@@ -29,4 +29,4 @@ interface IWorkspaceTrustRequestService {
     requestWorkspaceTrustOnStartup(): void;
 }
 
-export { IWorkspaceTrustRequestService, WorkspaceTrustRequestButton, WorkspaceTrustRequestOptions, WorkspaceTrustUriResponse };
+export { IWorkspaceTrustRequestService, type WorkspaceTrustRequestButton, type WorkspaceTrustRequestOptions, WorkspaceTrustUriResponse };

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

@@ -5,4 +5,4 @@ interface IWorkspaceFolderCreationData {
     readonly name?: string;
 }
 
-export { IWorkspaceFolderCreationData };
+export type { IWorkspaceFolderCreationData };

package/vscode/src/vs/workbench/api/browser/mainThreadAiEmbeddingVector.js

@@ -0,0 +1,29 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IAiEmbeddingVectorService } from '../../services/aiEmbeddingVector/common/aiEmbeddingVectorService.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadAiEmbeddingVector = class MainThreadAiEmbeddingVector extends Disposable {
+    constructor(context, _AiEmbeddingVectorService) {
+        super();
+        this._AiEmbeddingVectorService = _AiEmbeddingVectorService;
+        this._registrations = this._register(( new DisposableMap()));
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiEmbeddingVector));
+    }
+    $registerAiEmbeddingVectorProvider(model, handle) {
+        const provider = {
+            provideAiEmbeddingVector: (strings, token) => {
+                return this._proxy.$provideAiEmbeddingVector(handle, strings, token);
+            },
+        };
+        this._registrations.set(handle, this._AiEmbeddingVectorService.registerAiEmbeddingVectorProvider(model, provider));
+    }
+    $unregisterAiEmbeddingVectorProvider(handle) {
+        this._registrations.deleteAndDispose(handle);
+    }
+};
+MainThreadAiEmbeddingVector = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadAiEmbeddingVector),
+    ( __param(1, IAiEmbeddingVectorService))
+], MainThreadAiEmbeddingVector);
+export { MainThreadAiEmbeddingVector };

package/vscode/src/vs/workbench/api/browser/mainThreadAiRelatedInformation.js

@@ -0,0 +1,33 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IAiRelatedInformationService } from '../../services/aiRelatedInformation/common/aiRelatedInformation.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadAiRelatedInformation = class MainThreadAiRelatedInformation extends Disposable {
+    constructor(context, _aiRelatedInformationService) {
+        super();
+        this._aiRelatedInformationService = _aiRelatedInformationService;
+        this._registrations = this._register(( new DisposableMap()));
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiRelatedInformation));
+    }
+    $getAiRelatedInformation(query, types) {
+        return this._aiRelatedInformationService.getRelatedInformation(query, types, CancellationToken.None);
+    }
+    $registerAiRelatedInformationProvider(handle, type) {
+        const provider = {
+            provideAiRelatedInformation: (query, token) => {
+                return this._proxy.$provideAiRelatedInformation(handle, query, token);
+            },
+        };
+        this._registrations.set(handle, this._aiRelatedInformationService.registerAiRelatedInformationProvider(type, provider));
+    }
+    $unregisterAiRelatedInformationProvider(handle) {
+        this._registrations.deleteAndDispose(handle);
+    }
+};
+MainThreadAiRelatedInformation = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadAiRelatedInformation),
+    ( __param(1, IAiRelatedInformationService))
+], MainThreadAiRelatedInformation);
+export { MainThreadAiRelatedInformation };

package/vscode/src/vs/workbench/api/browser/mainThreadChat.js

@@ -2,10 +2,12 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { IChatWidgetService } from '../../contrib/chat/browser/chat.js';
 import { IChatContributionService } from '../../contrib/chat/common/chatContributionService.js';
+import { isCompleteInteractiveProgressTreeData } from '../../contrib/chat/common/chatModel.js';
 import { IChatService } from '../../contrib/chat/common/chatService.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 let MainThreadChat = class MainThreadChat extends Disposable {
@@ -24,21 +26,6 @@ let MainThreadChat = class MainThreadChat extends Disposable {
             this._proxy.$onDidPerformUserAction(e);
         }));
     }
-    async $registerSlashCommandProvider(handle, chatProviderId) {
-        const unreg = this._chatService.registerSlashCommandProvider({
-            chatProviderId,
-            provideSlashCommands: async (token) => {
-                return this._proxy.$provideProviderSlashCommands(handle, token);
-            },
-            resolveSlashCommand: async (command, token) => {
-                return this._proxy.$resolveSlashCommand(handle, command, token);
-            }
-        });
-        this._providerRegistrations.set(handle, unreg);
-    }
-    async $unregisterSlashCommandProvider(handle) {
-        this._providerRegistrations.deleteAndDispose(handle);
-    }
     $transferChatSession(sessionId, toWorkspace) {
         const sessionIdStr = this._chatService.getSessionId(sessionId);
         if (!sessionIdStr) {
@@ -94,6 +81,7 @@ let MainThreadChat = class MainThreadChat extends Disposable {
                 try {
                     const requestDto = {
                         message: request.message,
+                        variables: request.variables
                     };
                     const dto = await this._proxy.$provideReply(handle, request.session.id, requestDto, token);
                     return {
@@ -132,10 +120,19 @@ let MainThreadChat = class MainThreadChat extends Disposable {
         else if (responsePartHandle) {
             const responsePartId = `${id}_${responsePartHandle}`;
             const deferredContentPromise = this._activeResponsePartPromises.get(responsePartId);
-            if (deferredContentPromise && 'content' in progress) {
+            if (deferredContentPromise && isCompleteInteractiveProgressTreeData(progress)) {
+                const withRevivedUris = revive(progress);
+                deferredContentPromise.complete(withRevivedUris);
+                this._activeResponsePartPromises.delete(responsePartId);
+            }
+            else if (deferredContentPromise && 'content' in progress) {
                 deferredContentPromise.complete(progress.content);
                 this._activeResponsePartPromises.delete(responsePartId);
             }
+            return;
+        }
+        if (isCompleteInteractiveProgressTreeData(progress)) {
+            return;
         }
         this._activeRequestProgressCallbacks.get(id)?.(progress);
     }

package/vscode/src/vs/workbench/api/browser/mainThreadChatProvider.js

@@ -0,0 +1,59 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IChatProviderService } from '../../contrib/chat/common/chatProvider.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadChatProvider = class MainThreadChatProvider {
+    constructor(extHostContext, _chatProviderService, _logService) {
+        this._chatProviderService = _chatProviderService;
+        this._logService = _logService;
+        this._providerRegistrations = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatProvider));
+    }
+    dispose() {
+        this._providerRegistrations.dispose();
+    }
+    $registerProvider(handle, identifier, metadata) {
+        const registration = this._chatProviderService.registerChatResponseProvider(identifier, {
+            metadata,
+            provideChatResponse: async (messages, options, progress, token) => {
+                const requestId = (Math.random() * 1e6) | 0;
+                this._pendingProgress.set(requestId, progress);
+                try {
+                    await this._proxy.$provideChatResponse(handle, requestId, messages, options, token);
+                }
+                finally {
+                    this._pendingProgress.delete(requestId);
+                }
+            }
+        });
+        this._providerRegistrations.set(handle, registration);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        this._pendingProgress.get(requestId)?.report(chunk);
+    }
+    $unregisterProvider(handle) {
+        this._providerRegistrations.deleteAndDispose(handle);
+    }
+    async $fetchResponse(extension, providerId, requestId, messages, options, token) {
+        this._logService.debug('[CHAT] extension request STARTED', extension.value, requestId);
+        const task = this._chatProviderService.fetchChatResponse(providerId, messages, options, ( new Progress(value => {
+            this._proxy.$handleResponseFragment(requestId, value);
+        })), token);
+        task.catch(err => {
+            this._logService.error('[CHAT] extension request ERRORED', err, extension.value, requestId);
+        }).finally(() => {
+            this._logService.debug('[CHAT] extension request DONE', extension.value, requestId);
+        });
+        return task;
+    }
+};
+MainThreadChatProvider = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatProvider),
+    ( __param(1, IChatProviderService)),
+    ( __param(2, ILogService))
+], MainThreadChatProvider);
+export { MainThreadChatProvider };

package/vscode/src/vs/workbench/api/browser/mainThreadChatSlashCommands.js

@@ -0,0 +1,46 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IChatSlashCommandService } from '../../contrib/chat/common/chatSlashCommands.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
+    constructor(extHostContext, _chatSlashCommandService) {
+        this._chatSlashCommandService = _chatSlashCommandService;
+        this._commands = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatSlashCommands));
+    }
+    dispose() {
+        this._commands.clearAndDisposeAll();
+    }
+    $registerCommand(handle, name, detail) {
+        if (!this._chatSlashCommandService.hasCommand(name)) {
+            this._chatSlashCommandService.registerSlashData({
+                command: name,
+                detail
+            });
+        }
+        const d = this._chatSlashCommandService.registerSlashCallback(name, async (prompt, progress, history, token) => {
+            const requestId = Math.random();
+            this._pendingProgress.set(requestId, progress);
+            try {
+                await this._proxy.$executeCommand(handle, requestId, prompt, { history }, token);
+            }
+            finally {
+                this._pendingProgress.delete(requestId);
+            }
+        });
+        this._commands.set(handle, d);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        this._pendingProgress.get(requestId)?.report(chunk);
+    }
+    $unregisterCommand(handle) {
+        this._commands.deleteAndDispose(handle);
+    }
+};
+MainThreadChatSlashCommands = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatSlashCommands),
+    ( __param(1, IChatSlashCommandService))
+], MainThreadChatSlashCommands);
+export { MainThreadChatSlashCommands };

package/vscode/src/vs/workbench/api/browser/mainThreadChatVariables.js

@@ -0,0 +1,29 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { IChatVariablesService } from '../../contrib/chat/common/chatVariables.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadChatSlashCommands = class MainThreadChatSlashCommands {
+    constructor(extHostContext, _chatVariablesService) {
+        this._chatVariablesService = _chatVariablesService;
+        this._variables = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatVariables));
+    }
+    dispose() {
+        this._variables.clearAndDisposeAll();
+    }
+    $registerVariable(handle, data) {
+        const registration = this._chatVariablesService.registerVariable(data, (messageText, _arg, _model, token) => {
+            return this._proxy.$resolveVariable(handle, messageText, token);
+        });
+        this._variables.set(handle, registration);
+    }
+    $unregisterVariable(handle) {
+        this._variables.deleteAndDispose(handle);
+    }
+};
+MainThreadChatSlashCommands = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatVariables),
+    ( __param(1, IChatVariablesService))
+], MainThreadChatSlashCommands);
+export { MainThreadChatSlashCommands };

package/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.js

@@ -35,6 +35,7 @@ import { NO_TYPE_ID } from '../../services/workingCopy/common/workingCopy.js';
 import { IWorkingCopyFileService } from '../../services/workingCopy/common/workingCopyFileService.js';
 import { IWorkingCopyService } from '../../services/workingCopy/common/workingCopyService.js';
 import { IFileDialogService } from '../../../platform/dialogs/common/dialogs.js';
+var MainThreadCustomEditorModel_1;
 let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
     constructor(context, mainThreadWebview, mainThreadWebviewPanels, extensionService, storageService, workingCopyService, workingCopyFileService, _customEditorService, _editorGroupService, _editorService, _instantiationService, _webviewWorkbenchService) {
         super();
@@ -247,7 +248,7 @@ var HotExitState;
     }
     HotExitState.Pending = Pending;
 })(HotExitState || (HotExitState = {}))));
-let MainThreadCustomEditorModel = class MainThreadCustomEditorModel extends ResourceWorkingCopy {
+let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThreadCustomEditorModel extends ResourceWorkingCopy {
     static async create(instantiationService, proxy, viewType, resource, options, getEditors, cancellation) {
         const editors = getEditors();
         let untitledDocumentData;
@@ -255,10 +256,10 @@ let MainThreadCustomEditorModel = class MainThreadCustomEditorModel extends Reso
             untitledDocumentData = editors[0].untitledDocumentData;
         }
         const { editable } = await proxy.$createCustomDocument(resource, viewType, options.backupId, untitledDocumentData, cancellation);
-        return instantiationService.createInstance(MainThreadCustomEditorModel, proxy, viewType, resource, !!options.backupId, editable, !!untitledDocumentData, getEditors);
+        return instantiationService.createInstance(MainThreadCustomEditorModel_1, proxy, viewType, resource, !!options.backupId, editable, !!untitledDocumentData, getEditors);
     }
     constructor(_proxy, _viewType, _editorResource, fromBackup, _editable, startDirty, _getEditors, _fileDialogService, fileService, _labelService, _undoService, _environmentService, workingCopyService, _pathService, extensionService) {
-        super(MainThreadCustomEditorModel.toWorkingCopyResource(_viewType, _editorResource), fileService);
+        super(MainThreadCustomEditorModel_1.toWorkingCopyResource(_viewType, _editorResource), fileService);
         this._proxy = _proxy;
         this._viewType = _viewType;
         this._editorResource = _editorResource;
@@ -555,7 +556,7 @@ let MainThreadCustomEditorModel = class MainThreadCustomEditorModel extends Reso
         throw new Error(`Cannot back up in this state: ${errorMessage}`);
     }
 };
-MainThreadCustomEditorModel = ( (__decorate([
+MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = ( (__decorate([
     ( (__param(7, IFileDialogService))),
     ( (__param(8, IFileService))),
     ( (__param(9, ILabelService))),

package/vscode/src/vs/workbench/api/browser/mainThreadEditor.js

@@ -5,7 +5,6 @@ import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
 import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
 import { TextEditorRevealType } from '../common/extHost.protocol.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { EditorState } from 'monaco-editor/esm/vs/editor/contrib/editorState/browser/editorState.js';
 import { SnippetParser } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
@@ -83,7 +82,7 @@ class MainThreadTextEditorProperties {
         if (!oldProps || !MainThreadTextEditorProperties._selectionsEqual(oldProps.selections, this.selections)) {
             delta.selections = {
                 selections: this.selections,
-                source: withNullAsUndefined(selectionChangeSource)
+                source: selectionChangeSource ?? undefined,
             };
         }
         if (!oldProps || !MainThreadTextEditorProperties._optionsEqual(oldProps.options, this.options)) {