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

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

@@ -1,5 +1,6 @@
 import { Event } from '../../../../base/common/event.js';
 import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { ICurrentPartialCommand } from './commandDetectionCapability.js';
 import { ITerminalOutputMatcher, ITerminalOutputMatch } from '../terminal.js';
 
 interface IEvent<T, U = void> {
@@ -66,14 +67,26 @@ interface ITerminalCapabilityStore {
      * An iterable of all capabilities in the store.
      */
     readonly items: IterableIterator<TerminalCapability>;
+    /**
+     * Fired when a capability is added. The event data for this is only the
+     * {@link TerminalCapability} type, use {@link onDidAddCapability} to access the actual
+     * capability.
+     */
+    readonly onDidAddCapabilityType: Event<TerminalCapability>;
+    /**
+     * Fired when a capability is removed. The event data for this is only the
+     * {@link TerminalCapability} type, use {@link onDidAddCapability} to access the actual
+     * capability.
+     */
+    readonly onDidRemoveCapabilityType: Event<TerminalCapability>;
     /**
      * Fired when a capability is added.
      */
-    readonly onDidAddCapability: Event<TerminalCapability>;
+    readonly onDidAddCapability: Event<TerminalCapabilityChangeEvent<any>>;
     /**
      * Fired when a capability is removed.
      */
-    readonly onDidRemoveCapability: Event<TerminalCapability>;
+    readonly onDidRemoveCapability: Event<TerminalCapabilityChangeEvent<any>>;
     /**
      * Gets whether the capability exists in the store.
      */
@@ -83,6 +96,10 @@ interface ITerminalCapabilityStore {
      */
     get<T extends TerminalCapability>(capability: T): ITerminalCapabilityImplMap[T] | undefined;
 }
+interface TerminalCapabilityChangeEvent<T extends TerminalCapability> {
+    id: T;
+    capability: ITerminalCapabilityImplMap[T];
+}
 /**
  * Maps capability types to their implementation, enabling strongly typed fetching of
  * implementations.
@@ -128,6 +145,7 @@ interface ICommandDetectionCapability {
      * the state cannot reliably be detected the fallback of undefined will be used.
      */
     readonly hasInput: boolean | undefined;
+    readonly currentCommand: ICurrentPartialCommand | undefined;
     readonly onCommandStarted: Event<ITerminalCommand>;
     readonly onCommandFinished: Event<ITerminalCommand>;
     readonly onCommandExecuted: Event<void>;
@@ -238,4 +256,4 @@ interface ISerializedCommandDetectionCapability {
     commands: ISerializedTerminalCommand[];
 }
 
-export { CommandInvalidationReason, IBufferMarkCapability, ICommandDetectionCapability, ICommandInvalidationRequest, ICwdDetectionCapability, IHandleCommandOptions, IMarkProperties, IMarker, INaiveCwdDetectionCapability, IPartialCommandDetectionCapability, ISerializedCommandDetectionCapability, ISerializedTerminalCommand, ITerminalCapabilityImplMap, ITerminalCapabilityStore, ITerminalCommand, IXtermMarker, TerminalCapability };
+export { CommandInvalidationReason, type IBufferMarkCapability, type ICommandDetectionCapability, type ICommandInvalidationRequest, type ICwdDetectionCapability, type IHandleCommandOptions, type IMarkProperties, type IMarker, type INaiveCwdDetectionCapability, type IPartialCommandDetectionCapability, type ISerializedCommandDetectionCapability, type ISerializedTerminalCommand, type ITerminalCapabilityImplMap, type ITerminalCapabilityStore, type ITerminalCommand, type IXtermMarker, TerminalCapability, type TerminalCapabilityChangeEvent };

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 };