@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatWindowNotifier.d.ts

@@ -1,5 +1,6 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
@@ -13,10 +14,13 @@ export declare class ChatWindowNotifier extends Disposable implements IWorkbench
     private readonly _chatWidgetService;
     private readonly _hostService;
     private readonly _configurationService;
+    private readonly _commandService;
     static readonly ID = "workbench.contrib.chatWindowNotifier";
     private readonly _activeNotifications;
-    constructor(_chatService: IChatService, _chatWidgetService: IChatWidgetService, _hostService: IHostService, _configurationService: IConfigurationService);
+    constructor(_chatService: IChatService, _chatWidgetService: IChatWidgetService, _hostService: IHostService, _configurationService: IConfigurationService, _commandService: ICommandService);
     private _trackModel;
     private _notifyIfNeeded;
+    private _isQuestionCarouselPending;
+    private _sanitizeOSToastText;
     private _clearNotification;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/chatWindowNotifier.js

@@ -1,28 +1,38 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { getWindow, triggerNotification } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
-import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, DisposableResourceMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable, DisposableResourceMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
 import { FocusMode } from '@codingame/monaco-vscode-api/vscode/vs/platform/native/common/native';
 import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatConfiguration, ChatNotificationMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { AcceptToolConfirmationActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatConstants';
 import { autorunIterableDelta, autorunDelta } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
     static {
         this.ID = "workbench.contrib.chatWindowNotifier";
     }
-    constructor(_chatService, _chatWidgetService, _hostService, _configurationService) {
+    constructor(
+        _chatService,
+        _chatWidgetService,
+        _hostService,
+        _configurationService,
+        _commandService
+    ) {
         super();
         this._chatService = _chatService;
         this._chatWidgetService = _chatWidgetService;
         this._hostService = _hostService;
         this._configurationService = _configurationService;
+        this._commandService = _commandService;
         this._activeNotifications = this._register(( new DisposableResourceMap()));
         const modelTrackers = this._register(( new DisposableResourceMap()));
         this._register(
@@ -58,45 +68,65 @@ let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
         });
     }
     async _notifyIfNeeded(sessionResource, info) {
-        if (!this._configurationService.getValue("chat.notifyWindowOnConfirmation")) {
+        const mode = this._configurationService.getValue(ChatConfiguration.NotifyWindowOnConfirmation);
+        if (mode === ChatNotificationMode.Off) {
             return;
         }
         const widget = this._chatWidgetService.getWidgetBySessionResource(sessionResource);
         const targetWindow = widget ? getWindow(widget.domNode) : mainWindow;
-        if (targetWindow.document.hasFocus()) {
+        const isFocused = targetWindow.document.hasFocus();
+        if (mode !== ChatNotificationMode.Always && isFocused) {
             return;
         }
         this._clearNotification(sessionResource);
-        await this._hostService.focus(targetWindow, {
-            mode: FocusMode.Notify
-        });
-        const notificationTitle = info.title ? ( localize(5682, "Chat: {0}", info.title)) : ( localize(5683, "Untitled Chat"));
-        const notification = await triggerNotification(notificationTitle, {
-            detail: info.detail ?? ( localize(5684, "Approval needed to continue."))
-        });
-        if (notification) {
-            const disposables = ( new DisposableStore());
-            this._activeNotifications.set(sessionResource, disposables);
-            disposables.add(notification);
-            disposables.add(Event.once(notification.onClick)(async () => {
+        if (!isFocused) {
+            await this._hostService.focus(targetWindow, {
+                mode: FocusMode.Notify
+            });
+        }
+        const notificationTitle = info.title ? ( localize(6162, "Chat: {0}", info.title)) : ( localize(6163, "Untitled Chat"));
+        const cts = ( new CancellationTokenSource());
+        this._activeNotifications.set(sessionResource, toDisposable(() => cts.dispose(true)));
+        const isQuestionCarousel = this._isQuestionCarouselPending(sessionResource);
+        try {
+            const actionLabel = isQuestionCarousel ? ( localize(6164, "Open Chat")) : ( localize(6165, "Allow"));
+            const body = info.detail ? this._sanitizeOSToastText(info.detail) : isQuestionCarousel ? ( localize(6166, "Questions need your input.")) : ( localize(6167, "Approval needed to continue."));
+            const result = await this._hostService.showToast({
+                title: this._sanitizeOSToastText(notificationTitle),
+                body,
+                actions: [actionLabel]
+            }, cts.token);
+            if (result.clicked || typeof result.actionIndex === "number") {
                 await this._hostService.focus(targetWindow, {
                     mode: FocusMode.Force
                 });
                 const widget = await this._chatWidgetService.openSession(sessionResource);
                 widget?.focusInput();
-                this._clearNotification(sessionResource);
-            }));
-            disposables.add(this._hostService.onDidChangeFocus(focus => {
-                if (focus) {
-                    this._clearNotification(sessionResource);
+                if (result.actionIndex === 0 && !isQuestionCarousel) {
+                    await this._commandService.executeCommand(AcceptToolConfirmationActionId, {
+                        sessionResource
+                    });
                 }
-            }));
+            }
+        } finally {
+            this._clearNotification(sessionResource);
         }
     }
+    _isQuestionCarouselPending(sessionResource) {
+        const model = this._chatService.getSession(sessionResource);
+        const lastResponse = model?.lastRequest?.response;
+        if (!lastResponse) {
+            return false;
+        }
+        return ( lastResponse.response.value.some(part => part.kind === "questionCarousel" && !part.isUsed));
+    }
+    _sanitizeOSToastText(text) {
+        return text.replace(/`/g, "'");
+    }
     _clearNotification(sessionResource) {
         this._activeNotifications.deleteAndDispose(sessionResource);
     }
 };
-ChatWindowNotifier = ( __decorate([( __param(0, IChatService)), ( __param(1, IChatWidgetService)), ( __param(2, IHostService)), ( __param(3, IConfigurationService))], ChatWindowNotifier));
+ChatWindowNotifier = ( __decorate([( __param(0, IChatService)), ( __param(1, IChatWidgetService)), ( __param(2, IHostService)), ( __param(3, IConfigurationService)), ( __param(4, ICommandService))], ChatWindowNotifier));
 
 export { ChatWindowNotifier };

package/vscode/src/vs/workbench/contrib/chat/browser/contextContrib/chatContextService.js

@@ -7,6 +7,7 @@ import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 
 let ChatContextService = class ChatContextService extends Disposable {
@@ -78,11 +79,12 @@ let ChatContextService = class ChatContextService extends Disposable {
                 if (!item.value) {
                     continue;
                 }
+                const derivedLabel = item.label ?? (item.resourceUri ? basename(item.resourceUri) : "Unknown");
                 items.push({
                     value: item.value,
-                    name: item.label,
+                    name: derivedLabel,
                     modelDescription: item.modelDescription,
-                    id: item.label,
+                    id: derivedLabel,
                     kind: "workspace"
                 });
             }
@@ -120,11 +122,14 @@ let ChatContextService = class ChatContextService extends Disposable {
         if (!context) {
             return;
         }
+        const effectiveResourceUri = context.resourceUri ?? uri;
+        const derivedLabel = context.label ?? basename(effectiveResourceUri);
         const contextValue = {
             value: undefined,
-            name: context.label,
+            name: derivedLabel,
             icon: context.icon,
             uri: uri,
+            resourceUri: context.resourceUri,
             modelDescription: context.modelDescription,
             tooltip: context.tooltip,
             commandId: context.command?.id,
@@ -178,23 +183,27 @@ let ChatContextService = class ChatContextService extends Disposable {
             };
             return {
                 picks: picks().then(items => {
-                    return ( items.map(item => ({
-                        label: item.label,
-                        iconClass: ThemeIcon.asClassName(item.icon),
-                        asAttachment: async () => {
-                            let contextValue = item;
-                            if ((contextValue.value === undefined) && providerEntry?.explicitProvider) {
-                                contextValue = await providerEntry.explicitProvider.resolveChatContext(item, CancellationToken.None);
+                    return ( items.map(item => {
+                        const derivedLabel = item.label ?? (item.resourceUri ? basename(item.resourceUri) : "Unknown");
+                        return {
+                            label: derivedLabel,
+                            iconClass: item.icon ? ThemeIcon.asClassName(item.icon) : undefined,
+                            asAttachment: async () => {
+                                let contextValue = item;
+                                if ((contextValue.value === undefined) && providerEntry?.explicitProvider) {
+                                    contextValue = await providerEntry.explicitProvider.resolveChatContext(item, CancellationToken.None);
+                                }
+                                const resolvedLabel = contextValue.label ?? (contextValue.resourceUri ? basename(contextValue.resourceUri) : "Unknown");
+                                return {
+                                    kind: "generic",
+                                    id: resolvedLabel,
+                                    name: resolvedLabel,
+                                    icon: contextValue.icon,
+                                    value: contextValue.value
+                                };
                             }
-                            return {
-                                kind: "generic",
-                                id: contextValue.label,
-                                name: contextValue.label,
-                                icon: contextValue.icon,
-                                value: contextValue.value
-                            };
-                        }
-                    })));
+                        };
+                    }));
                 }),
                 placeholder: title
             };

package/vscode/src/vs/workbench/contrib/chat/browser/createSlashCommandsUsageTracker.d.ts

@@ -0,0 +1,14 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+export declare class CreateSlashCommandsUsageTracker extends Disposable {
+    private readonly _chatService;
+    private readonly _storageService;
+    private readonly _getActiveContextKeyService;
+    private static readonly _USED_CREATE_SLASH_COMMANDS_KEY;
+    constructor(_chatService: IChatService, _storageService: IStorageService, _getActiveContextKeyService: () => IContextKeyService | undefined);
+    syncContextKey(contextKeyService: IContextKeyService): void;
+    private _markUsed;
+    private static _isCreateSlashCommand;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/createSlashCommandsUsageTracker.js

@@ -0,0 +1,62 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatRequestSlashCommandPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
+
+class CreateSlashCommandsUsageTracker extends Disposable {
+    static { this._USED_CREATE_SLASH_COMMANDS_KEY = 'chat.tips.usedCreateSlashCommands'; }
+    constructor(_chatService, _storageService, _getActiveContextKeyService) {
+        super();
+        this._chatService = _chatService;
+        this._storageService = _storageService;
+        this._getActiveContextKeyService = _getActiveContextKeyService;
+        this._register(this._chatService.onDidSubmitRequest(e => {
+            const message = e.message ?? this._chatService.getSession(e.chatSessionResource)?.lastRequest?.message;
+            if (!message) {
+                return;
+            }
+            for (const part of message.parts) {
+                if (part.kind === ChatRequestSlashCommandPart.Kind) {
+                    const slash = part;
+                    if (CreateSlashCommandsUsageTracker._isCreateSlashCommand(slash.slashCommand.command)) {
+                        this._markUsed();
+                        return;
+                    }
+                }
+            }
+            const trimmed = message.text.trimStart();
+            const match = /^\/(create-(?:instructions|prompt|agent|skill))(?:\s|$)/.exec(trimmed);
+            if (match && CreateSlashCommandsUsageTracker._isCreateSlashCommand(match[1])) {
+                this._markUsed();
+            }
+        }));
+    }
+    syncContextKey(contextKeyService) {
+        const used = this._storageService.getBoolean(CreateSlashCommandsUsageTracker._USED_CREATE_SLASH_COMMANDS_KEY, StorageScope.APPLICATION, false);
+        ChatContextKeys.hasUsedCreateSlashCommands.bindTo(contextKeyService).set(used);
+    }
+    _markUsed() {
+        if (this._storageService.getBoolean(CreateSlashCommandsUsageTracker._USED_CREATE_SLASH_COMMANDS_KEY, StorageScope.APPLICATION, false)) {
+            return;
+        }
+        this._storageService.store(CreateSlashCommandsUsageTracker._USED_CREATE_SLASH_COMMANDS_KEY, true, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        const contextKeyService = this._getActiveContextKeyService();
+        if (contextKeyService) {
+            ChatContextKeys.hasUsedCreateSlashCommands.bindTo(contextKeyService).set(true);
+        }
+    }
+    static _isCreateSlashCommand(command) {
+        switch (command) {
+            case 'create-instructions':
+            case 'create-prompt':
+            case 'create-agent':
+            case 'create-skill':
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+
+export { CreateSlashCommandsUsageTracker };

package/vscode/src/vs/workbench/contrib/chat/browser/defaultModelContribution.d.ts

@@ -0,0 +1,36 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ILanguageModelChatMetadata } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+export interface DefaultModelArrays {
+    readonly modelIds: string[];
+    readonly modelLabels: string[];
+    readonly modelDescriptions: string[];
+}
+export interface DefaultModelContributionOptions {
+    /** Configuration key for the setting (used in schema notification). */
+    readonly configKey: string;
+    /** Configuration section id for `notifyConfigurationSchemaUpdated`, or `undefined` to skip notification. */
+    readonly configSectionId: string | undefined;
+    /** Log prefix, e.g. `'[PlanAgentDefaultModel]'`. */
+    readonly logPrefix: string;
+    /** Additional filter beyond `isUserSelectable`. Return `true` to include the model. */
+    readonly filter?: (metadata: ILanguageModelChatMetadata) => boolean;
+}
+/**
+ * Creates the initial static arrays used by configuration registration code.
+ * The returned arrays are mutated in-place by {@link DefaultModelContribution}.
+ */
+export declare function createDefaultModelArrays(): DefaultModelArrays;
+/**
+ * Shared base class for workbench contributions that populate a dynamic enum
+ * of language models for a settings picker.
+ */
+export declare abstract class DefaultModelContribution extends Disposable {
+    private readonly _arrays;
+    private readonly _options;
+    private readonly _languageModelsService;
+    private readonly _logService;
+    constructor(_arrays: DefaultModelArrays, _options: DefaultModelContributionOptions, _languageModelsService: ILanguageModelsService, _logService: ILogService);
+    private _updateModelValues;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/defaultModelContribution.js

@@ -0,0 +1,110 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { DEFAULT_MODEL_PICKER_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/input/modelPickerWidget';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+function createDefaultModelArrays() {
+    return {
+        modelIds: [""],
+        modelLabels: [( localize(6168, "Auto (Vendor Default)"))],
+        modelDescriptions: [( localize(6169, "Use the vendor's default model"))]
+    };
+}
+let DefaultModelContribution = class DefaultModelContribution extends Disposable {
+    constructor(_arrays, _options, _languageModelsService, _logService) {
+        super();
+        this._arrays = _arrays;
+        this._options = _options;
+        this._languageModelsService = _languageModelsService;
+        this._logService = _logService;
+        this._register(
+            _languageModelsService.onDidChangeLanguageModels(() => this._updateModelValues())
+        );
+        this._updateModelValues();
+    }
+    _updateModelValues() {
+        const {
+            modelIds,
+            modelLabels,
+            modelDescriptions
+        } = this._arrays;
+        const {
+            configKey,
+            configSectionId,
+            logPrefix,
+            filter
+        } = this._options;
+        try {
+            modelIds.length = 0;
+            modelLabels.length = 0;
+            modelDescriptions.length = 0;
+            modelIds.push("");
+            modelLabels.push(( localize(6168, "Auto (Vendor Default)")));
+            modelDescriptions.push(( localize(6169, "Use the vendor's default model")));
+            const models = [];
+            const allModelIds = this._languageModelsService.getLanguageModelIds();
+            for (const modelId of allModelIds) {
+                try {
+                    const metadata = this._languageModelsService.lookupLanguageModel(modelId);
+                    if (metadata) {
+                        models.push({
+                            identifier: modelId,
+                            metadata
+                        });
+                    } else {
+                        this._logService.warn(`${logPrefix} No metadata found for model ID: ${modelId}`);
+                    }
+                } catch (e) {
+                    this._logService.error(`${logPrefix} Error looking up model ${modelId}:`, e);
+                }
+            }
+            const supportedModels = models.filter(model => {
+                if (!model.metadata?.isUserSelectable) {
+                    return false;
+                }
+                if (filter && !filter(model.metadata)) {
+                    return false;
+                }
+                return true;
+            });
+            supportedModels.sort((a, b) => {
+                const aCategory = a.metadata.modelPickerCategory ?? DEFAULT_MODEL_PICKER_CATEGORY;
+                const bCategory = b.metadata.modelPickerCategory ?? DEFAULT_MODEL_PICKER_CATEGORY;
+                if (aCategory.order !== bCategory.order) {
+                    return aCategory.order - bCategory.order;
+                }
+                return a.metadata.name.localeCompare(b.metadata.name);
+            });
+            for (const model of supportedModels) {
+                try {
+                    const qualifiedName = ILanguageModelChatMetadata.asQualifiedName(model.metadata);
+                    modelIds.push(qualifiedName);
+                    modelLabels.push(model.metadata.name);
+                    modelDescriptions.push(model.metadata.tooltip ?? model.metadata.detail ?? "");
+                } catch (e) {
+                    this._logService.error(`${logPrefix} Error adding model ${model.metadata.name}:`, e);
+                }
+            }
+            if (configSectionId) {
+                configurationRegistry.notifyConfigurationSchemaUpdated({
+                    id: configSectionId,
+                    properties: {
+                        [configKey]: {}
+                    }
+                });
+            }
+        } catch (e) {
+            this._logService.error(`${logPrefix} Error updating model values:`, e);
+        }
+    }
+};
+DefaultModelContribution = ( __decorate([( __param(2, ILanguageModelsService)), ( __param(3, ILogService))], DefaultModelContribution));
+
+export { DefaultModelContribution, createDefaultModelArrays };

package/vscode/src/vs/workbench/contrib/chat/browser/exploreAgentDefaultModel.d.ts

@@ -0,0 +1,10 @@
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { DefaultModelContribution } from "./defaultModelContribution.js";
+export declare class ExploreAgentDefaultModel extends DefaultModelContribution {
+    static readonly ID = "workbench.contrib.exploreAgentDefaultModel";
+    static readonly modelIds: string[];
+    static readonly modelLabels: string[];
+    static readonly modelDescriptions: string[];
+    constructor(languageModelsService: ILanguageModelsService, logService: ILogService);
+}

package/vscode/src/vs/workbench/contrib/chat/browser/exploreAgentDefaultModel.js

@@ -0,0 +1,39 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { createDefaultModelArrays, DefaultModelContribution } from './defaultModelContribution.js';
+
+const arrays = createDefaultModelArrays();
+let ExploreAgentDefaultModel = class ExploreAgentDefaultModel extends DefaultModelContribution {
+    static {
+        this.ID = "workbench.contrib.exploreAgentDefaultModel";
+    }
+    static {
+        this.modelIds = arrays.modelIds;
+    }
+    static {
+        this.modelLabels = arrays.modelLabels;
+    }
+    static {
+        this.modelDescriptions = arrays.modelDescriptions;
+    }
+    constructor(languageModelsService, logService) {
+        super(arrays, {
+            configKey: ChatConfiguration.ExploreAgentDefaultModel,
+            configSectionId: "chatSidebar",
+            logPrefix: "[ExploreAgentDefaultModel]",
+            filter: metadata => !!metadata.capabilities?.toolCalling
+        }, languageModelsService, logService);
+    }
+};
+ExploreAgentDefaultModel = ( __decorate([( __param(0, ILanguageModelsService)), ( __param(1, ILogService))], ExploreAgentDefaultModel));
+registerWorkbenchContribution2(
+    ExploreAgentDefaultModel.ID,
+    ExploreAgentDefaultModel,
+    WorkbenchPhase.BlockRestore
+);
+
+export { ExploreAgentDefaultModel };

package/vscode/src/vs/workbench/contrib/chat/browser/languageModelsConfigurationService.d.ts

@@ -4,7 +4,7 @@ import { Mutable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/type
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
-import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { ITextEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textEditorService.service";
 import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
@@ -19,7 +19,7 @@ export declare class LanguageModelsConfigurationService extends Disposable imple
     private readonly fileService;
     private readonly textFileService;
     private readonly textModelService;
-    private readonly editorGroupsService;
+    private readonly editorService;
     private readonly textEditorService;
     _serviceBrand: undefined;
     private readonly modelsConfigurationFile;
@@ -27,7 +27,7 @@ export declare class LanguageModelsConfigurationService extends Disposable imple
     private readonly _onDidChangeLanguageModelGroups;
     readonly onDidChangeLanguageModelGroups: Event<readonly ILanguageModelsProviderGroup[]>;
     private languageModelsProviderGroups;
-    constructor(fileService: IFileService, textFileService: ITextFileService, textModelService: ITextModelService, editorGroupsService: IEditorGroupsService, textEditorService: ITextEditorService, userDataProfileService: IUserDataProfileService, uriIdentityService: IUriIdentityService);
+    constructor(fileService: IFileService, textFileService: ITextFileService, textModelService: ITextModelService, editorService: IEditorService, textEditorService: ITextEditorService, userDataProfileService: IUserDataProfileService, uriIdentityService: IUriIdentityService);
     private setLanguageModelsConfiguration;
     private updateLanguageModelsConfiguration;
     getLanguageModelsProviderGroups(): readonly ILanguageModelsProviderGroup[];

package/vscode/src/vs/workbench/contrib/chat/browser/languageModelsConfigurationService.js

@@ -5,7 +5,7 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { ITextEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textEditorService.service';
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
@@ -27,7 +27,7 @@ let LanguageModelsConfigurationService = class LanguageModelsConfigurationServic
         fileService,
         textFileService,
         textModelService,
-        editorGroupsService,
+        editorService,
         textEditorService,
         userDataProfileService,
         uriIdentityService
@@ -36,9 +36,9 @@ let LanguageModelsConfigurationService = class LanguageModelsConfigurationServic
         this.fileService = fileService;
         this.textFileService = textFileService;
         this.textModelService = textModelService;
-        this.editorGroupsService = editorGroupsService;
+        this.editorService = editorService;
         this.textEditorService = textEditorService;
-        this._onDidChangeLanguageModelGroups = ( new Emitter());
+        this._onDidChangeLanguageModelGroups = this._register(( new Emitter()));
         this.onDidChangeLanguageModelGroups = this._onDidChangeLanguageModelGroups.event;
         this.languageModelsProviderGroups = [];
         this.modelsConfigurationFile = uriIdentityService.extUri.joinPath(userDataProfileService.currentProfile.location, "chatLanguageModels.json");
@@ -136,7 +136,7 @@ let LanguageModelsConfigurationService = class LanguageModelsConfigurationServic
         await this.updateLanguageModelsConfiguration();
     }
     async configureLanguageModels(options) {
-        const editor = await this.editorGroupsService.activeGroup.openEditor(this.textEditorService.createTextEditor({
+        const editor = await this.editorService.openEditor(this.textEditorService.createTextEditor({
             resource: this.modelsConfigurationFile
         }));
         if (!editor || !options?.group) {
@@ -201,7 +201,7 @@ let LanguageModelsConfigurationService = class LanguageModelsConfigurationServic
         }
     }
 };
-LanguageModelsConfigurationService = ( __decorate([( __param(0, IFileService)), ( __param(1, ITextFileService)), ( __param(2, ITextModelService)), ( __param(3, IEditorGroupsService)), ( __param(4, ITextEditorService)), ( __param(5, IUserDataProfileService)), ( __param(6, IUriIdentityService))], LanguageModelsConfigurationService));
+LanguageModelsConfigurationService = ( __decorate([( __param(0, IFileService)), ( __param(1, ITextFileService)), ( __param(2, ITextModelService)), ( __param(3, IEditorService)), ( __param(4, ITextEditorService)), ( __param(5, IUserDataProfileService)), ( __param(6, IUriIdentityService))], LanguageModelsConfigurationService));
 function parseLanguageModelsProviderGroups(model) {
     const configuration = [];
     let currentProperty = null;

package/vscode/src/vs/workbench/contrib/chat/browser/planAgentDefaultModel.d.ts

@@ -0,0 +1,10 @@
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { DefaultModelContribution } from "./defaultModelContribution.js";
+export declare class PlanAgentDefaultModel extends DefaultModelContribution {
+    static readonly ID = "workbench.contrib.planAgentDefaultModel";
+    static readonly modelIds: string[];
+    static readonly modelLabels: string[];
+    static readonly modelDescriptions: string[];
+    constructor(languageModelsService: ILanguageModelsService, logService: ILogService);
+}