@codingame/monaco-vscode-api 4.5.2 → 5.0.0

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

@@ -3,24 +3,21 @@ import { raceCancellation } from '../../../base/common/async.js';
 import { toErrorMessage } from '../../../base/common/errorMessage.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Iterable } from '../../../base/common/iterator.js';
-import { DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
+import { Disposable, DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { assertType } from '../../../base/common/types.js';
 import { URI } from '../../../base/common/uri.js';
-import { localizeWithPath } from '../../../nls.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
-import { ChatAgentRequest, ChatAgentResult, ChatAgentResolvedVariable, ChatResponsePart, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, MarkdownString, ChatResponseMarkdownPart, ChatResponseFilesPart, ChatResponseAnchorPart, ChatResponseCommandButtonPart, ChatResponseProgressPart, ChatResponseReferencePart, ChatResponseProgress } from './extHostTypeConverters.js';
-import { ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ChatResponseReferencePart as ChatResponseReferencePart$1, ThemeIcon, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatResponseFileTreePart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseProgressPart as ChatResponseProgressPart$1 } from './extHostTypes.js';
+import { ChatAgentRequest, ChatAgentResult, ChatAgentResolvedVariable, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, ChatLocation, ChatResponsePart, MarkdownString, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatResponseMarkdownWithVulnerabilitiesPart as ChatResponseMarkdownWithVulnerabilitiesPart$1, ChatResponseFilesPart, ChatResponseAnchorPart, ChatResponseCommandButtonPart, ChatResponseProgressPart, ChatResponseReferencePart, ChatResponseTextEditPart, ChatResponseDetectedParticipantPart } from './extHostTypeConverters.js';
+import { ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ChatResponseMarkdownPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseTextEditPart as ChatResponseTextEditPart$1, ChatResponseDetectedParticipantPart as ChatResponseDetectedParticipantPart$1, ChatResponseReferencePart as ChatResponseReferencePart$1, ThemeIcon, ChatResponseFileTreePart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseProgressPart as ChatResponseProgressPart$1 } from './extHostTypes.js';
 import { InteractiveSessionVoteDirection } from '../../contrib/chat/common/chatService.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
-const _moduleId = "vs/workbench/api/common/extHostChatAgents2";
 class ChatAgentResponseStream {
-    constructor(_extension, _request, _proxy, _logService, _commandsConverter, _sessionDisposables) {
+    constructor(_extension, _request, _proxy, _commandsConverter, _sessionDisposables) {
         this._extension = _extension;
         this._request = _request;
         this._proxy = _proxy;
-        this._logService = _logService;
         this._commandsConverter = _commandsConverter;
         this._sessionDisposables = _sessionDisposables;
         this._stopWatch = StopWatch.create(false);
@@ -41,7 +38,7 @@ class ChatAgentResponseStream {
             this._stopWatch.reset();
             function throwIfDone(source) {
                 if (that._isClosed) {
-                    const err = ( (new Error('Response stream has been closed')));
+                    const err = ( new Error('Response stream has been closed'));
                     Error.captureStackTrace(err, source);
                     throw err;
                 }
@@ -55,54 +52,64 @@ class ChatAgentResponseStream {
             this._apiObject = {
                 markdown(value) {
                     throwIfDone(this.markdown);
-                    const part = new ChatResponseMarkdownPart$1(value);
-                    const dto = ChatResponseMarkdownPart.to(part);
+                    const part = new ChatResponseMarkdownPart(value);
+                    const dto = ChatResponseMarkdownPart$1.from(part);
+                    _report(dto);
+                    return this;
+                },
+                markdownWithVulnerabilities(value, vulnerabilities) {
+                    throwIfDone(this.markdown);
+                    if (vulnerabilities) {
+                        checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    }
+                    const part = new ChatResponseMarkdownWithVulnerabilitiesPart(value, vulnerabilities);
+                    const dto = ChatResponseMarkdownWithVulnerabilitiesPart$1.from(part);
                     _report(dto);
                     return this;
                 },
                 filetree(value, baseUri) {
                     throwIfDone(this.filetree);
                     const part = new ChatResponseFileTreePart(value, baseUri);
-                    const dto = ChatResponseFilesPart.to(part);
+                    const dto = ChatResponseFilesPart.from(part);
                     _report(dto);
                     return this;
                 },
                 anchor(value, title) {
                     throwIfDone(this.anchor);
                     const part = new ChatResponseAnchorPart$1(value, title);
-                    const dto = ChatResponseAnchorPart.to(part);
+                    const dto = ChatResponseAnchorPart.from(part);
                     _report(dto);
                     return this;
                 },
                 button(value) {
                     throwIfDone(this.anchor);
                     const part = new ChatResponseCommandButtonPart$1(value);
-                    const dto = ChatResponseCommandButtonPart.to(part, that._commandsConverter, that._sessionDisposables);
+                    const dto = ChatResponseCommandButtonPart.from(part, that._commandsConverter, that._sessionDisposables);
                     _report(dto);
                     return this;
                 },
                 progress(value) {
                     throwIfDone(this.progress);
                     const part = new ChatResponseProgressPart$1(value);
-                    const dto = ChatResponseProgressPart.to(part);
+                    const dto = ChatResponseProgressPart.from(part);
                     _report(dto);
                     return this;
                 },
-                reference(value) {
+                reference(value, iconPath) {
                     throwIfDone(this.reference);
                     if ('variableName' in value && !value.value) {
                         const matchingVarData = that._request.variables.variables.find(v => v.name === value.variableName);
                         if (matchingVarData) {
                             let references;
                             if (matchingVarData.references?.length) {
-                                references = ( (matchingVarData.references.map(r => ({
+                                references = ( matchingVarData.references.map(r => ({
                                     kind: 'reference',
                                     reference: { variableName: value.variableName, value: r.reference }
-                                }))));
+                                })));
                             }
                             else {
-                                const part = new ChatResponseReferencePart$1(value);
-                                const dto = ChatResponseReferencePart.to(part);
+                                const part = new ChatResponseReferencePart$1(value, iconPath);
+                                const dto = ChatResponseReferencePart.from(part);
                                 references = [dto];
                             }
                             references.forEach(r => _report(r));
@@ -110,84 +117,94 @@ class ChatAgentResponseStream {
                         }
                     }
                     else {
-                        const part = new ChatResponseReferencePart$1(value);
-                        const dto = ChatResponseReferencePart.to(part);
+                        const part = new ChatResponseReferencePart$1(value, iconPath);
+                        const dto = ChatResponseReferencePart.from(part);
                         _report(dto);
                     }
                     return this;
                 },
+                textEdit(target, edits) {
+                    throwIfDone(this.textEdit);
+                    checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    const part = new ChatResponseTextEditPart$1(target, edits);
+                    const dto = ChatResponseTextEditPart.from(part);
+                    _report(dto);
+                    return this;
+                },
+                detectedParticipant(participant, command) {
+                    throwIfDone(this.detectedParticipant);
+                    checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    const part = new ChatResponseDetectedParticipantPart$1(participant, command);
+                    const dto = ChatResponseDetectedParticipantPart.from(part);
+                    _report(dto);
+                    return this;
+                },
                 push(part) {
                     throwIfDone(this.push);
+                    if (part instanceof ChatResponseTextEditPart$1 || part instanceof ChatResponseMarkdownWithVulnerabilitiesPart || part instanceof ChatResponseDetectedParticipantPart$1) {
+                        checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
+                    }
                     if (part instanceof ChatResponseReferencePart$1) {
-                        this.reference(part.value);
+                        this.reference(part.value, part.iconPath);
                     }
                     else {
-                        const dto = ChatResponsePart.to(part, that._commandsConverter, that._sessionDisposables);
+                        const dto = ChatResponsePart.from(part, that._commandsConverter, that._sessionDisposables);
                         _report(dto);
                     }
                     return this;
                 },
-                report(progress) {
-                    throwIfDone(this.report);
-                    if ('placeholder' in progress && 'resolvedContent' in progress) {
-                        return;
-                    }
-                    const value = ChatResponseProgress.from(that._extension, progress);
-                    if (!value) {
-                        that._logService.error('Unknown progress type: ' + JSON.stringify(progress));
-                        return;
-                    }
-                    _report(value);
-                    return this;
-                }
             };
         }
         return this._apiObject;
     }
 }
-class ExtHostChatAgents2 {
+class ExtHostChatAgents2 extends Disposable {
     static { this._idPool = 0; }
     constructor(mainContext, _logService, commands) {
+        super();
         this._logService = _logService;
         this.commands = commands;
-        this._agents = ( (new Map()));
-        this._sessionDisposables = ( (new DisposableMap()));
-        this._proxy = ( (mainContext.getProxy(MainContext.MainThreadChatAgents2)));
+        this._agents = ( new Map());
+        this._sessionDisposables = this._register(( new DisposableMap()));
+        this._completionDisposables = this._register(( new DisposableStore()));
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatAgents2));
+    }
+    transferActiveChat(newWorkspace) {
+        this._proxy.$transferActiveChatSession(newWorkspace);
     }
     createChatAgent(extension, id, handler) {
         const handle = ExtHostChatAgents2._idPool++;
-        const agent = ( (new ExtHostChatAgent(extension, id, this._proxy, handle, handler)));
+        const agent = ( new ExtHostChatAgent(extension, id, this._proxy, handle, handler));
         this._agents.set(handle, agent);
         this._proxy.$registerAgent(handle, extension.identifier, id, {}, undefined);
         return agent.apiAgent;
     }
     createDynamicChatAgent(extension, id, name, description, handler) {
         const handle = ExtHostChatAgents2._idPool++;
-        const agent = ( (new ExtHostChatAgent(extension, id, this._proxy, handle, handler)));
+        const agent = ( new ExtHostChatAgent(extension, id, this._proxy, handle, handler));
         this._agents.set(handle, agent);
-        this._proxy.$registerAgent(handle, extension.identifier, id, {}, { name, description });
+        this._proxy.$registerAgent(handle, extension.identifier, id, { isSticky: true }, { name, description });
         return agent.apiAgent;
     }
     async $invokeAgent(handle, request, context, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
-            throw ( (new Error(
+            throw ( new Error(
                 `[CHAT](${handle}) CANNOT invoke agent because the agent is not registered`
-            )));
+            ));
         }
         let sessionDisposables = this._sessionDisposables.get(request.sessionId);
         if (!sessionDisposables) {
-            sessionDisposables = ( (new DisposableStore()));
+            sessionDisposables = ( new DisposableStore());
             this._sessionDisposables.set(request.sessionId, sessionDisposables);
         }
-        const stream = ( (new ChatAgentResponseStream(
+        const stream = ( new ChatAgentResponseStream(
             agent.extension,
             request,
             this._proxy,
-            this._logService,
             this.commands.converter,
             sessionDisposables
-        )));
+        ));
         try {
             const convertedHistory = await this.prepareHistoryTurns(request.agentId, context);
             const task = agent.invoke(ChatAgentRequest.to(request), { history: convertedHistory }, stream.apiObject, token);
@@ -207,7 +224,7 @@ class ExtHostChatAgents2 {
         }
         catch (e) {
             this._logService.error(e, agent.extension);
-            return { errorDetails: { message: ( localizeWithPath(_moduleId, 0, "Error from participant: {0}", toErrorMessage(e))), responseIsIncomplete: true } };
+            return { errorDetails: { message: toErrorMessage(e), responseIsIncomplete: true } };
         }
         finally {
             stream.close();
@@ -220,8 +237,8 @@ class ExtHostChatAgents2 {
             const result = agentId === h.request.agentId ?
                 ehResult :
                 { ...ehResult, metadata: undefined };
-            res.push(new ChatRequestTurn(h.request.message, h.request.command, ( (h.request.variables.variables.map(ChatAgentResolvedVariable.to))), h.request.agentId));
-            const parts = coalesce(( (h.response.map(r => ChatResponsePart.fromContent(r, this.commands.converter)))));
+            res.push(new ChatRequestTurn(h.request.message, h.request.command, ( h.request.variables.variables.map(ChatAgentResolvedVariable.to)), h.request.agentId));
+            const parts = coalesce(( h.response.map(r => ChatResponsePart.toContent(r, this.commands.converter))));
             res.push(new ChatResponseTurn(parts, result, h.request.agentId, h.request.command));
         }
         return res;
@@ -236,20 +253,15 @@ class ExtHostChatAgents2 {
         }
         const convertedHistory = await this.prepareHistoryTurns(agent.id, context);
         const ehResult = ChatAgentResult.to(result);
-        return (
-             ((await agent.provideFollowups(ehResult, { history: convertedHistory }, token))
-                .filter(f => {
-                const isValid = !f.participant || ( (Iterable.some(
-                     (this._agents.values()),
-                    a => a.id === f.participant && ExtensionIdentifier.equals(a.extension.identifier, agent.extension.identifier)
-                )));
-                if (!isValid) {
-                    this._logService.warn(`[@${agent.id}] ChatFollowup refers to an unknown participant: ${f.participant}`);
-                }
-                return isValid;
-            })
-                .map(f => ChatFollowup.from(f, request)))
-        );
+        return ( (await agent.provideFollowups(ehResult, { history: convertedHistory }, token))
+            .filter(f => {
+            const isValid = !f.participant || ( Iterable.some(( this._agents.values()), a => a.id === f.participant && ExtensionIdentifier.equals(a.extension.identifier, agent.extension.identifier)));
+            if (!isValid) {
+                this._logService.warn(`[@${agent.id}] ChatFollowup refers to an unknown participant: ${f.participant}`);
+            }
+            return isValid;
+        })
+            .map(f => ChatFollowup.from(f, request)));
     }
     $acceptFeedback(handle, result, vote, reportIssue) {
         const agent = this._agents.get(handle);
@@ -267,8 +279,8 @@ class ExtHostChatAgents2 {
                 break;
         }
         agent.acceptFeedback(reportIssue ?
-            ( (Object.freeze({ result: ehResult, kind, reportIssue }))) :
-            ( (Object.freeze({ result: ehResult, kind }))));
+            ( Object.freeze({ result: ehResult, kind, reportIssue })) :
+            ( Object.freeze({ result: ehResult, kind })));
     }
     $acceptAction(handle, result, event) {
         const agent = this._agents.get(handle);
@@ -280,7 +292,7 @@ class ExtHostChatAgents2 {
         }
         const ehAction = ChatAgentUserActionEvent.to(result, event, this.commands.converter);
         if (ehAction) {
-            agent.acceptAction(( (Object.freeze(ehAction))));
+            agent.acceptAction(( Object.freeze(ehAction)));
         }
     }
     async $invokeCompletionProvider(handle, query, token) {
@@ -289,26 +301,24 @@ class ExtHostChatAgents2 {
             return [];
         }
         const items = await agent.invokeCompletionProvider(query, token);
-        return (
-             (items.map(ChatAgentCompletionItem.from))
-        );
+        return ( items.map(
+            (i) => ChatAgentCompletionItem.from(i, this.commands.converter, this._completionDisposables)
+        ));
     }
-    async $provideWelcomeMessage(handle, token) {
+    async $provideWelcomeMessage(handle, location, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return;
         }
-        return await agent.provideWelcomeMessage(token);
+        return await agent.provideWelcomeMessage(ChatLocation.to(location), token);
     }
-    async $provideSampleQuestions(handle, token) {
+    async $provideSampleQuestions(handle, location, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return;
         }
-        return (
-             ((await agent.provideSampleQuestions(token))
-                .map(f => ChatFollowup.from(f, undefined)))
-        );
+        return ( (await agent.provideSampleQuestions(ChatLocation.to(location), token))
+            .map(f => ChatFollowup.from(f, undefined)));
     }
 }
 class ExtHostChatAgent {
@@ -318,8 +328,8 @@ class ExtHostChatAgent {
         this._proxy = _proxy;
         this._handle = _handle;
         this._requestHandler = _requestHandler;
-        this._onDidReceiveFeedback = ( (new Emitter()));
-        this._onDidPerformAction = ( (new Emitter()));
+        this._onDidReceiveFeedback = ( new Emitter());
+        this._onDidPerformAction = ( new Emitter());
     }
     acceptFeedback(feedback) {
         this._onDidReceiveFeedback.fire(feedback);
@@ -345,30 +355,28 @@ class ExtHostChatAgent {
             .filter(f => !(f && 'commandId' in f))
             .filter(f => !(f && 'message' in f));
     }
-    async provideWelcomeMessage(token) {
+    async provideWelcomeMessage(location, token) {
         if (!this._welcomeMessageProvider) {
             return [];
         }
-        const content = await this._welcomeMessageProvider.provideWelcomeMessage(token);
+        const content = await this._welcomeMessageProvider.provideWelcomeMessage(location, token);
         if (!content) {
             return [];
         }
-        return (
-             (content.map(item => {
-                if (typeof item === 'string') {
-                    return item;
-                }
-                else {
-                    return MarkdownString.from(item);
-                }
-            }))
-        );
+        return ( content.map(item => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            else {
+                return MarkdownString.from(item);
+            }
+        }));
     }
-    async provideSampleQuestions(token) {
+    async provideSampleQuestions(location, token) {
         if (!this._welcomeMessageProvider || !this._welcomeMessageProvider.provideSampleQuestions) {
             return [];
         }
-        const content = await this._welcomeMessageProvider.provideSampleQuestions(token);
+        const content = await this._welcomeMessageProvider.provideSampleQuestions(location, token);
         if (!content) {
             return [];
         }
@@ -512,7 +520,7 @@ class ExtHostChatAgent {
                 that._agentVariableProvider = v;
                 if (v) {
                     if (!v.triggerCharacters.length) {
-                        throw ( (new Error('triggerCharacters are required')));
+                        throw ( new Error('triggerCharacters are required'));
                     }
                     that._proxy.$registerAgentCompletionsProvider(that._handle, v.triggerCharacters);
                 }

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

@@ -72,24 +72,24 @@ class ChatVariableResolverResponseStream {
                 progress(value) {
                     throwIfDone(this.progress);
                     const part = new ChatResponseProgressPart$1(value);
-                    const dto = ChatResponseProgressPart.to(part);
+                    const dto = ChatResponseProgressPart.from(part);
                     _report(dto);
                     return this;
                 },
                 reference(value) {
                     throwIfDone(this.reference);
                     const part = new ChatResponseReferencePart$1(value);
-                    const dto = ChatResponseReferencePart.to(part);
+                    const dto = ChatResponseReferencePart.from(part);
                     _report(dto);
                     return this;
                 },
                 push(part) {
                     throwIfDone(this.push);
                     if (part instanceof ChatResponseReferencePart$1) {
-                        _report(ChatResponseReferencePart.to(part));
+                        _report(ChatResponseReferencePart.from(part));
                     }
                     else if (part instanceof ChatResponseProgressPart$1) {
-                        _report(ChatResponseProgressPart.to(part));
+                        _report(ChatResponseProgressPart.from(part));
                     }
                     return this;
                 }

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

@@ -89,7 +89,7 @@ class ExtHostConfigProvider {
         this._proxy = proxy;
         this._logService = logService;
         this._extHostWorkspace = extHostWorkspace;
-        this._configuration = Configuration$1.parse(data);
+        this._configuration = Configuration$1.parse(data, logService);
         this._configurationScopes = this._toMap(data.configurationScopes);
     }
     get onDidChangeConfiguration() {
@@ -97,7 +97,7 @@ class ExtHostConfigProvider {
     }
     $acceptConfigurationChanged(data, change) {
         const previous = { data: this._configuration.toData(), workspace: this._extHostWorkspace.workspace };
-        this._configuration = Configuration$1.parse(data);
+        this._configuration = Configuration$1.parse(data, this._logService);
         this._configurationScopes = this._toMap(data.configurationScopes);
         this._onDidChangeConfiguration.fire(this._toConfigurationChangeEvent(change, previous));
     }
@@ -262,7 +262,13 @@ class ExtHostConfigProvider {
         }
     }
     _toConfigurationChangeEvent(change, previous) {
-        const event = ( new ConfigurationChangeEvent(change, previous, this._configuration, this._extHostWorkspace.workspace));
+        const event = ( new ConfigurationChangeEvent(
+            change,
+            previous,
+            this._configuration,
+            this._extHostWorkspace.workspace,
+            this._logService
+        ));
         return ( Object.freeze({
             affectsConfiguration: (section, scope) => event.affectsConfiguration(section, scopeToOverrides(scope))
         }));

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

@@ -8,7 +8,7 @@ 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, ThemeIcon as ThemeIcon$1, DataBreakpoint, Thread, StackFrame } from './extHostTypes.js';
+import { SourceBreakpoint, DebugConsoleMode, Disposable, setBreakpointId, FunctionBreakpoint, Location, Position, DebugAdapterExecutable, DebugAdapterServer, DebugAdapterNamedPipeServer, DebugAdapterInlineImplementation, ThemeIcon as ThemeIcon$1, DataBreakpoint, DebugThread, DebugStackFrame } 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';
@@ -590,10 +590,10 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
         if (focusDto) {
             const session = await this.getSession(focusDto.sessionId);
             if (focusDto.kind === 'thread') {
-                focus = ( new Thread(session.api, focusDto.threadId));
+                focus = ( new DebugThread(session.api, focusDto.threadId));
             }
             else {
-                focus = ( new StackFrame(session.api, focusDto.threadId, focusDto.frameId));
+                focus = ( new DebugStackFrame(session.api, focusDto.threadId, focusDto.frameId));
             }
         }
         this._activeStackItem = focus;

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

@@ -3,6 +3,7 @@ import { illegalState } from '../../../base/common/errors.js';
 import { TextEdit } from './extHostTypes.js';
 import { TextDocumentSaveReason, Range, EndOfLine } from './extHostTypeConverters.js';
 import { LinkedList } from '../../../base/common/linkedList.js';
+import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
 class ExtHostDocumentSaveParticipant {
     constructor(_logService, _documents, _mainThreadBulkEdits, _thresholds = { timeout: 1500, errors: 3 }) {
         this._logService = _logService;
@@ -117,7 +118,7 @@ class ExtHostDocumentSaveParticipant {
                 return undefined;
             }
             if (version === document.version) {
-                return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit(dto);
+                return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit(( new SerializableObjectWithBuffers(dto)));
             }
             return Promise.reject(( new Error('concurrent_edits')));
         });

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

@@ -82,7 +82,7 @@ class ExtHostEditorTab {
             case 9 :
                 return ( new InteractiveWindowInput(URI.revive(this._dto.input.uri), URI.revive(this._dto.input.inputBoxUri)));
             case 10 :
-                return ( new ChatEditorTabInput(this._dto.input.providerId));
+                return ( new ChatEditorTabInput());
             case 11 :
                 return ( new TextMultiDiffTabInput(( this._dto.input.diffEditors.map(diff => ( new TextDiffTabInput(URI.revive(diff.original), URI.revive(diff.modified)))))));
             default:

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

@@ -72,12 +72,30 @@ class FileSystemWatcher {
         if (typeof globPattern === 'string') {
             return disposable;
         }
+        if (options?.ignoreChangeEvents && options?.ignoreCreateEvents && options?.ignoreDeleteEvents) {
+            return disposable;
+        }
         const proxy = ( mainContext.getProxy(MainContext.MainThreadFileSystemEventService));
         let recursive = false;
         if (globPattern.pattern.includes(GLOBSTAR) || globPattern.pattern.includes(GLOB_SPLIT)) {
             recursive = true;
         }
-        proxy.$watch(extension.identifier.value, this.session, globPattern.baseUri, { recursive, excludes: options?.excludes ?? [] }, Boolean(correlate));
+        let filter;
+        if (correlate) {
+            if (options?.ignoreChangeEvents || options?.ignoreCreateEvents || options?.ignoreDeleteEvents) {
+                filter = 2  | 4  | 8 ;
+                if (options?.ignoreChangeEvents) {
+                    filter &= ~2 ;
+                }
+                if (options?.ignoreCreateEvents) {
+                    filter &= ~4 ;
+                }
+                if (options?.ignoreDeleteEvents) {
+                    filter &= ~8 ;
+                }
+            }
+        }
+        proxy.$watch(extension.identifier.value, this.session, globPattern.baseUri, { recursive, excludes: options?.excludes ?? [], filter }, Boolean(correlate));
         return Disposable.from({ dispose: () => proxy.$unwatch(this.session) });
     }
     dispose() {