@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/workbench/api/common/extHostChatAgents2.js

@@ -1,3 +1,4 @@
+import { coalesce } from '../../../base/common/arrays.js';
 import { raceCancellation, DeferredPromise } from '../../../base/common/async.js';
 import { CancellationToken } from '../../../base/common/cancellation.js';
 import { toErrorMessage } from '../../../base/common/errorMessage.js';
@@ -8,7 +9,7 @@ import { URI } from '../../../base/common/uri.js';
 import { localizeWithPath } from '../../../nls.js';
 import { Progress } from '../../../platform/progress/common/progress.js';
 import { MainContext } from './extHost.protocol.js';
-import { ChatVariable, ChatMessage, ChatResponseProgress, ChatAgentCompletionItem, ChatFollowup, MarkdownString } from './extHostTypeConverters.js';
+import { ChatAgentRequest, ChatResponseProgress, ChatAgentCompletionItem, ChatFollowup, MarkdownString } from './extHostTypeConverters.js';
 import { ChatAgentResultFeedbackKind, ThemeIcon } from './extHostTypes.js';
 import { InteractiveSessionVoteDirection } from '../../contrib/chat/common/chatService.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
@@ -29,8 +30,8 @@ class ExtHostChatAgents2 {
         this._proxy.$registerAgent(handle, name, {});
         return agent.apiAgent;
     }
-    async $invokeAgent(handle, sessionId, requestId, request, context, token) {
-        this._previousResultMap.delete(sessionId);
+    async $invokeAgent(handle, request, context, token) {
+        this._previousResultMap.delete(request.sessionId);
         const agent = this._agents.get(handle);
         if (!agent) {
             throw new Error(`[CHAT](${handle}) CANNOT invoke agent because the agent is not registered`);
@@ -43,7 +44,6 @@ class ExtHostChatAgents2 {
         }
         const commandExecution = ( new DeferredPromise());
         token.onCancellationRequested(() => commandExecution.complete());
-        setTimeout(() => commandExecution.complete(), 10 * 1000);
         this._extHostChatProvider.allowListExtensionWhile(agent.extension.identifier, commandExecution.p);
         const slashCommand = request.command
             ? await agent.validateSlashCommand(request.command)
@@ -51,11 +51,8 @@ class ExtHostChatAgents2 {
         const stopWatch = StopWatch.create(false);
         let firstProgress;
         try {
-            const task = agent.invoke({
-                prompt: request.message,
-                variables: ChatVariable.objectTo(request.variables),
-                slashCommand
-            }, { history: ( context.history.map(ChatMessage.to)) }, ( new Progress(progress => {
+            const convertedHistory = await this.prepareHistory(agent, request, context);
+            const task = agent.invoke(ChatAgentRequest.to(request, slashCommand), { history: convertedHistory }, ( new Progress(progress => {
                 throwIfDone();
                 if (typeof firstProgress === 'undefined' && 'content' in progress) {
                     firstProgress = stopWatch.elapsed();
@@ -65,39 +62,25 @@ class ExtHostChatAgents2 {
                     this._logService.error('Unknown progress type: ' + JSON.stringify(progress));
                     return;
                 }
-                if ('placeholder' in progress && 'resolvedContent' in progress) {
-                    const resolvedContent = Promise.all([this._proxy.$handleProgressChunk(requestId, convertedProgress), progress.resolvedContent]);
-                    raceCancellation(resolvedContent, token).then(res => {
-                        if (!res) {
-                            return;
-                        }
-                        const [progressHandle, progressContent] = res;
-                        const convertedContent = ChatResponseProgress.from(agent.extension, progressContent);
-                        if (!convertedContent) {
-                            this._logService.error('Unknown progress type: ' + JSON.stringify(progressContent));
-                            return;
-                        }
-                        this._proxy.$handleProgressChunk(requestId, convertedContent, progressHandle ?? undefined);
-                    });
-                }
+                if ('placeholder' in progress && 'resolvedContent' in progress) ;
                 else {
-                    this._proxy.$handleProgressChunk(requestId, convertedProgress);
+                    this._proxy.$handleProgressChunk(request.requestId, convertedProgress);
                 }
             })), token);
             return await raceCancellation(Promise.resolve(task).then((result) => {
                 if (result) {
-                    this._previousResultMap.set(sessionId, result);
-                    let sessionResults = this._resultsBySessionAndRequestId.get(sessionId);
+                    this._previousResultMap.set(request.sessionId, result);
+                    let sessionResults = this._resultsBySessionAndRequestId.get(request.sessionId);
                     if (!sessionResults) {
                         sessionResults = ( new Map());
-                        this._resultsBySessionAndRequestId.set(sessionId, sessionResults);
+                        this._resultsBySessionAndRequestId.set(request.sessionId, sessionResults);
                     }
-                    sessionResults.set(requestId, result);
+                    sessionResults.set(request.requestId, result);
                     const timings = { firstProgress: firstProgress, totalElapsed: stopWatch.elapsed() };
                     return { errorDetails: result.errorDetails, timings };
                 }
                 else {
-                    this._previousResultMap.delete(sessionId);
+                    this._previousResultMap.delete(request.sessionId);
                 }
                 return undefined;
             }), token);
@@ -116,6 +99,18 @@ class ExtHostChatAgents2 {
             commandExecution.complete();
         }
     }
+    async prepareHistory(agent, request, context) {
+        return coalesce(await Promise.all(( context.history
+            .map(async (h) => {
+            const result = request.agentId === h.request.agentId && this._resultsBySessionAndRequestId.get(request.sessionId)?.get(h.request.requestId)
+                || h.result;
+            return {
+                request: ChatAgentRequest.to(h.request, undefined),
+                response: coalesce(( h.response.map(r => ChatResponseProgress.toProgressContent(r)))),
+                result
+            };
+        }))));
+    }
     $releaseSession(sessionId) {
         this._previousResultMap.delete(sessionId);
         this._resultsBySessionAndRequestId.delete(sessionId);
@@ -182,9 +177,9 @@ class ExtHostChatAgents2 {
     }
 }
 class ExtHostChatAgent {
-    constructor(extension, _id, _proxy, _handle, _callback) {
+    constructor(extension, id, _proxy, _handle, _callback) {
         this.extension = extension;
-        this._id = _id;
+        this.id = id;
         this._proxy = _proxy;
         this._handle = _handle;
         this._callback = _callback;
@@ -218,7 +213,7 @@ class ExtHostChatAgent {
         if (!this._slashCommandProvider) {
             return [];
         }
-        const result = await this._slashCommandProvider.provideSlashCommands(token);
+        const result = await this._slashCommandProvider.provideSubCommands(token);
         if (!result) {
             return [];
         }
@@ -280,7 +275,7 @@ class ExtHostChatAgent {
         const that = this;
         return {
             get name() {
-                return that._id;
+                return that.id;
             },
             get description() {
                 return that._description ?? '';
@@ -303,10 +298,10 @@ class ExtHostChatAgent {
                 that._iconPath = v;
                 updateMetadataSoon();
             },
-            get slashCommandProvider() {
+            get subCommandProvider() {
                 return that._slashCommandProvider;
             },
-            set slashCommandProvider(v) {
+            set subCommandProvider(v) {
                 that._slashCommandProvider = v;
                 updateMetadataSoon();
             },

package/vscode/src/vs/workbench/api/common/extHostChatVariables.js

@@ -14,7 +14,7 @@ class ExtHostChatVariables {
             return undefined;
         }
         try {
-            const value = await item.resolver.resolve(item.data.name, { message: messageText }, token);
+            const value = await item.resolver.resolve(item.data.name, { prompt: messageText }, token);
             if (value) {
                 return ( value.map(ChatVariable.from));
             }

package/vscode/src/vs/workbench/api/common/extHostComments.js

@@ -495,6 +495,9 @@ function createExtHostComments(mainContext, commands, documents) {
         if (vscodeComment.state !== undefined) {
             checkProposedApiEnabled(extension, 'commentsDraftState');
         }
+        if (vscodeComment.reactions?.some(reaction => reaction.reactors !== undefined)) {
+            checkProposedApiEnabled(extension, 'commentReactor');
+        }
         return {
             mode: vscodeComment.mode,
             contextValue: vscodeComment.contextValue,
@@ -514,6 +517,7 @@ function createExtHostComments(mainContext, commands, documents) {
             iconPath: reaction.iconPath ? pathOrURIToURI(reaction.iconPath) : undefined,
             count: reaction.count,
             hasReacted: reaction.authorHasReacted,
+            reactors: ((reaction.reactors && (reaction.reactors.length > 0) && (typeof reaction.reactors[0] !== 'string')) ? ( reaction.reactors.map(reactor => reactor.name)) : reaction.reactors)
         };
     }
     function convertFromReaction(reaction) {
@@ -521,7 +525,8 @@ function createExtHostComments(mainContext, commands, documents) {
             label: reaction.label || '',
             count: reaction.count || 0,
             iconPath: reaction.iconPath ? URI.revive(reaction.iconPath) : '',
-            authorHasReacted: reaction.hasReacted || false
+            authorHasReacted: reaction.hasReacted || false,
+            reactors: reaction.reactors?.map(reactor => ({ name: reactor }))
         };
     }
     function convertToCollapsibleState(kind) {

package/vscode/src/vs/workbench/api/common/extHostConsoleForwarder.js

@@ -11,6 +11,7 @@ let AbstractExtHostConsoleForwarder = class AbstractExtHostConsoleForwarder {
         this._wrapConsoleMethod('info', 'log');
         this._wrapConsoleMethod('log', 'log');
         this._wrapConsoleMethod('warn', 'warn');
+        this._wrapConsoleMethod('debug', 'debug');
         this._wrapConsoleMethod('error', 'error');
     }
     _wrapConsoleMethod(method, severity) {

package/vscode/src/vs/workbench/api/common/extHostDebugService.js

@@ -2,17 +2,21 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { asPromise } from '../../../base/common/async.js';
 import { Emitter } from '../../../base/common/event.js';
 import { URI } from '../../../base/common/uri.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { MainContext } from './extHost.protocol.js';
 import { IExtHostEditorTabs } from './extHostEditorTabs.js';
 import { IExtHostExtensionService } from './extHostExtensionService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
-import { SourceBreakpoint, DebugConsoleMode, Disposable, setBreakpointId, FunctionBreakpoint, Location, Position, DebugAdapterExecutable, DebugAdapterServer, DebugAdapterNamedPipeServer, DebugAdapterInlineImplementation, DataBreakpoint, ThreadFocus, StackFrameFocus } from './extHostTypes.js';
+import { SourceBreakpoint, DebugConsoleMode, Disposable, setBreakpointId, FunctionBreakpoint, Location, Position, DebugAdapterExecutable, DebugAdapterServer, DebugAdapterNamedPipeServer, DebugAdapterInlineImplementation, ThemeIcon as ThemeIcon$1, DataBreakpoint, ThreadFocus, StackFrameFocus } from './extHostTypes.js';
 import { IExtHostWorkspace } from './extHostWorkspace.js';
 import { AbstractDebugAdapter } from '../../contrib/debug/common/abstractDebugAdapter.js';
 import { convertToVSCPaths, convertToDAPaths, isDebuggerMainContribution } from '../../contrib/debug/common/debugUtils.js';
 import { IExtHostConfiguration } from './extHostConfiguration.js';
 import { IExtHostVariableResolverProvider } from './extHostVariableResolverService.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
+import { IExtHostCommands } from './extHostCommands.js';
 const IExtHostDebugService = ( createDecorator('IExtHostDebugService'));
 let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
     get onDidStartDebugSession() { return this._onDidStartDebugSession.event; }
@@ -21,13 +25,17 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
     get activeDebugSession() { return this._activeDebugSession; }
     get onDidReceiveDebugSessionCustomEvent() { return this._onDidReceiveDebugSessionCustomEvent.event; }
     get activeDebugConsole() { return this._activeDebugConsole.value; }
-    constructor(extHostRpcService, _workspaceService, _extensionService, _configurationService, _editorTabs, _variableResolver) {
+    constructor(extHostRpcService, _workspaceService, _extensionService, _configurationService, _editorTabs, _variableResolver, _commands) {
         this._workspaceService = _workspaceService;
         this._extensionService = _extensionService;
         this._configurationService = _configurationService;
         this._editorTabs = _editorTabs;
         this._variableResolver = _variableResolver;
+        this._commands = _commands;
         this._debugSessions = ( new Map());
+        this._debugVisualizationProviders = ( new Map());
+        this._visualizers = ( new Map());
+        this._visualizerIdCounter = 0;
         this._configProviderHandleCounter = 0;
         this._configProviders = [];
         this._adapterFactoryHandleCounter = 0;
@@ -101,6 +109,82 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         this._breakpoints.forEach(bp => result.push(bp));
         return result;
     }
+    async $resolveDebugVisualizer(id, token) {
+        const visualizer = this._visualizers.get(id);
+        if (!visualizer) {
+            throw new Error(`No debug visualizer found with id '${id}'`);
+        }
+        let { v, provider } = visualizer;
+        if (!v.visualization) {
+            v = (await provider.resolveDebugVisualization?.(v, token)) || v;
+            visualizer.v = v;
+        }
+        if (!v.visualization) {
+            throw new Error(`No visualization returned from resolveDebugVisualization in '${provider}'`);
+        }
+        return this.serializeVisualization(v.visualization);
+    }
+    async $executeDebugVisualizerCommand(id) {
+        const visualizer = this._visualizers.get(id);
+        if (!visualizer) {
+            throw new Error(`No debug visualizer found with id '${id}'`);
+        }
+        const command = visualizer.v.visualization;
+        if (command && 'command' in command) {
+            this._commands.executeCommand(command.command, ...(command.arguments || []));
+        }
+    }
+    async $provideDebugVisualizers(extensionId, id, context, token) {
+        const session = this._debugSessions.get(context.sessionId);
+        const key = this.extensionVisKey(extensionId, id);
+        const provider = this._debugVisualizationProviders.get(key);
+        if (!session || !provider) {
+            return [];
+        }
+        const visualizations = await provider.provideDebugVisualization({
+            session,
+            variable: context.variable,
+            containerId: context.containerId,
+            frameId: context.frameId,
+            threadId: context.threadId,
+        }, token);
+        if (!visualizations) {
+            return [];
+        }
+        return ( visualizations.map(v => {
+            const id = ++this._visualizerIdCounter;
+            this._visualizers.set(id, { v, provider });
+            const icon = v.iconPath ? this.getIconPathOrClass(v.iconPath) : undefined;
+            return {
+                id,
+                name: v.name,
+                iconClass: icon?.iconClass,
+                iconPath: icon?.iconPath,
+                visualization: this.serializeVisualization(v.visualization),
+            };
+        }));
+    }
+    $disposeDebugVisualizers(ids) {
+        for (const id of ids) {
+            this._visualizers.delete(id);
+        }
+    }
+    registerDebugVisualizationProvider(manifest, id, provider) {
+        if (!manifest.contributes?.debugVisualizers?.some(r => r.id === id)) {
+            throw new Error(`Extensions may only call registerDebugVisualizationProvider() for renderers they contribute (got ${id})`);
+        }
+        const extensionId = ExtensionIdentifier.toKey(manifest.identifier);
+        const key = this.extensionVisKey(extensionId, id);
+        if (( this._debugVisualizationProviders.has(key))) {
+            throw new Error(`A debug visualization provider with id '${id}' is already registered`);
+        }
+        this._debugVisualizationProviders.set(key, provider);
+        this._debugServiceProxy.$registerDebugVisualizer(extensionId, id);
+        return toDisposable(() => {
+            this._debugServiceProxy.$unregisterDebugVisualizer(extensionId, id);
+            this._debugVisualizationProviders.delete(id);
+        });
+    }
     addBreakpoints(breakpoints0) {
         const breakpoints = breakpoints0.filter(bp => {
             const id = bp.id;
@@ -672,6 +756,44 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         }
         return Promise.resolve(undefined);
     }
+    extensionVisKey(extensionId, id) {
+        return `${extensionId}\0${id}`;
+    }
+    serializeVisualization(viz) {
+        if (!viz) {
+            return undefined;
+        }
+        if ('title' in viz && 'command' in viz) {
+            return { type: 0  };
+        }
+        throw new Error('Unsupported debug visualization type');
+    }
+    getIconPathOrClass(icon) {
+        const iconPathOrIconClass = this.getIconUris(icon);
+        let iconPath;
+        let iconClass;
+        if ('id' in iconPathOrIconClass) {
+            iconClass = ThemeIcon.asClassName(iconPathOrIconClass);
+        }
+        else {
+            iconPath = iconPathOrIconClass;
+        }
+        return {
+            iconPath,
+            iconClass
+        };
+    }
+    getIconUris(iconPath) {
+        if (iconPath instanceof ThemeIcon$1) {
+            return { id: iconPath.id };
+        }
+        const dark = typeof iconPath === 'object' && 'dark' in iconPath ? iconPath.dark : iconPath;
+        const light = typeof iconPath === 'object' && 'light' in iconPath ? iconPath.light : iconPath;
+        return {
+            dark: (typeof dark === 'string' ? URI.file(dark) : dark),
+            light: (typeof light === 'string' ? URI.file(light) : light),
+        };
+    }
 };
 ExtHostDebugServiceBase = ( __decorate([
     ( __param(0, IExtHostRpcService)),
@@ -679,7 +801,8 @@ ExtHostDebugServiceBase = ( __decorate([
     ( __param(2, IExtHostExtensionService)),
     ( __param(3, IExtHostConfiguration)),
     ( __param(4, IExtHostEditorTabs)),
-    ( __param(5, IExtHostVariableResolverProvider))
+    ( __param(5, IExtHostVariableResolverProvider)),
+    ( __param(6, IExtHostCommands))
 ], ExtHostDebugServiceBase));
 class ExtHostDebugSession {
     constructor(_debugServiceProxy, _id, _type, _name, _workspaceFolder, _configuration, _parentSession) {
@@ -778,8 +901,8 @@ class DirectDebugAdapter extends AbstractDebugAdapter {
     }
 }
 let WorkerExtHostDebugService = class WorkerExtHostDebugService extends ExtHostDebugServiceBase {
-    constructor(extHostRpcService, workspaceService, extensionService, configurationService, editorTabs, variableResolver) {
-        super(extHostRpcService, workspaceService, extensionService, configurationService, editorTabs, variableResolver);
+    constructor(extHostRpcService, workspaceService, extensionService, configurationService, editorTabs, variableResolver, commands) {
+        super(extHostRpcService, workspaceService, extensionService, configurationService, editorTabs, variableResolver, commands);
     }
 };
 WorkerExtHostDebugService = ( __decorate([
@@ -788,6 +911,7 @@ WorkerExtHostDebugService = ( __decorate([
     ( __param(2, IExtHostExtensionService)),
     ( __param(3, IExtHostConfiguration)),
     ( __param(4, IExtHostEditorTabs)),
-    ( __param(5, IExtHostVariableResolverProvider))
+    ( __param(5, IExtHostVariableResolverProvider)),
+    ( __param(6, IExtHostCommands))
 ], WorkerExtHostDebugService));
 export { ExtHostDebugConsole, ExtHostDebugServiceBase, ExtHostDebugSession, IExtHostDebugService, WorkerExtHostDebugService };

package/vscode/src/vs/workbench/api/common/extHostDocumentContentProviders.js

@@ -22,26 +22,39 @@ class ExtHostDocumentContentProvider {
         this._proxy.$registerTextContentProvider(handle, scheme);
         let subscription;
         if (typeof provider.onDidChange === 'function') {
-            subscription = provider.onDidChange(uri => {
+            let lastEvent;
+            subscription = provider.onDidChange(async (uri) => {
                 if (uri.scheme !== scheme) {
                     this._logService.warn(`Provider for scheme '${scheme}' is firing event for schema '${uri.scheme}' which will be IGNORED`);
                     return;
                 }
-                if (this._documentsAndEditors.getDocument(uri)) {
-                    this.$provideTextDocumentContent(handle, uri).then(value => {
-                        if (!value && typeof value !== 'string') {
-                            return;
-                        }
-                        const document = this._documentsAndEditors.getDocument(uri);
-                        if (!document) {
-                            return;
-                        }
-                        const lines = splitLines(value);
-                        if (!document.equalLines(lines)) {
-                            return this._proxy.$onVirtualDocumentChange(uri, value);
-                        }
-                    }, onUnexpectedError);
+                if (!this._documentsAndEditors.getDocument(uri)) {
+                    return;
+                }
+                if (lastEvent) {
+                    await lastEvent;
                 }
+                const thisEvent = this.$provideTextDocumentContent(handle, uri)
+                    .then(async (value) => {
+                    if (!value && typeof value !== 'string') {
+                        return;
+                    }
+                    const document = this._documentsAndEditors.getDocument(uri);
+                    if (!document) {
+                        return;
+                    }
+                    const lines = splitLines(value);
+                    if (!document.equalLines(lines)) {
+                        return this._proxy.$onVirtualDocumentChange(uri, value);
+                    }
+                })
+                    .catch(onUnexpectedError)
+                    .finally(() => {
+                    if (lastEvent === thisEvent) {
+                        lastEvent = undefined;
+                    }
+                });
+                lastEvent = thisEvent;
             });
         }
         return ( new Disposable(() => {

package/vscode/src/vs/workbench/api/common/extHostDocuments.js

@@ -7,13 +7,12 @@ import { Range } from './extHostTypeConverters.js';
 import { assertIsDefined } from '../../../base/common/types.js';
 import { deepFreeze } from '../../../base/common/objects.js';
 import { TextDocumentChangeReason } from './extHostTypes.js';
-import { onUnexpectedExternalError } from '../../../base/common/errors.js';
 class ExtHostDocuments {
     constructor(mainContext, documentsAndEditors) {
-        this._onDidAddDocument = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
-        this._onDidRemoveDocument = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
-        this._onDidChangeDocument = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
-        this._onDidSaveDocument = ( new Emitter({ onListenerError: onUnexpectedExternalError }));
+        this._onDidAddDocument = ( new Emitter());
+        this._onDidRemoveDocument = ( new Emitter());
+        this._onDidChangeDocument = ( new Emitter());
+        this._onDidSaveDocument = ( new Emitter());
         this.onDidAddDocument = this._onDidAddDocument.event;
         this.onDidRemoveDocument = this._onDidRemoveDocument.event;
         this.onDidChangeDocument = this._onDidChangeDocument.event;

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -681,7 +681,11 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         intervalLogger.dispose();
         const tunnelInformation = {
             environmentTunnels: result.environmentTunnels,
-            features: result.tunnelFeatures
+            features: result.tunnelFeatures ? {
+                elevation: result.tunnelFeatures.elevation,
+                privacyOptions: result.tunnelFeatures.privacyOptions,
+                protocol: result.tunnelFeatures.protocol === undefined ? true : result.tunnelFeatures.protocol,
+            } : undefined
         };
         const options = {
             extensionHostEnv: result.extensionHostEnv,

package/vscode/src/vs/workbench/api/common/extHostFileSystem.js

@@ -120,8 +120,7 @@ class ExtHostFileSystem {
             capabilities += 4 ;
         }
         let readOnlyMessage;
-        if (options.isReadonly && isMarkdownString(options.isReadonly)) {
-            checkProposedApiEnabled(extension, 'readonlyMessage');
+        if (options.isReadonly && isMarkdownString(options.isReadonly) && options.isReadonly.value !== '') {
             readOnlyMessage = {
                 value: options.isReadonly.value,
                 isTrusted: options.isReadonly.isTrusted,

package/vscode/src/vs/workbench/api/common/extHostFileSystemConsumer.js

@@ -93,7 +93,7 @@ let ExtHostConsumerFileSystem = ExtHostConsumerFileSystem_1 = class ExtHostConsu
                     if (provider && !provider.isReadonly) {
                         await that._proxy.$ensureActivation(uri.scheme);
                         await that.mkdirp(provider.impl, provider.extUri, provider.extUri.dirname(uri));
-                        return await that._writeQueue.queueFor(uri).queue(() => Promise.resolve(provider.impl.writeFile(uri, content, { create: true, overwrite: true })));
+                        return await that._writeQueue.queueFor(uri, () => Promise.resolve(provider.impl.writeFile(uri, content, { create: true, overwrite: true })));
                     }
                     else {
                         return await that._proxy.$writeFile(uri, VSBuffer.wrap(content));
@@ -106,7 +106,7 @@ let ExtHostConsumerFileSystem = ExtHostConsumerFileSystem_1 = class ExtHostConsu
             async delete(uri, options) {
                 try {
                     const provider = that._fileSystemProvider.get(uri.scheme);
-                    if (provider && !provider.isReadonly) {
+                    if (provider && !provider.isReadonly && !options?.useTrash ) {
                         await that._proxy.$ensureActivation(uri.scheme);
                         return await provider.impl.delete(uri, { recursive: false, ...options });
                     }

package/vscode/src/vs/workbench/api/common/extHostInlineChat.js

@@ -1,8 +1,8 @@
 import { toDisposable } from '../../../base/common/lifecycle.js';
 import { URI } from '../../../base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
-import { Range, Selection, Position, MarkdownString, WorkspaceEdit as WorkspaceEdit$1, TextEdit, ChatReplyFollowup, InteractiveEditorResponseFeedbackKind } from './extHostTypeConverters.js';
-import { WorkspaceEdit, MarkdownString as MarkdownString$1 } from './extHostTypes.js';
+import { Range, Selection as Selection$1, Position, MarkdownString, WorkspaceEdit as WorkspaceEdit$1, TextEdit, ChatFollowup, InteractiveEditorResponseFeedbackKind } from './extHostTypeConverters.js';
+import { Selection, WorkspaceEdit, MarkdownString as MarkdownString$1 } from './extHostTypes.js';
 import { ApiCommand, ApiCommandArgument, ApiCommandResult } from './extHostCommands.js';
 import { raceCancellation } from '../../../base/common/async.js';
 class ProviderWrapper {
@@ -37,7 +37,7 @@ class ExtHostInteractiveEditor {
                     }
                     return {
                         initialRange: v.initialRange ? Range.from(v.initialRange) : undefined,
-                        initialSelection: v.initialSelection ? Selection.from(v.initialSelection) : undefined,
+                        initialSelection: Selection.isSelection(v.initialSelection) ? Selection$1.from(v.initialSelection) : undefined,
                         message: v.message,
                         autoSend: v.autoSend,
                         position: v.position ? Position.from(v.position) : undefined,
@@ -62,7 +62,7 @@ class ExtHostInteractiveEditor {
             return undefined;
         }
         const document = this._documents.getDocument(URI.revive(uri));
-        const selection = Selection.to(range);
+        const selection = Selection$1.to(range);
         const session = await entry.provider.prepareInteractiveEditorSession({ document, selection }, token);
         if (!session) {
             return undefined;
@@ -92,10 +92,11 @@ class ExtHostInteractiveEditor {
         }
         const apiRequest = {
             prompt: request.prompt,
-            selection: Selection.to(request.selection),
+            selection: Selection$1.to(request.selection),
             wholeRange: Range.to(request.wholeRange),
             attempt: request.attempt,
             live: request.live,
+            withIntentDetection: request.withIntentDetection,
         };
         let done = false;
         const progress = {
@@ -131,34 +132,35 @@ class ExtHostInteractiveEditor {
             wholeRange: Range.from(res.wholeRange),
             placeholder: res.placeholder,
         };
-        if (ExtHostInteractiveEditor._isEditResponse(res)) {
-            const { edits, contents } = res;
-            const message = contents !== undefined ? MarkdownString.from(contents) : undefined;
-            if (edits instanceof WorkspaceEdit) {
-                return {
-                    ...stub,
-                    id,
-                    type: "bulkEdit" ,
-                    edits: WorkspaceEdit$1.from(edits),
-                    message
-                };
-            }
-            else {
-                return {
-                    ...stub,
-                    id,
-                    type: "editorEdit" ,
-                    edits: ( edits.map(TextEdit.from)),
-                    message
-                };
-            }
+        if (!ExtHostInteractiveEditor._isEditResponse(res)) {
+            return {
+                ...stub,
+                id,
+                type: "editorEdit" ,
+                message: MarkdownString.from(res.contents),
+                edits: []
+            };
+        }
+        const { edits, contents } = res;
+        const message = contents !== undefined ? MarkdownString.from(contents) : undefined;
+        if (edits instanceof WorkspaceEdit) {
+            return {
+                ...stub,
+                id,
+                type: "bulkEdit" ,
+                edits: WorkspaceEdit$1.from(edits),
+                message
+            };
+        }
+        else {
+            return {
+                ...stub,
+                id,
+                type: "editorEdit" ,
+                edits: ( edits.map(TextEdit.from)),
+                message
+            };
         }
-        return {
-            ...stub,
-            id,
-            type: "message" ,
-            message: MarkdownString.from(res.contents),
-        };
     }
     async $provideFollowups(handle, sessionId, responseId, token) {
         const entry = this._inputProvider.get(handle);
@@ -167,7 +169,7 @@ class ExtHostInteractiveEditor {
         if (entry && response && entry.provider.provideFollowups) {
             const task = Promise.resolve(entry.provider.provideFollowups(sessionData.session, response, token));
             const followups = await raceCancellation(task, token);
-            return followups?.map(ChatReplyFollowup.from);
+            return followups?.map(ChatFollowup.from);
         }
         return undefined;
     }