@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.1

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

@@ -1,6 +1,6 @@
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { mixin, equals } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { Range, Selection as Selection$1, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, location, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink } from './extHostTypeConverters.js';
+import { Range, Selection as Selection$1, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, MultiDocumentHighlight, location, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink } from './extHostTypeConverters.js';
 import { CodeActionKind, Disposable, SyntaxTokenType, DocumentSymbol, Range as Range$2, InternalDataTransferItem, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, Location, CompletionList, InlineCompletionTriggerKind } from './extHostTypes.js';
 import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
 import { MainContext } from './extHost.protocol.js';
@@ -261,6 +261,22 @@ class DocumentHighlightAdapter {
         return undefined;
     }
 }
+class MultiDocumentHighlightAdapter {
+    constructor(_documents, _provider) {
+        this._documents = _documents;
+        this._provider = _provider;
+    }
+    async provideMultiDocumentHighlights(resource, position, otherResources, token) {
+        const doc = this._documents.getDocument(resource);
+        const otherDocuments = ( otherResources.map(r => this._documents.getDocument(r)));
+        const pos = Position.to(position);
+        const value = await this._provider.provideMultiDocumentHighlights(doc, pos, otherDocuments, token);
+        if (Array.isArray(value)) {
+            return ( value.map(MultiDocumentHighlight.from));
+        }
+        return undefined;
+    }
+}
 class LinkedEditingRangeAdapter {
     constructor(_documents, _provider) {
         this._documents = _documents;
@@ -364,6 +380,7 @@ class CodeActionAdapter {
                     edit: candidate.edit && WorkspaceEdit.from(candidate.edit, undefined),
                     kind: candidate.kind && candidate.kind.value,
                     isPreferred: candidate.isPreferred,
+                    isAI: isProposedApiEnabled(this._extension, 'codeActionAI') ? candidate.isAI : false,
                     disabled: candidate.disabled?.reason
                 });
             }
@@ -1096,7 +1113,7 @@ class InlayHintsAdapter {
         const range = Range.to(ran);
         const hints = await this._provider.provideInlayHints(doc, range, token);
         if (!Array.isArray(hints) || hints.length === 0) {
-            this._logService.trace(`[InlayHints] NO inlay hints from '${this._extension.identifier.value}' for ${ran}`);
+            this._logService.trace(`[InlayHints] NO inlay hints from '${this._extension.identifier.value}' for range ${JSON.stringify(ran)}`);
             return undefined;
         }
         if (token.isCancellationRequested) {
@@ -1110,7 +1127,7 @@ class InlayHintsAdapter {
                 result.hints.push(this._convertInlayHint(hints[i], [pid, i]));
             }
         }
-        this._logService.trace(`[InlayHints] ${result.hints.length} inlay hints from '${this._extension.identifier.value}' for ${ran}`);
+        this._logService.trace(`[InlayHints] ${result.hints.length} inlay hints from '${this._extension.identifier.value}' for range ${JSON.stringify(ran)}`);
         return result;
     }
     async resolveInlayHint(id, token) {
@@ -1671,9 +1688,17 @@ class ExtHostLanguageFeatures {
         this._proxy.$registerDocumentHighlightProvider(handle, this._transformDocumentSelector(selector, extension));
         return this._createDisposable(handle);
     }
+    registerMultiDocumentHighlightProvider(extension, selector, provider) {
+        const handle = this._addNewAdapter(( new MultiDocumentHighlightAdapter(this._documents, provider)), extension);
+        this._proxy.$registerMultiDocumentHighlightProvider(handle, this._transformDocumentSelector(selector, extension));
+        return this._createDisposable(handle);
+    }
     $provideDocumentHighlights(handle, resource, position, token) {
         return this._withAdapter(handle, DocumentHighlightAdapter, adapter => adapter.provideDocumentHighlights(URI.revive(resource), position, token), undefined, token);
     }
+    $provideMultiDocumentHighlights(handle, resource, position, otherModels, token) {
+        return this._withAdapter(handle, MultiDocumentHighlightAdapter, adapter => adapter.provideMultiDocumentHighlights(URI.revive(resource), position, ( otherModels.map(model => URI.revive(model))), token), undefined, token);
+    }
     registerLinkedEditingRangeProvider(extension, selector, provider) {
         const handle = this._addNewAdapter(( new LinkedEditingRangeAdapter(this._documents, provider)), extension);
         this._proxy.$registerLinkedEditingRangeProvider(handle, this._transformDocumentSelector(selector, extension));

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

@@ -4,6 +4,7 @@ import { StandardTokenType, Range, LanguageStatusSeverity } from './extHostTypes
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 class ExtHostLanguages {
     constructor(mainContext, _documents, _commands, _uriTransformer) {
         this._documents = _documents;
@@ -125,6 +126,15 @@ class ExtHostLanguages {
                 data.text = value;
                 updateAsync();
             },
+            set text2(value) {
+                checkProposedApiEnabled(extension, 'languageStatusText');
+                data.text = value;
+                updateAsync();
+            },
+            get text2() {
+                checkProposedApiEnabled(extension, 'languageStatusText');
+                return data.text;
+            },
             get detail() {
                 return data.detail;
             },

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

@@ -2,7 +2,7 @@ import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { ResourceMap, ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
 import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
@@ -18,6 +18,9 @@ import { ExtHostNotebookEditor } from './extHostNotebookEditor.js';
 import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { filter } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { CellSearchModel } from '../../contrib/search/common/cellSearchModel.js';
+import { genericCellMatchesToTextSearchMatches } from '../../contrib/search/common/searchNotebookHelpers.js';
+import { globMatchesResource } from '../../services/editor/common/editorResolverService.js';
 class ExtHostNotebookController {
     static { this._notebookStatusBarItemProviderHandlePool = 0; }
     get activeNotebookEditor() {
@@ -26,10 +29,11 @@ class ExtHostNotebookController {
     get visibleNotebookEditors() {
         return ( this._visibleNotebookEditors.map(editor => editor.apiEditor));
     }
-    constructor(mainContext, commands, _textDocumentsAndEditors, _textDocuments, _extHostFileSystem) {
+    constructor(mainContext, commands, _textDocumentsAndEditors, _textDocuments, _extHostFileSystem, _extHostSearch) {
         this._textDocumentsAndEditors = _textDocumentsAndEditors;
         this._textDocuments = _textDocuments;
         this._extHostFileSystem = _extHostFileSystem;
+        this._extHostSearch = _extHostSearch;
         this._notebookStatusBarItemProviders = ( new Map());
         this._documents = ( new ResourceMap());
         this._editors = ( new Map());
@@ -278,6 +282,117 @@ class ExtHostNotebookController {
         };
         return fileStats;
     }
+    async $searchInNotebooks(handle, textQuery, viewTypeFileTargets, otherViewTypeFileTargets, token) {
+        const serializer = this._notebookSerializer.get(handle)?.serializer;
+        if (!serializer) {
+            return {
+                limitHit: false,
+                results: []
+            };
+        }
+        const finalMatchedTargets = ( new ResourceSet());
+        const runFileQueries = async (includes, token, textQuery) => {
+            await Promise.all(( includes.map(async (include) => await Promise.all(( include.filenamePatterns.map(filePattern => {
+                const query = {
+                    ...textQuery,
+                    ...{ type: 1 , filePattern }
+                };
+                return this._extHostSearch.doInternalFileSearchWithCustomCallback(query, token, (data) => {
+                    data.forEach(uri => {
+                        if (( finalMatchedTargets.has(uri))) {
+                            return;
+                        }
+                        const hasOtherMatches = ( otherViewTypeFileTargets.some(target => {
+                            if (include.isFromSettings && !target.isFromSettings) {
+                                return false;
+                            }
+                            else {
+                                return ( target.filenamePatterns.some(targetFilePattern => globMatchesResource(targetFilePattern, uri)));
+                            }
+                        }));
+                        if (hasOtherMatches) {
+                            return;
+                        }
+                        finalMatchedTargets.add(uri);
+                    });
+                });
+            }))))));
+            return;
+        };
+        await runFileQueries(viewTypeFileTargets, token, textQuery);
+        const results = ( new ResourceMap());
+        let limitHit = false;
+        const promises = ( Array.from(finalMatchedTargets).map(async (uri) => {
+            const cellMatches = [];
+            try {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                if (textQuery.maxResults && [...( results.values())].reduce((acc, value) => acc + value.cellResults.length, 0) > textQuery.maxResults) {
+                    limitHit = true;
+                    return;
+                }
+                const simpleCells = [];
+                const notebook = this._documents.get(uri);
+                if (notebook) {
+                    const cells = notebook.apiNotebook.getCells();
+                    cells.forEach(e => simpleCells.push({
+                        input: e.document.getText(),
+                        outputs: e.outputs.flatMap(value => ( value.items.map(output => ( output.data.toString()))))
+                    }));
+                }
+                else {
+                    const fileContent = await this._extHostFileSystem.value.readFile(uri);
+                    const bytes = VSBuffer.fromString(( fileContent.toString()));
+                    const notebook = await serializer.deserializeNotebook(bytes.buffer, token);
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    const data = NotebookData.from(notebook);
+                    data.cells.forEach(cell => simpleCells.push({
+                        input: cell.source,
+                        outputs: cell.outputs.flatMap(value => ( value.items.map(output => ( output.valueBytes.toString()))))
+                    }));
+                }
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                simpleCells.forEach((cell, index) => {
+                    const target = textQuery.contentPattern.pattern;
+                    const cellModel = ( new CellSearchModel(cell.input, undefined, cell.outputs));
+                    const inputMatches = cellModel.findInInputs(target);
+                    const outputMatches = cellModel.findInOutputs(target);
+                    const webviewResults = ( outputMatches
+                        .flatMap(outputMatch => genericCellMatchesToTextSearchMatches(outputMatch.matches, outputMatch.textBuffer))
+                        .map((textMatch, index) => {
+                        textMatch.webviewIndex = index;
+                        return textMatch;
+                    }));
+                    if (inputMatches.length > 0 || outputMatches.length > 0) {
+                        const cellMatch = {
+                            index: index,
+                            contentResults: genericCellMatchesToTextSearchMatches(inputMatches, cellModel.inputTextBuffer),
+                            webviewResults
+                        };
+                        cellMatches.push(cellMatch);
+                    }
+                });
+                const fileMatch = {
+                    resource: uri, cellResults: cellMatches
+                };
+                results.set(uri, fileMatch);
+                return;
+            }
+            catch (e) {
+                return;
+            }
+        }));
+        await Promise.all(promises);
+        return {
+            limitHit,
+            results: [...( results.values())]
+        };
+    }
     async _validateWriteFile(uri, options) {
         const stat = await this._extHostFileSystem.value.stat(uri);
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== files.ETAG_DISABLED &&

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

@@ -8,11 +8,10 @@ import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { Cache } from './cache.js';
 import { MainContext } from './extHost.protocol.js';
 import { ApiCommand, ApiCommandArgument, ApiCommandResult } from './extHostCommands.js';
 import { NotebookCellOutput as NotebookCellOutput$1, NotebookCellOutputItem, NotebookKernelSourceAction, NotebookCellExecutionState, NotebookRendererScript } from './extHostTypeConverters.js';
-import { NotebookCellOutput, NotebookCellExecutionState as NotebookCellExecutionState$1, NotebookControllerAffinity2 } from './extHostTypes.js';
+import { NotebookCellOutput, NotebookCellExecutionState as NotebookCellExecutionState$1, NotebookControllerAffinity2, NotebookVariablesRequestKind } from './extHostTypes.js';
 import { asWebviewUri } from '../../contrib/webview/common/webview.js';
 import { CellExecutionUpdateType } from '../../contrib/notebook/common/notebookExecutionService.js';
 import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
@@ -29,7 +28,6 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
         this._kernelDetectionTaskHandlePool = 0;
         this._kernelSourceActionProviders = ( new Map());
         this._kernelSourceActionProviderHandlePool = 0;
-        this._kernelSourceActionProviderCache = ( new Cache('NotebookKernelSourceActionProviderCache'));
         this._kernelData = ( new Map());
         this._handlePool = 0;
         this._onDidChangeCellExecutionState = ( new Emitter());
@@ -84,6 +82,7 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
         };
         let _executeHandler = handler ?? _defaultExecutHandler;
         let _interruptHandler;
+        let _variableProvider;
         this._proxy.$addKernel(handle, data).catch(err => {
             console.log(err);
             isDisposed = true;
@@ -157,6 +156,16 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
                 data.supportsInterrupt = Boolean(value);
                 _update();
             },
+            set variableProvider(value) {
+                checkProposedApiEnabled(extension, 'notebookVariableProvider');
+                _variableProvider = value;
+                data.hasVariableProvider = !!value;
+                value?.onDidChangeVariables(e => that._proxy.$variablesUpdated(e.uri));
+                _update();
+            },
+            get variableProvider() {
+                return _variableProvider;
+            },
             createNotebookCellExecution(cell) {
                 if (isDisposed) {
                     throw new Error('notebook controller is DISPOSED');
@@ -258,7 +267,6 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
         const provider = this._kernelSourceActionProviders.get(handle);
         if (provider) {
             const disposables = ( new DisposableStore());
-            this._kernelSourceActionProviderCache.add([disposables]);
             const ret = await provider.provideNotebookKernelSourceActions(token);
             return ( (ret ?? []).map(
                 item => NotebookKernelSourceAction.from(item, this._commands.converter, disposables)
@@ -329,6 +337,26 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
             }
         }
     }
+    async $provideVariables(handle, requestId, notebookUri, parentName, kind, start, token) {
+        const obj = this._kernelData.get(handle);
+        if (!obj) {
+            return;
+        }
+        const document = this._extHostNotebook.getNotebookDocument(URI.revive(notebookUri));
+        const variableProvider = obj.controller.variableProvider;
+        if (!variableProvider) {
+            return;
+        }
+        const parent = parentName ? { name: parentName, value: '' } : undefined;
+        const requestKind = kind === 'named' ? NotebookVariablesRequestKind.Named : NotebookVariablesRequestKind.Indexed;
+        const variables = variableProvider.provideVariables(document.apiNotebook, parent, requestKind, start, token);
+        for await (const variable of variables) {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            this._proxy.$receiveVariable(requestId, variable);
+        }
+    }
     $acceptKernelMessageFromRenderer(handle, editorId, message) {
         const obj = this._kernelData.get(handle);
         if (!obj) {

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

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableStore, MutableDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { asPromise } from 'monaco-editor/esm/vs/base/common/async.js';
 import { MainContext } from './extHost.protocol.js';
 import { sortedDiff, equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
@@ -13,7 +13,17 @@ import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { MarkdownString } from './extHostTypeConverters.js';
 import { isProposedApiEnabled, checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
 var ExtHostSCM_1;
+function isUri(thing) {
+    return thing instanceof URI;
+}
+function uriEquals(a, b) {
+    if (a.scheme === Schemas.file && b.scheme === Schemas.file && isLinux) {
+        return ( a.toString()) === ( b.toString());
+    }
+    return ( a.toString()).toLowerCase() === ( b.toString()).toLowerCase();
+}
 function getIconResource(decorations) {
     if (!decorations) {
         return undefined;
@@ -31,6 +41,21 @@ function getIconResource(decorations) {
         return undefined;
     }
 }
+function getInputBoxActionButtonIcon(actionButton) {
+    if (!actionButton?.icon) {
+        return undefined;
+    }
+    else if (URI.isUri(actionButton.icon)) {
+        return actionButton.icon;
+    }
+    else if (ThemeIcon.isThemeIcon(actionButton.icon)) {
+        return actionButton.icon;
+    }
+    else {
+        const icon = actionButton.icon;
+        return { light: icon.light, dark: icon.dark };
+    }
+}
 function getHistoryItemIconDto(historyItem) {
     if (!historyItem.icon) {
         return undefined;
@@ -46,6 +71,21 @@ function getHistoryItemIconDto(historyItem) {
         return { light: icon.light, dark: icon.dark };
     }
 }
+function getSourceControlInputBoxValueProviderIcon(provider) {
+    if (!provider.icon) {
+        return undefined;
+    }
+    else if (URI.isUri(provider.icon)) {
+        return provider.icon;
+    }
+    else if (ThemeIcon.isThemeIcon(provider.icon)) {
+        return provider.icon;
+    }
+    else {
+        const icon = provider.icon;
+        return { light: icon.light, dark: icon.dark };
+    }
+}
 function compareResourceThemableDecorations(a, b) {
     if (!a.iconPath && !b.iconPath) {
         return 0;
@@ -134,6 +174,9 @@ function compareCommands(a, b) {
         if (aArg === bArg) {
             continue;
         }
+        if (isUri(aArg) && isUri(bArg) && uriEquals(aArg, bArg)) {
+            continue;
+        }
         return aArg < bArg ? -1 : 1;
     }
     return 0;
@@ -183,15 +226,6 @@ function commandEquals(a, b) {
 function commandListEquals(a, b) {
     return equals(a, b, commandEquals);
 }
-function historyItemGroupEquals(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (!a || !b) {
-        return false;
-    }
-    return a.id === b.id && a.label === b.label && a.upstream?.id === b.upstream?.id && a.upstream?.label === b.upstream?.label;
-}
 class ExtHostSCMInputBox {
     #proxy;
     #extHostDocuments;
@@ -247,12 +281,29 @@ class ExtHostSCMInputBox {
         this._visible = visible;
         this.#proxy.$setInputBoxVisibility(this._sourceControlHandle, visible);
     }
+    get actionButton() {
+        checkProposedApiEnabled(this._extension, 'scmInputBoxActionButton');
+        return this._actionButton;
+    }
+    set actionButton(actionButton) {
+        checkProposedApiEnabled(this._extension, 'scmInputBoxActionButton');
+        this._actionButtonDisposables.value = ( new DisposableStore());
+        this._actionButton = actionButton;
+        const internal = actionButton !== undefined ?
+            {
+                command: this._commands.converter.toInternal(actionButton.command, this._actionButtonDisposables.value),
+                icon: getInputBoxActionButtonIcon(actionButton),
+                enabled: actionButton.enabled
+            } : undefined;
+        this.#proxy.$setInputBoxActionButton(this._sourceControlHandle, internal ?? null);
+    }
     get document() {
         checkProposedApiEnabled(this._extension, 'scmTextDocument');
         return this.#extHostDocuments.getDocument(this._documentUri);
     }
-    constructor(_extension, _extHostDocuments, proxy, _sourceControlHandle, _documentUri) {
+    constructor(_extension, _commands, _extHostDocuments, proxy, _sourceControlHandle, _documentUri) {
         this._extension = _extension;
+        this._commands = _commands;
         this._sourceControlHandle = _sourceControlHandle;
         this._documentUri = _documentUri;
         this._value = '';
@@ -260,6 +311,7 @@ class ExtHostSCMInputBox {
         this._placeholder = '';
         this._enabled = true;
         this._visible = true;
+        this._actionButtonDisposables = ( new MutableDisposable());
         this.#extHostDocuments = _extHostDocuments;
         this.#proxy = proxy;
     }
@@ -340,7 +392,7 @@ class ExtHostSourceControlResourceGroup {
                 const sourceUri = r.resourceUri;
                 let command;
                 if (r.command) {
-                    if (r.command.command === 'vscode.open' || r.command.command === 'vscode.diff') {
+                    if (r.command.command === 'vscode.open' || r.command.command === 'vscode.diff' || r.command.command === 'vscode.changes') {
                         const disposables = ( new DisposableStore());
                         command = this._commands.converter.toInternal(r.command, disposables);
                         this._resourceStatesDisposablesMap.set(handle, disposables);
@@ -428,9 +480,6 @@ class ExtHostSourceControl {
         this.#proxy.$updateSourceControl(this.handle, { hasHistoryProvider: !!historyProvider });
         if (historyProvider) {
             this._historyProviderDisposable.value.add(historyProvider.onDidChangeCurrentHistoryItemGroup(() => {
-                if (historyItemGroupEquals(this._historyProviderCurrentHistoryItemGroup, historyProvider?.currentHistoryItemGroup)) {
-                    return;
-                }
                 this._historyProviderCurrentHistoryItemGroup = historyProvider?.currentHistoryItemGroup;
                 this.#proxy.$onDidChangeHistoryProviderCurrentHistoryItemGroup(this.handle, this._historyProviderCurrentHistoryItemGroup);
             }));
@@ -535,6 +584,7 @@ class ExtHostSourceControl {
         }));
         this._inputBox = ( new ExtHostSCMInputBox(
             _extension,
+            _commands,
             _extHostDocuments,
             this.#proxy,
             this.handle,
@@ -612,6 +662,7 @@ ExtHostSourceControl.__decorator = ( __decorate([
 let ExtHostSCM = class ExtHostSCM {
     static { ExtHostSCM_1 = this; }
     static { this._handlePool = 0; }
+    static { this._inputBoxValueProviderHandlePool = 0; }
     get onDidChangeActiveProvider() { return this._onDidChangeActiveProvider.event; }
     constructor(mainContext, _commands, _extHostDocuments, logService) {
         this._commands = _commands;
@@ -620,6 +671,7 @@ let ExtHostSCM = class ExtHostSCM {
         this._sourceControls = ( new Map());
         this._sourceControlsByExtension = ( new ExtensionIdentifierMap());
         this._onDidChangeActiveProvider = ( new Emitter());
+        this._inputBoxValueProviders = ( new Map());
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadSCM));
         this._telemetry = ( mainContext.getProxy(MainContext.MainThreadTelemetry));
         _commands.registerArgumentProcessor({
@@ -674,6 +726,23 @@ let ExtHostSCM = class ExtHostSCM {
         this._sourceControlsByExtension.set(extension.identifier, sourceControls);
         return sourceControl;
     }
+    registerSourceControlInputBoxValueProvider(extension, sourceControlId, provider) {
+        this.logService.trace('ExtHostSCM#registerSourceControlInputBoxValueProvider', extension.identifier.value, provider.label);
+        const handle = ExtHostSCM_1._inputBoxValueProviderHandlePool++;
+        this._inputBoxValueProviders.set(handle, provider);
+        this._proxy.$registerSourceControlInputBoxValueProvider(handle, sourceControlId, provider.label, getSourceControlInputBoxValueProviderIcon(provider));
+        return toDisposable(() => {
+            this._proxy.$unregisterSourceControlInputBoxValueProvider(handle);
+            this._inputBoxValueProviders.delete(handle);
+        });
+    }
+    async $provideInputBoxValue(inputBoxValueProviderHandle, rootUri, context, token) {
+        const provider = this._inputBoxValueProviders.get(inputBoxValueProviderHandle);
+        if (!provider) {
+            return undefined;
+        }
+        return (await provider.provideValue(URI.revive(rootUri), context, token)) ?? undefined;
+    }
     getLastInputBox(extension) {
         this.logService.trace('ExtHostSCM#getLastInputBox', extension.identifier.value);
         const sourceControls = this._sourceControlsByExtension.get(extension.identifier);
@@ -753,14 +822,7 @@ let ExtHostSCM = class ExtHostSCM {
     async $provideHistoryItems(sourceControlHandle, historyItemGroupId, options, token) {
         const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;
         const historyItems = await historyProvider?.provideHistoryItems(historyItemGroupId, options, token);
-        return historyItems?.map(item => ({
-            id: item.id,
-            parentIds: item.parentIds,
-            label: item.label,
-            description: item.description,
-            icon: getHistoryItemIconDto(item),
-            timestamp: item.timestamp,
-        })) ?? undefined;
+        return historyItems?.map(item => ({ ...item, icon: getHistoryItemIconDto(item) })) ?? undefined;
     }
     async $provideHistoryItemChanges(sourceControlHandle, historyItemId, token) {
         const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;

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

@@ -65,6 +65,9 @@ let ExtHostSearch = class ExtHostSearch {
             throw new Error('unknown provider: ' + handle);
         }
     }
+    async doInternalFileSearchWithCustomCallback(query, token, handleFileMatch) {
+        return { messages: [] };
+    }
     $clearCache(cacheKey) {
         this._fileSearchManager.clearCache(cacheKey);
         return Promise.resolve(undefined);

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

@@ -0,0 +1,42 @@
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext } from './extHost.protocol.js';
+class ExtHostSpeech {
+    static { this.ID_POOL = 1; }
+    constructor(mainContext) {
+        this.providers = ( new Map());
+        this.sessions = ( new Map());
+        this.proxy = ( mainContext.getProxy(MainContext.MainThreadSpeech));
+    }
+    async $createSpeechToTextSession(handle, session) {
+        const provider = this.providers.get(handle);
+        if (!provider) {
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        const cts = ( new CancellationTokenSource());
+        this.sessions.set(session, cts);
+        const speechToTextSession = disposables.add(provider.provideSpeechToTextSession(cts.token));
+        disposables.add(speechToTextSession.onDidChange(e => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            this.proxy.$emitSpeechToTextEvent(session, e);
+        }));
+        disposables.add(cts.token.onCancellationRequested(() => disposables.dispose()));
+    }
+    async $cancelSpeechToTextSession(session) {
+        this.sessions.get(session)?.dispose(true);
+        this.sessions.delete(session);
+    }
+    registerProvider(extension, identifier, provider) {
+        const handle = ExtHostSpeech.ID_POOL++;
+        this.providers.set(handle, provider);
+        this.proxy.$registerProvider(handle, identifier, { extension, displayName: extension.value });
+        return toDisposable(() => {
+            this.proxy.$unregisterProvider(handle);
+            this.providers.delete(handle);
+        });
+    }
+}
+export { ExtHostSpeech };

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

@@ -621,7 +621,8 @@ let WorkerExtHostTask = class WorkerExtHostTask extends ExtHostTaskBase {
             for (const task of value) {
                 this.checkDeprecation(task, handler);
                 if (!task.definition || !validTypes[task.definition.type]) {
-                    this._logService.warn(`The task [${task.source}, ${task.name}] uses an undefined task type. The task will be ignored in the future.`);
+                    const source = task.source ? task.source : 'No task source';
+                    this._logService.warn(`The task [${source}, ${task.name}] uses an undefined task type. The task will be ignored in the future.`);
                 }
                 const taskDTO = TaskDTO.from(task, handler.extension);
                 if (taskDTO && CustomExecutionDTO.is(taskDTO.execution)) {

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

@@ -80,6 +80,7 @@ let ExtHostTelemetry = class ExtHostTelemetry extends Disposable {
         commonProperties['common.extversion'] = extension.version;
         commonProperties['common.vscodemachineid'] = this.initData.telemetryInfo.machineId;
         commonProperties['common.vscodesessionid'] = this.initData.telemetryInfo.sessionId;
+        commonProperties['common.sqmid'] = this.initData.telemetryInfo.sqmId;
         commonProperties['common.vscodeversion'] = this.initData.version;
         commonProperties['common.isnewappinstall'] = isNewAppInstall(this.initData.telemetryInfo.firstSessionDate);
         commonProperties['common.product'] = this.initData.environment.appHost;

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

@@ -48,9 +48,9 @@ class ExtHostTerminal {
             get selection() {
                 return that._selection;
             },
-            sendText(text, addNewLine = true) {
+            sendText(text, shouldExecute = true) {
                 that._checkDisposed();
-                that._proxy.$sendText(that._id, text, addNewLine);
+                that._proxy.$sendText(that._id, text, shouldExecute);
             },
             show(preserveFocus) {
                 that._checkDisposed();
@@ -85,7 +85,7 @@ class ExtHostTerminal {
             name: options.name,
             shellPath: options.shellPath ?? undefined,
             shellArgs: options.shellArgs ?? undefined,
-            cwd: options.cwd ?? undefined,
+            cwd: options.cwd ?? internalOptions?.cwd ?? undefined,
             env: options.env ?? undefined,
             icon: asTerminalIcon(options.iconPath) ?? undefined,
             color: ThemeColor.isThemeColor(options.color) ? options.color.id : undefined,