@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -0,0 +1,301 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatPetAchievements from './media/chatPetAchievements.css';
+import { append, $, addDisposableListener, EventType, getActiveElement, isHTMLElement, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { CHAT_PET_ACHIEVEMENT_PREVIEW_SIZE, renderChatPetAchievementPreview } from './chatPetAchievementPreview.js';
+import { chatPetAchievements as chatPetAchievements$1, getChatPetAchievementPresentation, getChatPetAccessory } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatPetAchievements';
+import { IChatPetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(chatPetAchievements);
+let ChatPetAchievementsWidget = class ChatPetAchievementsWidget extends Disposable {
+    constructor(parent, onDidRequestClose, chatPetService, themeService, logService) {
+        super();
+        this.onDidRequestClose = onDidRequestClose;
+        this.chatPetService = chatPetService;
+        this.themeService = themeService;
+        this.logService = logService;
+        this.renderDisposables = this._register(( new DisposableStore()));
+        this.accessoryCards = ( new Map());
+        this.unseenAchievementIds = ( new Set());
+        this.container = append(parent, $(".chat-pet-achievements-widget"));
+        this.content = $(".chat-pet-achievements-content");
+        this.scrollable = this._register(( new DomScrollableElement(this.content, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto
+        })));
+        this.container.appendChild(this.scrollable.getDomNode());
+        this._register(addDisposableListener(this.content, EventType.SCROLL, () => {
+            const scrollTop = this.content.scrollTop;
+            if (scrollTop !== this.scrollable.getScrollPosition().scrollTop) {
+                this.scrollable.setScrollPosition({
+                    scrollTop
+                });
+            }
+        }, {
+            passive: true
+        }));
+        const themeChanged = observableSignalFromEvent(this, this.themeService.onDidColorThemeChange);
+        this._register(autorun(reader => {
+            const unlockedAchievements = this.chatPetService.unlockedAchievements.read(reader);
+            const variant = this.chatPetService.variant.read(reader);
+            themeChanged.read(reader);
+            this.render(
+                unlockedAchievements,
+                this.chatPetService.selectedAccessory.read(undefined),
+                variant
+            );
+        }));
+        this._register(autorun(reader => {
+            this.updateSelectedAccessory(this.chatPetService.selectedAccessory.read(reader));
+        }));
+        this._register(autorun(reader => {
+            this.updateNewAchievements(this.chatPetService.unseenAchievements.read(reader));
+        }));
+    }
+    layout(dimension) {
+        if (dimension) {
+            this.lastDimension = dimension;
+            this.container.style.width = `${dimension.width}px`;
+            this.container.style.height = `${dimension.height}px`;
+        }
+        const width = dimension?.width ?? this.container.clientWidth;
+        const height = dimension?.height ?? this.container.clientHeight;
+        this.container.classList.toggle("narrow", width < 560);
+        this.content.style.width = `${width}px`;
+        this.content.style.height = `${height}px`;
+        const scrollableNode = this.scrollable.getDomNode();
+        scrollableNode.style.width = `${width}px`;
+        scrollableNode.style.height = `${height}px`;
+        this.scrollable.scanDomNode();
+    }
+    focus() {
+        this.focusTarget?.();
+    }
+    render(unlockedAchievements, selectedAccessory, variant) {
+        const activeElement = getActiveElement();
+        const restoreFocusId = isHTMLElement(activeElement) ? activeElement.closest(".chat-pet-achievement-card")?.dataset.accessoryId : undefined;
+        this.renderDisposables.clear();
+        clearNode(this.content);
+        this.accessoryCards.clear();
+        this.focusTarget = undefined;
+        const inner = append(this.content, $(".chat-pet-achievements-inner"));
+        append(inner, $("h1")).textContent = ( localize(8342, "Achievements"));
+        append(inner, $("p.chat-pet-achievements-intro")).textContent = ( localize(
+            8343,
+            "Unlock hats as you explore agent features, then choose what your pet wears by selecting an unlocked card."
+        ));
+        const unlockedSet = ( new Set(unlockedAchievements));
+        const collection = append(inner, $("section.chat-pet-achievements-collection"));
+        collection.setAttribute("role", "region");
+        collection.setAttribute("aria-label", ( localize(
+            8344,
+            "Achievement collection, {0} of {1} unlocked",
+            unlockedAchievements.length,
+            chatPetAchievements$1.length
+        )));
+        const collectionHeader = append(collection, $(".chat-pet-achievements-collection-header"));
+        append(collectionHeader, $("h2")).textContent = ( localize(8345, "Collection"));
+        append(collectionHeader, $("span.chat-pet-achievements-count")).textContent = ( localize(
+            8346,
+            "{0} of {1} unlocked",
+            unlockedAchievements.length,
+            chatPetAchievements$1.length
+        ));
+        const list = append(collection, $("ul.chat-pet-achievements-list"));
+        const cards = ( new Map());
+        const noHatId = "none";
+        const noHatItem = append(list, $("li.chat-pet-achievements-list-item"));
+        const noHatSelected = selectedAccessory === undefined;
+        const noHatCard = this.renderDisposables.add(( new Button(noHatItem, {
+            secondary: true,
+            ariaLabel: noHatSelected ? ( localize(8347, "No Hat, selected")) : ( localize(8348, "No Hat"))
+        })));
+        noHatCard.element.classList.add("chat-pet-achievement-card", "no-hat");
+        noHatCard.element.dataset.accessoryId = noHatId;
+        noHatCard.element.setAttribute("aria-pressed", String(noHatSelected));
+        noHatCard.element.classList.toggle("wearing", noHatSelected);
+        const noHatPreviews = append(noHatCard.element, $(".chat-pet-achievement-previews"));
+        this.renderCardPreview(noHatPreviews, undefined, true, variant);
+        const noHatContent = append(noHatCard.element, $(".chat-pet-achievement-card-content"));
+        append(noHatContent, $("h3")).textContent = ( localize(8349, "No Hat"));
+        const noHatState = append(noHatContent, $("span.chat-pet-achievement-state"));
+        noHatState.textContent = noHatSelected ? ( localize(8350, "Wearing")) : ( localize(8351, "Select"));
+        this.renderDisposables.add(noHatCard.onDidClick(() => this.selectAccessory(undefined)));
+        this.renderDisposables.add(noHatCard.onDidEscape(() => this.onDidRequestClose()));
+        this.accessoryCards.set(noHatId, {
+            button: noHatCard,
+            state: noHatState,
+            defaultState: ( localize(8351, "Select")),
+            selectedAriaLabel: ( localize(8347, "No Hat, selected")),
+            defaultAriaLabel: ( localize(8348, "No Hat"))
+        });
+        cards.set(noHatId, noHatCard);
+        for (const achievement of chatPetAchievements$1) {
+            const unlocked = ( unlockedSet.has(achievement.id));
+            const presentation = getChatPetAchievementPresentation(achievement, unlocked);
+            const wearing = unlocked && ( achievement.accessories.some(accessory => selectedAccessory === accessory.id));
+            const item = append(list, $("li.chat-pet-achievements-list-item"));
+            const accessoryId = achievement.accessories[0].id;
+            const card = this.renderDisposables.add(( new Button(item, {
+                secondary: true,
+                ariaLabel: presentation.locked ? ( localize(
+                    8352,
+                    "Locked. Hint: {0} Rewards: {1}.",
+                    presentation.hint,
+                    presentation.rewardLabels.join(", ")
+                )) : ( localize(
+                    8353,
+                    "{0}. Reward: {1}. {2}",
+                    presentation.title,
+                    presentation.accessories[0].label,
+                    wearing ? ( localize(8350, "Wearing")) : ( localize(8354, "Unlocked"))
+                ))
+            })));
+            card.element.classList.add("chat-pet-achievement-card");
+            card.element.dataset.accessoryId = accessoryId;
+            card.element.classList.toggle("locked", !unlocked);
+            card.element.classList.toggle("wearing", wearing);
+            card.element.setAttribute("aria-pressed", String(wearing));
+            card.enabled = unlocked;
+            const newBadge = append(card.element, $("span.chat-pet-achievement-new-badge.hidden"));
+            newBadge.textContent = ( localize(8355, "New"));
+            newBadge.setAttribute("aria-hidden", "true");
+            const previews = append(card.element, $(".chat-pet-achievement-previews"));
+            const previewAccessories = unlocked ? achievement.accessories : [achievement.accessories[0]];
+            for (const accessory of previewAccessories) {
+                this.renderCardPreview(previews, accessory, unlocked, variant);
+            }
+            const cardContent = append(card.element, $(".chat-pet-achievement-card-content"));
+            if (!presentation.locked) {
+                append(cardContent, $("h3")).textContent = presentation.title;
+                const state = append(cardContent, $("span.chat-pet-achievement-state"));
+                state.textContent = wearing ? ( localize(8350, "Wearing")) : ( localize(8354, "Unlocked"));
+                append(cardContent, $("p.chat-pet-achievement-description")).textContent = presentation.description;
+                append(cardContent, $("p.chat-pet-achievement-reward")).textContent = ( localize(
+                    8356,
+                    "Rewards: {0}",
+                    ( presentation.accessories.map(accessory => accessory.label)).join(", ")
+                ));
+                this.accessoryCards.set(accessoryId, {
+                    button: card,
+                    state,
+                    defaultState: ( localize(8354, "Unlocked")),
+                    selectedAriaLabel: ( localize(
+                        8353,
+                        "{0}. Reward: {1}. {2}",
+                        achievement.title,
+                        achievement.accessories[0].label,
+                        localize(8350, "Wearing")
+                    )),
+                    defaultAriaLabel: ( localize(
+                        8353,
+                        "{0}. Reward: {1}. {2}",
+                        achievement.title,
+                        achievement.accessories[0].label,
+                        localize(8354, "Unlocked")
+                    )),
+                    achievementId: achievement.id,
+                    newBadge
+                });
+            } else {
+                append(cardContent, $("h3")).textContent = ( localize(8357, "Locked"));
+                append(cardContent, $("span.chat-pet-achievement-state")).textContent = ( localize(8358, "Hint"));
+                append(cardContent, $("p.chat-pet-achievement-description")).textContent = presentation.hint;
+                append(cardContent, $("p.chat-pet-achievement-reward")).textContent = ( localize(8356, "Rewards: {0}", presentation.rewardLabels.join(", ")));
+            }
+            this.renderDisposables.add(card.onDidClick(() => this.selectAccessory(accessoryId, achievement.id)));
+            this.renderDisposables.add(card.onDidEscape(() => this.onDidRequestClose()));
+            cards.set(accessoryId, card);
+        }
+        const roadmapItem = append(list, $("li.chat-pet-achievements-list-item"));
+        const roadmapCard = append(
+            roadmapItem,
+            $("article.chat-pet-achievement-card.chat-pet-achievement-roadmap")
+        );
+        const roadmapPreview = append(roadmapCard, $(".chat-pet-achievement-roadmap-preview"));
+        roadmapPreview.textContent = ( localize(8359, "TBD"));
+        const roadmapContent = append(roadmapCard, $(".chat-pet-achievement-card-content"));
+        append(roadmapContent, $("h3")).textContent = ( localize(8360, "TBD"));
+        append(roadmapContent, $("span.chat-pet-achievement-state")).textContent = ( localize(8361, "Coming soon"));
+        const roadmapIntro = append(roadmapContent, $("p.chat-pet-achievement-description"));
+        roadmapIntro.textContent = ( localize(8362, "Upcoming pet features:"));
+        const roadmapList = append(roadmapContent, $("ul.chat-pet-achievement-roadmap-list"));
+        for (const item of [( localize(8363, "A naming competition")), ( localize(8364, "More achievements and built-in hats")), ( localize(8365, "Customizable hats that you can upload"))]) {
+            append(roadmapList, $("li")).textContent = item;
+        }
+        const experimentalNote = append(inner, $("p.chat-pet-achievements-experimental"));
+        experimentalNote.textContent = ( localize(
+            8366,
+            "The VS Code pet and achievements are experimental. Features and rewards may change."
+        ));
+        this.scrollable.scanDomNode();
+        this.layout(this.lastDimension);
+        this.updateNewAchievements(this.chatPetService.unseenAchievements.read(undefined));
+        const selectedCardId = selectedAccessory ?? noHatId;
+        this.focusTarget = () => cards.get(selectedCardId)?.focus();
+        if (restoreFocusId) {
+            queueMicrotask(() => {
+                if (!this._store.isDisposed) {
+                    cards.get(restoreFocusId)?.focus();
+                }
+            });
+        }
+    }
+    renderCardPreview(previews, accessory, unlocked, variant) {
+        const preview = append(previews, $("canvas.chat-pet-achievement-preview"));
+        preview.width = CHAT_PET_ACHIEVEMENT_PREVIEW_SIZE;
+        preview.height = CHAT_PET_ACHIEVEMENT_PREVIEW_SIZE;
+        preview.setAttribute("aria-hidden", "true");
+        this.renderDisposables.add(
+            renderChatPetAchievementPreview(preview, accessory, unlocked, variant, this.themeService, this.logService)
+        );
+    }
+    selectAccessory(accessoryId, achievementId) {
+        if (achievementId) {
+            this.chatPetService.markAchievementSeen(achievementId);
+        }
+        if (accessoryId === this.chatPetService.selectedAccessory.get()) {
+            return;
+        }
+        this.chatPetService.setAccessory(accessoryId);
+        status(accessoryId === undefined ? ( localize(8367, "VS Code pet hat removed")) : ( localize(
+            8368,
+            "VS Code pet is now wearing {0}",
+            getChatPetAccessory(accessoryId).label
+        )));
+    }
+    updateSelectedAccessory(accessoryId) {
+        const selectedId = accessoryId ?? "none";
+        for (const [id, card] of this.accessoryCards) {
+            const wearing = id === selectedId;
+            card.button.element.classList.toggle("wearing", wearing);
+            card.button.element.setAttribute("aria-pressed", String(wearing));
+            const baseAriaLabel = wearing ? card.selectedAriaLabel : card.defaultAriaLabel;
+            card.button.setAriaLabel(card.achievementId && ( this.unseenAchievementIds.has(card.achievementId)) ? ( localize(8369, "{0}. New", baseAriaLabel)) : baseAriaLabel);
+            card.state.textContent = wearing ? ( localize(8350, "Wearing")) : card.defaultState;
+        }
+        this.focusTarget = () => this.accessoryCards.get(selectedId)?.button.focus();
+    }
+    updateNewAchievements(achievementIds) {
+        this.unseenAchievementIds = ( new Set(achievementIds));
+        for (const card of ( this.accessoryCards.values())) {
+            card.newBadge?.classList.toggle("hidden", !card.achievementId || !( this.unseenAchievementIds.has(card.achievementId)));
+        }
+        this.updateSelectedAccessory(this.chatPetService.selectedAccessory.read(undefined));
+    }
+};
+ChatPetAchievementsWidget = ( __decorate([( __param(2, IChatPetService)), ( __param(3, IThemeService)), ( __param(4, ILogService))], ChatPetAchievementsWidget));
+
+export { ChatPetAchievementsWidget };

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

@@ -0,0 +1,22 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
+/**
+ * Surfaces a model's promo as a chat input notification, scoped to the harness
+ * (chat session type) of the model that carries it. Promos only render where a
+ * model switch is still plausible: persistent chat surfaces whose session has
+ * not started yet, and only when the promo is banner-eligible (`showBanner` is
+ * not `false`). Dismissals are persisted by promo id in application storage,
+ * so they survive reloads and apply to every open window.
+ */
+export declare class ChatPromoNotificationContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _languageModelsService;
+    private readonly _chatInputNotificationService;
+    private readonly _storageService;
+    static readonly ID = "workbench.contrib.chatPromoNotification";
+    constructor(_languageModelsService: ILanguageModelsService, _chatInputNotificationService: IChatInputNotificationService, _storageService: IStorageService);
+    private readonly _shownNotifications;
+    private _update;
+}

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

@@ -0,0 +1,103 @@
+
+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 { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+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 { addDismissedNotificationId, readDismissedNotificationIds, matchesModelIdentifier, ChatInputNotificationActionKind, ChatInputNotificationSeverity } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
+
+const PROMO_NOTIFICATION_ID = "copilot.promoNotification";
+const DISMISSED_PROMOS_STORAGE_KEY = "chat.dismissedPromoIds";
+function isPromoVisible(context) {
+    return context.deferredNotificationsEnabled && !context.isTransientChat && !context.sessionStarted;
+}
+let ChatPromoNotificationContribution = class ChatPromoNotificationContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatPromoNotification";
+    }
+    constructor(_languageModelsService, _chatInputNotificationService, _storageService) {
+        super();
+        this._languageModelsService = _languageModelsService;
+        this._chatInputNotificationService = _chatInputNotificationService;
+        this._storageService = _storageService;
+        this._shownNotifications = ( new Map());
+        this._register(
+            this._languageModelsService.onDidChangeLanguageModels(() => this._update())
+        );
+        this._register(this._chatInputNotificationService.onDidDismiss(id => {
+            const promoId = this._shownNotifications.get(id)?.promoId;
+            if (promoId) {
+                addDismissedNotificationId(this._storageService, DISMISSED_PROMOS_STORAGE_KEY, promoId);
+                this._update();
+            }
+        }));
+        this._register(
+            this._storageService.onDidChangeValue(StorageScope.APPLICATION, DISMISSED_PROMOS_STORAGE_KEY, this._store)(() => this._update())
+        );
+        this._update();
+    }
+    _update() {
+        const dismissed = readDismissedNotificationIds(this._storageService, DISMISSED_PROMOS_STORAGE_KEY);
+        const modelIds = this._languageModelsService.getLanguageModelIds();
+        const promoByHarness = ( new Map());
+        for (const id of modelIds) {
+            const meta = this._languageModelsService.lookupLanguageModel(id);
+            if (!meta || !ILanguageModelChatMetadata.hasPromoBanner(meta) || ( dismissed.has(meta.promo.id))) {
+                continue;
+            }
+            const harness = meta.targetChatSessionType ?? localChatSessionType;
+            const current = promoByHarness.get(harness);
+            if (!current || (!ILanguageModelChatMetadata.hasPromoDiscount(current.metadata) && ILanguageModelChatMetadata.hasPromoDiscount(meta))) {
+                promoByHarness.set(harness, {
+                    identifier: id,
+                    metadata: meta
+                });
+            }
+        }
+        const desired = ( new Set());
+        for (const [harness, model] of promoByHarness) {
+            const promo = model.metadata.promo;
+            const notificationId = `${PROMO_NOTIFICATION_ID}.${harness}`;
+            desired.add(notificationId);
+            const shownNotification = this._shownNotifications.get(notificationId);
+            if (shownNotification?.modelIdentifier === model.identifier && shownNotification.promoId === promo.id) {
+                continue;
+            }
+            this._shownNotifications.set(notificationId, {
+                promoId: promo.id,
+                modelIdentifier: model.identifier
+            });
+            const description = ILanguageModelChatMetadata.getPromoEndsAtLabel(promo.endsAt);
+            const action = {
+                label: ( localize(8377, "Try {0}", model.metadata.name)),
+                kind: ChatInputNotificationActionKind.SwitchToModel,
+                matchesModel: matchesModelIdentifier(model.identifier)
+            };
+            this._chatInputNotificationService.setNotification({
+                id: notificationId,
+                telemetryId: promo.id,
+                severity: ChatInputNotificationSeverity.Info,
+                message: promo.message,
+                description,
+                actions: [action],
+                when: isPromoVisible,
+                dismissible: true,
+                autoDismissOnMessage: false,
+                sessionTypes: [harness]
+            });
+        }
+        for (const notificationId of [...( this._shownNotifications.keys())]) {
+            if (!( desired.has(notificationId))) {
+                this._chatInputNotificationService.deleteNotification(notificationId);
+                this._shownNotifications.delete(notificationId);
+            }
+        }
+    }
+};
+ChatPromoNotificationContribution = ( __decorate([( __param(0, ILanguageModelsService)), ( __param(1, IChatInputNotificationService)), ( __param(2, IStorageService))], ChatPromoNotificationContribution));
+
+export { ChatPromoNotificationContribution };

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

@@ -1,12 +1,9 @@
 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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
 import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
-import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
 import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
 /**
  * Core-side workbench contribution that shows chat input notifications for
@@ -23,11 +20,8 @@ import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vsco
 export declare class ChatQuotaNotificationContribution extends Disposable implements IWorkbenchContribution {
     private readonly _chatEntitlementService;
     private readonly _chatInputNotificationService;
-    private readonly _contextKeyService;
-    private readonly _languageModelsService;
     private readonly _storageService;
     private readonly _assignmentService;
-    private readonly _telemetryService;
     private readonly _logService;
     static readonly ID = "workbench.contrib.chatQuotaNotification";
     /** Tracks whether the current notification is the quota-exhausted variant. */
@@ -41,32 +35,17 @@ export declare class ChatQuotaNotificationContribution extends Disposable implem
     private _prevAdditionalUsageEnabled;
     private _prevSessionPercentUsed;
     private _prevWeeklyPercentUsed;
-    private _trajectoryTreatment;
-    private _trajectoryAssignmentRequested;
-    constructor(_chatEntitlementService: IChatEntitlementService, _chatInputNotificationService: IChatInputNotificationService, _contextKeyService: IContextKeyService, _languageModelsService: ILanguageModelsService, _storageService: IStorageService, _assignmentService: IWorkbenchAssignmentService, _telemetryService: ITelemetryService, _logService: ILogService);
-    /**
-     * Reads the already-evaluated trajectory experiment cohort. The assignment
-     * service resolves the cohort asynchronously, so this is requested only once
-     * the user has met every non-experiment condition required for the nudge.
-     *
-     * Stores the raw treatment value. `undefined` means the user is not
-     * assigned to the flight (or assignments are not available); only a `true`
-     * treatment renders the nudge. We deliberately do not coerce a missing
-     * assignment into a synthetic "control" value, since that would assume an
-     * enrollment that may not exist. Enrollment telemetry is emitted only when
-     * the user is actually assigned to a flight.
-     */
-    private _resolveTrajectoryTreatment;
-    private _requestTrajectoryTreatment;
+    private _switchToAutoTreatment;
+    private _switchToAutoAssignmentRequested;
+    private _activeQuotaWarning;
+    constructor(_chatEntitlementService: IChatEntitlementService, _chatInputNotificationService: IChatInputNotificationService, _storageService: IStorageService, _assignmentService: IWorkbenchAssignmentService, _logService: ILogService);
+    private _resolveSwitchToAutoTreatment;
+    private _requestSwitchToAutoTreatment;
     private _getRelevantSnapshot;
     private _isQuotaUsedUp;
     private _isUBBEligible;
     private _update;
     private _computeQuotaWarning;
-    private _computeQuotaTrajectoryWarning;
-    private _showQuotaTrajectoryWarning;
-    private _handleCreditEfficiencyLearnMoreCommand;
-    private _logQuotaTrajectoryNudgeEnrolled;
     /**
      * Returns the highest threshold that was newly crossed, or `undefined`.
      */
@@ -74,22 +53,16 @@ export declare class ChatQuotaNotificationContribution extends Disposable implem
     private _showExhaustedNotification;
     private _showOverageActivationNotification;
     private _showQuotaApproachingWarning;
+    private _setQuotaApproachingNotification;
     private _computeRateLimitWarning;
     private _checkRateLimitCrossing;
     private _showRateLimitWarning;
-    /**
-     * Returns `true` only when a Copilot model is actively selected.
-     * Returns `false` if no model is selected yet (widget not initialized)
-     * or if the selected model is from a non-Copilot vendor (BYOK).
-     */
-    private _isCopilotModelSelected;
+    private _clearInactiveQuotaWarning;
+    private _getActiveQuotaWarning;
     private _isManagedPlan;
     private _isManagedPlanBlocked;
     private _showManagedPlanBlockedNotification;
     private _formatResetDate;
-    private _getTrajectoryPeriodKey;
-    private _isTrajectoryShownInCurrentPeriod;
-    private _storeTrajectoryShown;
     private _setNotification;
     private _hideNotification;
     /**