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

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

@@ -0,0 +1,41 @@
+/**
+ * Storage keys used by ChatTipService for persisting tip state.
+ */
+export declare const ChatTipStorageKeys: {
+    /** IDs of tips that have been permanently dismissed by the user. */
+    DismissedTips: string;
+    /** The ID of the last tip that was shown, for round-robin selection. */
+    LastTipId: string;
+    /** Whether the user has ever modified the thinking phrases setting. */
+    ThinkingPhrasesEverModified: string;
+};
+/**
+ * Storage keys used by TipEligibilityTracker for tracking user signals.
+ */
+export declare const TipEligibilityStorageKeys: {
+    /** Command IDs that have been executed (for excludeWhenCommandsExecuted). */
+    ExecutedCommands: string;
+    /** Chat modes that have been used (for excludeWhenModesUsed). */
+    UsedModes: string;
+    /** Tool IDs that have been invoked (for excludeWhenToolsInvoked). */
+    InvokedTools: string;
+};
+/**
+ * Synthetic command IDs used to track user actions that don't have real commands.
+ * These are recorded when the user performs the action, allowing tips to be excluded
+ * via excludeWhenCommandsExecuted.
+ */
+export declare const TipTrackingCommands: {
+    /** Tracked when user attaches a file/folder reference with #. */
+    readonly AttachFilesReferenceUsed: "chat.tips.attachFiles.referenceUsed";
+    /** Tracked when user executes /init or /create-instructions. */
+    readonly CreateAgentInstructionsUsed: "chat.tips.createAgentInstructions.commandUsed";
+    /** Tracked when user executes /create-prompt. */
+    readonly CreatePromptUsed: "chat.tips.createPrompt.commandUsed";
+    /** Tracked when user executes /create-agent. */
+    readonly CreateAgentUsed: "chat.tips.createAgent.commandUsed";
+    /** Tracked when user executes /create-skill. */
+    readonly CreateSkillUsed: "chat.tips.createSkill.commandUsed";
+    /** Tracked when user executes /fork. */
+    readonly ForkConversationUsed: "chat.tips.forkConversation.commandUsed";
+};

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

@@ -0,0 +1,22 @@
+
+
+const ChatTipStorageKeys = {
+    DismissedTips: 'chat.tip.dismissed',
+    LastTipId: 'chat.tip.lastTipId',
+    ThinkingPhrasesEverModified: 'chat.tip.thinkingPhrasesEverModified',
+};
+const TipEligibilityStorageKeys = {
+    ExecutedCommands: 'chat.tips.executedCommands',
+    UsedModes: 'chat.tips.usedModes',
+    InvokedTools: 'chat.tips.invokedTools',
+};
+const TipTrackingCommands = {
+    AttachFilesReferenceUsed: 'chat.tips.attachFiles.referenceUsed',
+    CreateAgentInstructionsUsed: 'chat.tips.createAgentInstructions.commandUsed',
+    CreatePromptUsed: 'chat.tips.createPrompt.commandUsed',
+    CreateAgentUsed: 'chat.tips.createAgent.commandUsed',
+    CreateSkillUsed: 'chat.tips.createSkill.commandUsed',
+    ForkConversationUsed: 'chat.tips.forkConversation.commandUsed',
+};
+
+export { ChatTipStorageKeys, TipEligibilityStorageKeys, TipTrackingCommands };

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

@@ -18,5 +18,10 @@ export declare class ChatWindowNotifier extends Disposable implements IWorkbench
     constructor(_chatService: IChatService, _chatWidgetService: IChatWidgetService, _hostService: IHostService, _configurationService: IConfigurationService);
     private _trackModel;
     private _notifyIfNeeded;
+    private _confirmAllow;
+    private _getNotificationBody;
+    private _getPendingTerminalCommand;
+    private _isQuestionCarouselPending;
+    private _sanitizeOSToastText;
     private _clearNotification;
 }

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

@@ -1,15 +1,18 @@
 
 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 { 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 { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { migrateLegacyTerminalToolSpecificData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
+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 { autorunIterableDelta, autorunDelta } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
@@ -58,40 +61,101 @@ 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(6233, "Session: {0}", info.title)) : ( localize(6234, "Untitled Session"));
+        const cts = ( new CancellationTokenSource());
+        this._activeNotifications.set(sessionResource, toDisposable(() => cts.dispose(true)));
+        const isQuestionCarousel = this._isQuestionCarouselPending(sessionResource);
+        try {
+            const actionLabel = isQuestionCarousel ? ( localize(6235, "Open Session")) : ( localize(6236, "Allow"));
+            const result = await this._hostService.showToast({
+                title: this._sanitizeOSToastText(notificationTitle),
+                body: this._getNotificationBody(sessionResource, info, isQuestionCarousel),
+                actions: [actionLabel]
+            }, cts.token);
+            if (result.actionIndex === 0 && !isQuestionCarousel && this._confirmAllow(sessionResource)) {
+                return;
+            }
+            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);
-                }
-            }));
+            }
+        } finally {
+            this._clearNotification(sessionResource);
+        }
+    }
+    _confirmAllow(sessionResource) {
+        const model = this._chatService.getSession(sessionResource);
+        const lastResponse = model?.lastRequest?.response;
+        if (!lastResponse) {
+            return false;
+        }
+        for (const part of lastResponse.response.value) {
+            const state = part.kind === "toolInvocation" ? part.state.get() : undefined;
+            if (state?.type === IChatToolInvocation.StateKind.WaitingForConfirmation || state?.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
+                state.confirm({
+                    type: ToolConfirmKind.UserAction
+                });
+                return true;
+            }
         }
+        return false;
+    }
+    _getNotificationBody(sessionResource, info, isQuestionCarousel) {
+        if (isQuestionCarousel) {
+            return localize(6237, "Questions need your input.");
+        }
+        const terminalCommand = this._getPendingTerminalCommand(sessionResource);
+        if (terminalCommand) {
+            return this._sanitizeOSToastText(terminalCommand);
+        }
+        if (info.detail) {
+            return this._sanitizeOSToastText(info.detail);
+        }
+        return localize(6238, "Approval needed to continue.");
+    }
+    _getPendingTerminalCommand(sessionResource) {
+        const model = this._chatService.getSession(sessionResource);
+        const lastResponse = model?.lastRequest?.response;
+        if (!lastResponse?.response?.value) {
+            return undefined;
+        }
+        for (const part of lastResponse.response.value) {
+            if (part.kind === "toolInvocation" && part.toolSpecificData?.kind === "terminal") {
+                const terminalData = migrateLegacyTerminalToolSpecificData(part.toolSpecificData);
+                return terminalData.commandLine.forDisplay ?? terminalData.commandLine.userEdited ?? terminalData.commandLine.toolEdited ?? terminalData.commandLine.original;
+            }
+        }
+        return undefined;
+    }
+    _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);

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(6239, "Auto (Vendor Default)"))],
+        modelDescriptions: [( localize(6240, "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(6239, "Auto (Vendor Default)")));
+            modelDescriptions.push(( localize(6240, "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[];