@codingame/monaco-vscode-api 30.0.1 → 31.0.0

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

@@ -9,10 +9,12 @@ import { ResourceSet, ResourceMap } from '../../../base/common/map.js';
 import { MarshalledId } from '../../../base/common/marshallingIds.js';
 import { equals } from '../../../base/common/objects.js';
 import { URI } from '../../../base/common/uri.js';
+import { generateUuid } from '../../../base/common/uuid.js';
 import { SymbolKind, SymbolKinds } from '../../../editor/common/languages.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { IDiagnosticVariableEntryFilterData, PromptFileVariableKind, toPromptFileVariableEntry } from '../../contrib/chat/common/attachments/chatVariableEntries.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
+import { isUntitledChatSession } from '../../contrib/chat/common/model/chatUri.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatAgentResponseStream } from './extHostChatAgents2.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
@@ -20,6 +22,44 @@ import { ChatSessionItem, ChatAgentRequest, ChatRequestModeInstructions, Locatio
 import { Disposable as Disposable$1, ChatRequestTurn, ChatReferenceDiagnostic } from './extHostTypes.js';
 import { Location as Location$1 } from './extHostTypes/location.js';
 
+class ChatSessionInputStateImpl {
+    #groups;
+    #onChangedDelegate;
+    #onDidChangeEmitter;
+    #sessionResource;
+    get sessionResource() {
+        return this.#sessionResource;
+    }
+    set sessionResource(value) {
+        this.#sessionResource = value;
+    }
+    #untitledSessionResource;
+    get untitledSessionResource() {
+        return this.#untitledSessionResource;
+    }
+    set untitledSessionResource(value) {
+        this.#untitledSessionResource = value;
+    }
+    constructor(groups, onChangedDelegate) {
+        this.#onDidChangeEmitter = ( new Emitter());
+        this.onDidChange = this.#onDidChangeEmitter.event;
+        this.#groups = groups;
+        this.#onChangedDelegate = onChangedDelegate;
+    }
+    get groups() {
+        return this.#groups;
+    }
+    set groups(value) {
+        this.#groups = value;
+        this.#onChangedDelegate?.();
+    }
+    _fireDidChange() {
+        this.#onDidChangeEmitter.fire();
+    }
+    _setGroups(groups) {
+        this.#groups = groups;
+    }
+}
 class ChatSessionItemImpl {
     #label;
     #iconPath;
@@ -255,7 +295,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         this._contentProviderHandlePool = 0;
         this._chatSessionContentProviders = ( new Map());
         this._extHostChatSessions = ( new ResourceMap());
-        this._providerOptionGroups = ( new Map());
+        this._proxyCommands = ( new Map());
         this._proxy = ( this._extHostRpc.getProxy(MainContext.MainThreadChatSessions));
         commands.registerArgumentProcessor({
             processArgument: arg => {
@@ -287,6 +327,9 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             createChatSessionItem: (_resource, _label) => {
                 throw ( new Error("Not implemented for providers"));
             },
+            createChatSessionInputState: _options => {
+                return ( new ChatSessionInputStateImpl([]));
+            },
             onDidChangeChatSessionItemState: onDidChangeChatSessionItemStateEmitter.event,
             newChatSessionItemHandler: undefined,
             dispose: () => {
@@ -302,7 +345,8 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             controller,
             extension,
             disposable: disposables,
-            onDidChangeChatSessionItemStateEmitter
+            onDidChangeChatSessionItemStateEmitter,
+            inputStates: ( new Set())
         });
         this._proxy.$registerChatSessionItemController(controllerHandle, chatSessionType);
         if (provider.onDidChangeChatSessionItems) {
@@ -320,13 +364,16 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 this._proxy.$onDidCommitChatSessionItem(controllerHandle, original.resource, modified.resource);
             }));
         }
-        return {
+        const disposable = {
             dispose: () => {
                 this._chatSessionItemControllers.delete(controllerHandle);
                 disposables.dispose();
                 this._proxy.$unregisterChatSessionItemController(controllerHandle);
             }
         };
+        return Object.assign(disposable, {
+            onDidChangeChatSessionItemState: onDidChangeChatSessionItemStateEmitter.event
+        });
     }
     createChatSessionItemController(extension, id, refreshHandler) {
         const controllerHandle = this._itemControllerHandlePool++;
@@ -334,7 +381,9 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         let isDisposed = false;
         let newChatSessionItemHandler;
         let forkHandler;
+        let provideChatSessionInputStateHandler;
         const onDidChangeChatSessionItemStateEmitter = disposables.add(( new Emitter()));
+        const inputStates = ( new Set());
         const collection = ( new ChatSessionItemCollectionImpl(controllerHandle, this._proxy));
         const controller = ( Object.freeze({
             id,
@@ -370,6 +419,40 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             set forkHandler(handler) {
                 forkHandler = handler;
             },
+            get getChatSessionInputState() {
+                return provideChatSessionInputStateHandler;
+            },
+            set getChatSessionInputState(handler) {
+                provideChatSessionInputStateHandler = handler;
+            },
+            createChatSessionInputState: groups => {
+                if (isDisposed) {
+                    throw ( new Error("ChatSessionItemController has been disposed"));
+                }
+                const inputState = ( new ChatSessionInputStateImpl(groups, () => {
+                    const entry = this._chatSessionItemControllers.get(controllerHandle);
+                    if (entry) {
+                        entry.optionGroups = inputState.groups;
+                    }
+                    const wrappedGroups = this._wrapOptionGroupCommands(controllerHandle, inputState.groups);
+                    const serializableGroups = ( wrappedGroups.map(g => ({
+                        id: g.id,
+                        name: g.name,
+                        description: g.description,
+                        items: g.items,
+                        selected: g.selected,
+                        when: g.when,
+                        icon: g.icon,
+                        commands: g.commands
+                    })));
+                    const resource = inputState.sessionResource ?? inputState.untitledSessionResource;
+                    if (resource) {
+                        void this._proxy.$updateChatSessionInputState(controllerHandle, resource, serializableGroups);
+                    }
+                }));
+                inputStates.add(inputState);
+                return inputState;
+            },
             dispose: () => {
                 isDisposed = true;
                 disposables.dispose();
@@ -380,7 +463,8 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             extension,
             disposable: disposables,
             chatSessionType: id,
-            onDidChangeChatSessionItemStateEmitter
+            onDidChangeChatSessionItemStateEmitter,
+            inputStates
         });
         this._proxy.$registerChatSessionItemController(controllerHandle, id);
         disposables.add(toDisposable(() => {
@@ -393,6 +477,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         const handle = this._contentProviderHandlePool++;
         const disposables = ( new DisposableStore());
         this._chatSessionContentProviders.set(handle, {
+            chatSessionScheme,
             provider,
             extension,
             capabilities,
@@ -425,13 +510,31 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             throw ( new Error(`No provider for handle ${handle}`));
         }
         const sessionResource = URI.revive(sessionResourceComponents);
+        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
+        let inputState;
+        if (controllerData?.controller.getChatSessionInputState) {
+            const result = await controllerData.controller.getChatSessionInputState(isUntitledChatSession(sessionResource) ? undefined : sessionResource, {
+                previousInputState: this._createInputStateFromOptions(controllerData.optionGroups ?? [], context.initialSessionOptions)
+            }, token);
+            if (result) {
+                inputState = result;
+            }
+        }
+        inputState ??= this._createInputStateFromOptions(controllerData?.optionGroups ?? [], context.initialSessionOptions);
+        if (inputState instanceof ChatSessionInputStateImpl) {
+            if (isUntitledChatSession(sessionResource)) {
+                inputState.untitledSessionResource = sessionResource;
+            } else {
+                inputState.sessionResource = sessionResource;
+            }
+        }
         const session = await provider.provider.provideChatSessionContent(sessionResource, token, {
-            sessionOptions: context?.initialSessionOptions ?? []
+            sessionOptions: context?.initialSessionOptions ?? [],
+            inputState
         });
         if (token.isCancellationRequested) {
             throw ( new CancellationError());
         }
-        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
         const sessionDisposables = ( new DisposableStore());
         const id = ( sessionResource.toString());
         const chatSession = ( new ExtHostChatSession(session, provider.extension, {
@@ -490,23 +593,44 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             this._logService.warn(`No provider for handle ${handle}`);
             return;
         }
-        if (!provider.provider.provideHandleOptionsChange) {
-            this._logService.debug(
-                `Provider for handle ${handle} does not implement provideHandleOptionsChange`
-            );
+        if (provider.provider.provideHandleOptionsChange) {
+            try {
+                const updatesToSend = ( Object.entries(updates).map(([optionId, value]) => ({
+                    optionId,
+                    value: value === undefined ? undefined : (typeof value === "string" ? value : value.id)
+                })));
+                provider.provider.provideHandleOptionsChange(sessionResource, updatesToSend, token);
+            } catch (error) {
+                this._logService.error(
+                    `Error calling provideHandleOptionsChange for handle ${handle}, sessionResource ${sessionResource}:`,
+                    error
+                );
+            }
             return;
         }
-        try {
-            const updatesToSend = ( Object.entries(updates).map(([optionId, value]) => ({
-                optionId,
-                value: value === undefined ? undefined : (typeof value === "string" ? value : value.id)
-            })));
-            provider.provider.provideHandleOptionsChange(sessionResource, updatesToSend, token);
-        } catch (error) {
-            this._logService.error(
-                `Error calling provideHandleOptionsChange for handle ${handle}, sessionResource ${sessionResource}:`,
-                error
-            );
+        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
+        if (!controllerData || !controllerData.controller.getChatSessionInputState) {
+            this._logService.warn(`No valid controller found for scheme ${sessionResource.scheme}`);
+            return;
+        }
+        for (const inputState of controllerData?.inputStates ?? []) {
+            const updatedGroups = ( inputState.groups.map(group => {
+                const update = updates[group.id];
+                if (!update) {
+                    return group;
+                }
+                const selectedId = typeof update === "string" ? update : update.id;
+                const selectedItem = group.items.find(item => item.id === selectedId);
+                if (!selectedItem) {
+                    return group;
+                }
+                return {
+                    ...group,
+                    selected: selectedItem
+                };
+            }));
+            inputState._setGroups(updatedGroups);
+            inputState._fireDidChange();
         }
     }
     async $provideChatSessionProviderOptions(handle, token) {
@@ -529,7 +653,10 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 newSessionOptions
             } = result;
             if (optionGroups) {
-                this._providerOptionGroups.set(handle, optionGroups);
+                const controllerData = this.getChatSessionItemController(entry.chatSessionScheme);
+                if (controllerData) {
+                    controllerData.optionGroups = optionGroups;
+                }
             }
             return {
                 optionGroups,
@@ -621,6 +748,82 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         }
         return undefined;
     }
+    _createInputStateFromOptions(groups, sessionOptions) {
+        if (!sessionOptions?.length) {
+            return ( new ChatSessionInputStateImpl(groups));
+        }
+        const resolvedGroups = ( groups.map(group => {
+            const match = sessionOptions.find(o => o.optionId === group.id);
+            if (!match) {
+                return group;
+            }
+            const selectedItem = group.items.find(item => item.id === match.value);
+            if (!selectedItem) {
+                return group;
+            }
+            return {
+                ...group,
+                selected: selectedItem
+            };
+        }));
+        return ( new ChatSessionInputStateImpl(resolvedGroups));
+    }
+    async getInputStateForSession(sessionResource, initialSessionOptions, token) {
+        const scheme = sessionResource?.scheme;
+        const controllerData = scheme ? this.getChatSessionItemController(scheme) : undefined;
+        const resolvedResource = sessionResource && !isUntitledChatSession(sessionResource) ? sessionResource : undefined;
+        if (controllerData?.controller.getChatSessionInputState) {
+            const result = await controllerData.controller.getChatSessionInputState(resolvedResource, {
+                previousInputState: this._createInputStateFromOptions(controllerData.optionGroups ?? [], initialSessionOptions)
+            }, token);
+            if (result) {
+                if (result instanceof ChatSessionInputStateImpl) {
+                    if (sessionResource && isUntitledChatSession(sessionResource)) {
+                        result.untitledSessionResource = sessionResource;
+                    } else if (sessionResource) {
+                        result.sessionResource = resolvedResource;
+                    }
+                }
+                return result;
+            }
+        }
+        const fallback = this._createInputStateFromOptions(controllerData?.optionGroups ?? [], initialSessionOptions);
+        fallback.sessionResource = resolvedResource;
+        return fallback;
+    }
+    _wrapOptionGroupCommands(controllerHandle, groups) {
+        const controllerData = this._chatSessionItemControllers.get(controllerHandle);
+        if (!controllerData?.controller.getChatSessionInputState) {
+            return groups;
+        }
+        return ( groups.map(group => {
+            if (!group.commands?.length) {
+                return group;
+            }
+            return {
+                ...group,
+                commands: ( group.commands.map(command => {
+                    const proxyId = `_chatSession.proxyCommand.${generateUuid()}`;
+                    this._proxyCommands.set(proxyId, {
+                        originalCommandId: command.command,
+                        controllerHandle
+                    });
+                    this.commands.registerCommand(true, proxyId, async (...args) => {
+                        const sessionResource = args[0] instanceof URI ? args[0] : undefined;
+                        const inputState = await this.getInputStateForSession(sessionResource, undefined, CancellationToken.None);
+                        return this.commands.executeCommand(command.command, {
+                            inputState,
+                            sessionResource
+                        }, ...(command.arguments ?? []));
+                    });
+                    return {
+                        ...command,
+                        command: proxyId
+                    };
+                }))
+            };
+        }));
+    }
     async getModelForRequest(request, extension) {
         let model;
         if (request.userSelectedModelId) {
@@ -718,25 +921,6 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             participant: turn.participant
         };
     }
-    async $invokeOptionGroupSearch(providerHandle, optionGroupId, query, token) {
-        const optionGroups = this._providerOptionGroups.get(providerHandle);
-        if (!optionGroups) {
-            this._logService.warn(`No option groups found for provider handle ${providerHandle}`);
-            return [];
-        }
-        const group = optionGroups.find(g => g.id === optionGroupId);
-        if (!group || !group.onSearch) {
-            this._logService.warn(`No onSearch callback found for option group ${optionGroupId}`);
-            return [];
-        }
-        try {
-            const results = await group.onSearch(query, token);
-            return results ?? [];
-        } catch (error) {
-            this._logService.error(`Error calling onSearch for option group ${optionGroupId}:`, error);
-            return [];
-        }
-    }
     async $refreshChatSessionItems(handle, token) {
         const controllerData = this._chatSessionItemControllers.get(handle);
         if (!controllerData) {
@@ -755,16 +939,27 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         if (!handler) {
             return undefined;
         }
+        const previousInputState = this._createInputStateFromOptions(controllerData.optionGroups ?? [], request.initialSessionOptions);
+        let inputState;
+        if (controllerData.controller.getChatSessionInputState) {
+            inputState = await controllerData.controller.getChatSessionInputState(undefined, {
+                previousInputState
+            }, token);
+        } else {
+            inputState = previousInputState;
+        }
         const item = await handler({
             request: {
                 prompt: request.prompt,
                 command: request.command
             },
-            sessionOptions: request.initialSessionOptions ?? []
+            sessionOptions: request.initialSessionOptions ?? [],
+            inputState
         }, token);
         if (!item) {
             return undefined;
         }
+        controllerData.controller.items.add(item);
         return ChatSessionItem.from(item);
     }
     $onDidChangeChatSessionItemState(controllerHandle, sessionResourceComponents, archived) {
@@ -782,6 +977,47 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         item.archived = archived;
         controllerData.onDidChangeChatSessionItemStateEmitter.fire(item);
     }
+    async $provideChatSessionInputState(controllerHandle, sessionResourceComponents, token) {
+        const controllerData = this._chatSessionItemControllers.get(controllerHandle);
+        if (!controllerData) {
+            this._logService.warn(`No controller found for handle ${controllerHandle}`);
+            return undefined;
+        }
+        const handler = controllerData.controller.getChatSessionInputState;
+        if (!handler) {
+            return undefined;
+        }
+        const sessionResource = sessionResourceComponents ? URI.revive(sessionResourceComponents) : undefined;
+        const inputState = await handler(
+            !sessionResource || isUntitledChatSession(sessionResource) ? undefined : sessionResource,
+            {
+                previousInputState: undefined
+            },
+            token
+        );
+        if (!inputState) {
+            return undefined;
+        }
+        if (inputState instanceof ChatSessionInputStateImpl && sessionResource) {
+            if (isUntitledChatSession(sessionResource)) {
+                inputState.untitledSessionResource = sessionResource;
+            } else {
+                inputState.sessionResource = sessionResource;
+            }
+        }
+        controllerData.optionGroups = inputState.groups;
+        const wrappedGroups = this._wrapOptionGroupCommands(controllerHandle, inputState.groups);
+        return ( wrappedGroups.map(g => ({
+            id: g.id,
+            name: g.name,
+            description: g.description,
+            items: g.items,
+            selected: g.selected,
+            when: g.when,
+            icon: g.icon,
+            commands: g.commands
+        })));
+    }
 };
 ExtHostChatSessions = ( __decorate([( __param(2, IExtHostRpcService)), ( __param(3, ILogService))], ExtHostChatSessions));
 

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

@@ -125,7 +125,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            2746,
+                            2741,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),

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

@@ -614,14 +614,14 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             extensionTestsLocationURI
         } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2747, "Cannot load test runner."))));
+            throw ( new Error(( localize(2742, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
         const testRunner = await (isESM ? this._loadESMModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))) : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
         if (!testRunner || typeof testRunner.run !== "function") {
             throw ( new Error(( localize(
-                2748,
+                2743,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));

package/vscode/src/vs/workbench/api/common/extHostGitExtensionService.d.ts

@@ -16,7 +16,7 @@ export declare class ExtHostGitExtensionService extends Disposable implements IE
     private readonly _proxy;
     private readonly _repositories;
     private readonly _repositoryByUri;
-    private readonly _disposables;
+    private readonly _repositoryStateChangeListeners;
     constructor(extHostRpc: IExtHostRpcService, _extHostExtensionService: IExtHostExtensionService);
     $isGitExtensionAvailable(): Promise<boolean>;
     $openRepository(uri: UriComponents): Promise<{
@@ -27,7 +27,7 @@ export declare class ExtHostGitExtensionService extends Disposable implements IE
     $getRefs(handle: number, query: GitRefQueryDto, token?: vscode.CancellationToken): Promise<GitRefDto[]>;
     $getRepositoryState(handle: number): Promise<GitRepositoryStateDto | undefined>;
     private _getRepositoryState;
-    private _getBranchBase;
+    private _setRepositoryStateChangeListener;
     $diffBetweenWithStats(handle: number, ref1: string, ref2: string, path?: string): Promise<GitDiffChangeDto[]>;
     $diffBetweenWithStats2(handle: number, ref: string, path?: string): Promise<GitDiffChangeDto[]>;
     private _ensureGitApi;

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

@@ -1,7 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Event } from '../../../base/common/event.js';
-import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { Disposable, DisposableMap } from '../../../base/common/lifecycle.js';
 import { URI } from '../../../base/common/uri.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
@@ -30,7 +29,6 @@ function toGitBranchDto(branch) {
         commit: branch.commit,
         type: toGitRefTypeDto(branch.type),
         remote: branch.remote,
-        base: branch.base,
         upstream: branch.upstream ? toGitUpstreamRefDto(branch.upstream) : undefined,
         ahead: branch.ahead,
         behind: branch.behind
@@ -105,7 +103,7 @@ let ExtHostGitExtensionService = class ExtHostGitExtensionService extends Dispos
         this._extHostExtensionService = _extHostExtensionService;
         this._repositories = ( new Map());
         this._repositoryByUri = ( new ResourceMap());
-        this._disposables = this._register(( new DisposableStore()));
+        this._repositoryStateChangeListeners = ( new DisposableMap());
         this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadGitExtension));
     }
     async $isGitExtensionAvailable() {
@@ -123,25 +121,23 @@ let ExtHostGitExtensionService = class ExtHostGitExtensionService extends Dispos
         }
         const existingHandle = this._repositoryByUri.get(repository.rootUri);
         if (existingHandle !== undefined) {
-            const state = await this._getRepositoryState(repository);
+            if (this._repositories.get(existingHandle) !== repository) {
+                this._repositories.set(existingHandle, repository);
+                this._repositoryByUri.set(repository.rootUri, existingHandle);
+                this._setRepositoryStateChangeListener(existingHandle, repository);
+            }
+            const state = this._getRepositoryState(repository);
             return {
                 handle: existingHandle,
                 rootUri: repository.rootUri,
                 state
             };
         }
-        let repositoryState = repository.state;
-        if (repositoryState.HEAD === undefined) {
-            await Event.toPromise(repositoryState.onDidChange, this._disposables);
-            repositoryState = repository.state;
-        }
         const handle = ExtHostGitExtensionService_1._handlePool++;
         this._repositories.set(handle, repository);
         this._repositoryByUri.set(repository.rootUri, handle);
-        this._disposables.add(repository.state.onDidChange(() => {
-            this._proxy.$onDidChangeRepository(handle);
-        }));
-        const state = await this._getRepositoryState(repository);
+        this._setRepositoryStateChangeListener(handle, repository);
+        const state = this._getRepositoryState(repository);
         return {
             handle,
             rootUri: repository.rootUri,
@@ -179,34 +175,21 @@ let ExtHostGitExtensionService = class ExtHostGitExtensionService extends Dispos
         }
         return this._getRepositoryState(repository);
     }
-    async _getRepositoryState(repository) {
+    _getRepositoryState(repository) {
         const state = repository.state;
-        const base = await this._getBranchBase(repository);
         return {
-            HEAD: state.HEAD ? toGitBranchDto({
-                ...state.HEAD,
-                base
-            }) : undefined,
+            HEAD: state.HEAD ? toGitBranchDto(state.HEAD) : undefined,
+            remotes: state.remotes,
             mergeChanges: ( state.mergeChanges.map(toGitChangeDto)),
             indexChanges: ( state.indexChanges.map(toGitChangeDto)),
             workingTreeChanges: ( state.workingTreeChanges.map(toGitChangeDto)),
             untrackedChanges: ( state.untrackedChanges.map(toGitChangeDto))
         };
     }
-    async _getBranchBase(repository) {
-        const state = repository.state;
-        if (!state.HEAD?.name) {
-            return undefined;
-        }
-        const baseBranch = await repository.getBranchBase(state.HEAD.name);
-        if (!baseBranch?.name) {
-            return undefined;
-        }
-        const isProtected = repository.isBranchProtected(baseBranch);
-        return {
-            name: baseBranch.name,
-            isProtected
-        };
+    _setRepositoryStateChangeListener(handle, repository) {
+        this._repositoryStateChangeListeners.set(handle, repository.state.onDidChange(() => {
+            this._proxy.$onDidChangeRepository(handle);
+        }));
     }
     async $diffBetweenWithStats(handle, ref1, ref2, path) {
         const repository = this._repositories.get(handle);
@@ -258,7 +241,7 @@ let ExtHostGitExtensionService = class ExtHostGitExtensionService extends Dispos
         return this._gitApi;
     }
     dispose() {
-        this._disposables.dispose();
+        this._repositoryStateChangeListeners.dispose();
         super.dispose();
     }
 };

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

@@ -574,7 +574,7 @@ class DocumentPasteEditProvider {
         return (edits.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2749,
+                2744,
                 "Paste using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
@@ -1832,7 +1832,7 @@ class DocumentDropEditAdapter {
         return (editsArray.map((edit, i) => ({
             _cacheId: [cacheId, i],
             title: edit.title ?? ( localize(
-                2750,
+                2745,
                 "Drop using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),

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

@@ -246,7 +246,8 @@ class ExtHostLanguageModelTools {
             if (result.confirmationMessages?.approveCombination !== undefined) {
                 checkProposedApiEnabled(item.extension, "toolInvocationApproveCombination");
             }
-            const approveCombinationLabel = result.confirmationMessages?.approveCombination ? MarkdownString.fromStrict(result.confirmationMessages.approveCombination) : undefined;
+            const approveCombination = result.confirmationMessages?.approveCombination;
+            const approveCombinationLabel = approveCombination ? MarkdownString.fromStrict(approveCombination.message) : undefined;
             const approveCombinationKey = approveCombinationLabel ? await computeCombinationKey(toolId, context.parameters) : undefined;
             return {
                 confirmationMessages: result.confirmationMessages ? {
@@ -254,7 +255,8 @@ class ExtHostLanguageModelTools {
                     message: typeof result.confirmationMessages.message === "string" ? result.confirmationMessages.message : MarkdownString.from(result.confirmationMessages.message),
                     approveCombination: approveCombinationLabel && approveCombinationKey ? {
                         label: approveCombinationLabel,
-                        key: approveCombinationKey
+                        key: approveCombinationKey,
+                        arguments: approveCombination.arguments
                     } : undefined
                 } : undefined,
                 invocationMessage: MarkdownString.fromStrict(result.invocationMessage),

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

@@ -491,7 +491,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             return false;
         }
         try {
-            const detail = justification ? ( localize(2751, "Justification: {1}", to.displayName, justification)) : undefined;
+            const detail = justification ? ( localize(2746, "Justification: {1}", to.displayName, justification)) : undefined;
             await this._extHostAuthentication.getSession(from, providerId, [], {
                 forceNewSession: {
                     detail