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

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

@@ -1,109 +1,665 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { StorageScope, StorageTarget } 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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { CreateSlashCommandsUsageTracker } from './createSlashCommandsUsageTracker.js';
+import { ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatRequestDynamicVariablePart, ChatRequestSlashCommandPart, ChatRequestAgentSubcommandPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { TipEligibilityTracker } from './chatTipEligibilityTracker.js';
+import { TIP_CATALOG, ChatTipTier, extractCommandIds } from './chatTipCatalog.js';
+import { TipTrackingCommands, ChatTipStorageKeys } from './chatTipStorageKeys.js';
 
-const TIP_CATALOG = [{
-    id: "tip.agentMode",
-    message: ( localize(
-        5676,
-        "Tip: Try [Agent mode](command:workbench.action.chat.openEditSession) for multi-file edits and running commands."
-    )),
-    when: ( ChatContextKeys.chatModeKind.notEqualsTo(ChatModeKind.Agent)),
-    enabledCommands: ["workbench.action.chat.openEditSession"]
-}, {
-    id: "tip.planMode",
-    message: ( localize(
-        5677,
-        "Tip: Try [Plan mode](command:workbench.action.chat.openPlan) to let the agent perform deep analysis and planning before implementing changes."
-    )),
-    when: ( ChatContextKeys.chatModeName.notEqualsTo("Plan")),
-    enabledCommands: ["workbench.action.chat.openPlan"]
-}, {
-    id: "tip.attachFiles",
-    message: ( localize(5678, "Tip: Attach files or folders with # to give Copilot more context."))
-}, {
-    id: "tip.codeActions",
-    message: ( localize(
-        5679,
-        "Tip: Select code and right-click for Copilot actions in the context menu."
-    ))
-}, {
-    id: "tip.undoChanges",
-    message: ( localize(
-        5680,
-        "Tip: You can undo Copilot's changes to any point by clicking Restore Checkpoint."
-    )),
-    when: ( ContextKeyExpr.or(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Edit))))
-}, {
-    id: "tip.customInstructions",
-    message: ( localize(
-        5681,
-        "Tip: [Generate workspace instructions](command:workbench.action.chat.generateInstructions) so Copilot always has the context it needs when starting a task."
-    )),
-    enabledCommands: ["workbench.action.chat.generateInstructions"]
-}];
-let ChatTipService = class ChatTipService {
-    constructor(_productService, _configurationService) {
+const CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND = TipTrackingCommands.CreateAgentInstructionsUsed;
+const CREATE_PROMPT_TRACKING_COMMAND = TipTrackingCommands.CreatePromptUsed;
+const CREATE_AGENT_TRACKING_COMMAND = TipTrackingCommands.CreateAgentUsed;
+const CREATE_SKILL_TRACKING_COMMAND = TipTrackingCommands.CreateSkillUsed;
+const FORK_CONVERSATION_TRACKING_COMMAND = TipTrackingCommands.ForkConversationUsed;
+let ChatTipService = class ChatTipService extends Disposable {
+    constructor(
+        _productService,
+        _configurationService,
+        _storageService,
+        _chatService,
+        instantiationService,
+        _logService,
+        _chatEntitlementService,
+        _commandService,
+        _telemetryService,
+        _keybindingService
+    ) {
+        super();
         this._productService = _productService;
         this._configurationService = _configurationService;
-        this._createdAt = Date.now();
-        this._hasShownTip = false;
+        this._storageService = _storageService;
+        this._chatService = _chatService;
+        this._logService = _logService;
+        this._chatEntitlementService = _chatEntitlementService;
+        this._commandService = _commandService;
+        this._telemetryService = _telemetryService;
+        this._keybindingService = _keybindingService;
+        this._onDidDismissTip = this._register(( new Emitter()));
+        this.onDidDismissTip = this._onDidDismissTip.event;
+        this._onDidNavigateTip = this._register(( new Emitter()));
+        this.onDidNavigateTip = this._onDidNavigateTip.event;
+        this._onDidHideTip = this._register(( new Emitter()));
+        this.onDidHideTip = this._onDidHideTip.event;
+        this._onDidDisableTips = this._register(( new Emitter()));
+        this.onDidDisableTips = this._onDidDisableTips.event;
+        this._tipsHiddenForSession = false;
+        this._tipCommandListener = this._register(( new MutableDisposable()));
+        this._tracker = this._register(instantiationService.createInstance(TipEligibilityTracker, TIP_CATALOG));
+        this._createSlashCommandsUsageTracker = this._register(( new CreateSlashCommandsUsageTracker(this._chatService, this._storageService, () => this._contextKeyService)));
+        this._register(this._chatEntitlementService.onDidChangeQuotaExceeded(() => {
+            if (this._chatEntitlementService.quotas.chat?.percentRemaining === 0 && this._shownTip) {
+                this.hideTip();
+            }
+        }));
+        this._register(this._chatService.onDidSubmitRequest(e => {
+            const message = e.message ?? this._chatService.getSession(e.chatSessionResource)?.lastRequest?.message;
+            if (!message) {
+                return;
+            }
+            if (this._hasFileOrFolderReference(message)) {
+                this._tracker.recordCommandExecuted(TipTrackingCommands.AttachFilesReferenceUsed);
+            }
+            const slashCommandTrackingId = this._getSlashCommandTrackingId(message);
+            if (slashCommandTrackingId) {
+                this._tracker.recordCommandExecuted(slashCommandTrackingId);
+            }
+            this._hideShownTipIfNowIneligible();
+        }));
+        this._thinkingPhrasesEverModified = this._storageService.getBoolean(
+            ChatTipStorageKeys.ThinkingPhrasesEverModified,
+            StorageScope.APPLICATION,
+            false
+        );
+        if (!this._thinkingPhrasesEverModified && this._isSettingModified(ChatConfiguration.ThinkingPhrases)) {
+            this._thinkingPhrasesEverModified = true;
+            this._storageService.store(
+                ChatTipStorageKeys.ThinkingPhrasesEverModified,
+                true,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+        if (!this._thinkingPhrasesEverModified) {
+            this._register(this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration(ChatConfiguration.ThinkingPhrases)) {
+                    this._thinkingPhrasesEverModified = true;
+                    this._storageService.store(
+                        ChatTipStorageKeys.ThinkingPhrasesEverModified,
+                        true,
+                        StorageScope.APPLICATION,
+                        StorageTarget.MACHINE
+                    );
+                }
+            }));
+        }
+    }
+    _hasFileOrFolderReference(message) {
+        return ( message.parts.some(part => {
+            if (part.kind !== ChatRequestDynamicVariablePart.Kind) {
+                return false;
+            }
+            const dynamicPart = part;
+            return dynamicPart.isFile === true || dynamicPart.isDirectory === true;
+        }));
+    }
+    _getSlashCommandTrackingId(message) {
+        for (const part of message.parts) {
+            if (part.kind === ChatRequestSlashCommandPart.Kind) {
+                const slashCommand = part.slashCommand.command;
+                return this._toSlashCommandTrackingId(slashCommand);
+            }
+            if (part.kind === ChatRequestAgentSubcommandPart.Kind) {
+                const subCommand = part.command.name;
+                return this._toSlashCommandTrackingId(subCommand);
+            }
+        }
+        const trimmed = message.text.trimStart();
+        const match = /^(?:@\S+\s+)?\/(init|create-(?:instructions|prompt|agent|skill)|fork)(?:\s|$)/.exec(trimmed);
+        return match ? this._toSlashCommandTrackingId(match[1]) : undefined;
+    }
+    _toSlashCommandTrackingId(command) {
+        switch (command) {
+        case "init":
+        case "create-instructions":
+            return CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND;
+        case "create-prompt":
+            return CREATE_PROMPT_TRACKING_COMMAND;
+        case "create-agent":
+            return CREATE_AGENT_TRACKING_COMMAND;
+        case "create-skill":
+            return CREATE_SKILL_TRACKING_COMMAND;
+        case "fork":
+            return FORK_CONVERSATION_TRACKING_COMMAND;
+        default:
+            return undefined;
+        }
+    }
+    recordSlashCommandUsage(command) {
+        const trackingId = this._toSlashCommandTrackingId(command);
+        if (!trackingId) {
+            return;
+        }
+        this._tracker.recordCommandExecuted(trackingId);
+        this._hideShownTipIfNowIneligible();
+    }
+    resetSession() {
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._contextKeyService = undefined;
+        this._tipsHiddenForSession = false;
+    }
+    dismissTip() {
+        if (this._shownTip) {
+            this._logTipTelemetry(this._shownTip.id, "dismissed");
+            const dismissed = ( new Set(this._getDismissedTipIds()));
+            dismissed.add(this._shownTip.id);
+            this._storageService.store(
+                ChatTipStorageKeys.DismissedTips,
+                JSON.stringify([...dismissed]),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+        this._tipRequestId = undefined;
+        this._onDidDismissTip.fire();
+    }
+    dismissTipForSession() {
+        this.dismissTip();
+        this.hideTipsForSession();
+    }
+    clearDismissedTips() {
+        this._storageService.remove(ChatTipStorageKeys.DismissedTips, StorageScope.APPLICATION);
+        this._storageService.remove(ChatTipStorageKeys.DismissedTips, StorageScope.PROFILE);
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._contextKeyService = undefined;
+        this._tipsHiddenForSession = false;
+        this._onDidDismissTip.fire();
+    }
+    _getDismissedTipIds() {
+        const raw = this._readApplicationWithProfileFallback(ChatTipStorageKeys.DismissedTips);
+        if (!raw) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            this._logService.debug("#ChatTips dismissed:", parsed);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+            const knownTipIds = ( new Set(( TIP_CATALOG.map(tip => tip.id))));
+            const dismissed = ( new Set());
+            for (const value of parsed) {
+                if (typeof value === "string" && ( knownTipIds.has(value))) {
+                    dismissed.add(value);
+                }
+            }
+            return [...dismissed];
+        } catch {
+            return [];
+        }
+    }
+    hideTip() {
+        if (this._shownTip) {
+            this._logTipTelemetry(this._shownTip.id, "hidden");
+        }
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._onDidHideTip.fire();
     }
-    getNextTip(requestId, requestTimestamp, contextKeyService) {
+    hideTipsForSession() {
+        if (this._tipsHiddenForSession) {
+            return;
+        }
+        this._tipsHiddenForSession = true;
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._onDidHideTip.fire();
+    }
+    async disableTips() {
+        if (this._shownTip) {
+            this._logTipTelemetry(this._shownTip.id, "disabled");
+        }
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        await this._configurationService.updateValue("chat.tips.enabled", false, ConfigurationTarget.APPLICATION);
+        this._onDidDisableTips.fire();
+    }
+    getWelcomeTip(contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        this._tracker.recordCurrentMode(contextKeyService);
+        this._tracker.refreshPromptFileExclusions();
         if (!this._configurationService.getValue("chat.tips.enabled")) {
             return undefined;
         }
+        if (this._tipsHiddenForSession) {
+            return undefined;
+        }
+        this._contextKeyService = contextKeyService;
         if (!this._isCopilotEnabled()) {
             return undefined;
         }
-        if (this._tipRequestId === requestId && this._shownTip) {
-            return this._createTip(this._shownTip);
+        if (this._chatEntitlementService.entitlement === ChatEntitlement.Unknown) {
+            return undefined;
+        }
+        if (!this._isChatLocation(contextKeyService)) {
+            return undefined;
         }
-        if (this._hasShownTip) {
+        const foregroundSessionCount = contextKeyService.getContextKeyValue(ChatContextKeys.foregroundSessionCount.key);
+        if (foregroundSessionCount !== 1) {
             return undefined;
         }
-        if (requestTimestamp < this._createdAt) {
+        if (this._isChatQuotaExceeded(contextKeyService)) {
+            return undefined;
+        }
+        if (this._tipRequestId === "welcome" && this._shownTip) {
+            if (this._shownTip.id !== "tip.switchToAuto") {
+                const switchToAutoTip = TIP_CATALOG.find(tip => tip.id === "tip.switchToAuto");
+                if (switchToAutoTip) {
+                    const dismissedIds = ( new Set(this._getDismissedTipIds()));
+                    if (!( dismissedIds.has(switchToAutoTip.id)) && this._isEligible(switchToAutoTip, contextKeyService)) {
+                        this._shownTip = switchToAutoTip;
+                        this._storageService.store(
+                            ChatTipStorageKeys.LastTipId,
+                            switchToAutoTip.id,
+                            StorageScope.APPLICATION,
+                            StorageTarget.USER
+                        );
+                        const tip = this._createTip(switchToAutoTip);
+                        this._logTipTelemetry(switchToAutoTip.id, "shown");
+                        this._trackTipCommandClicks(switchToAutoTip);
+                        this._onDidNavigateTip.fire(tip);
+                        return tip;
+                    }
+                }
+            }
+            if (!this._isEligible(this._shownTip, contextKeyService)) {
+                if (this._tracker.isExcluded(this._shownTip)) {
+                    this.hideTip();
+                    return undefined;
+                }
+                const nextTip = this._findNextEligibleTip(this._shownTip.id, contextKeyService);
+                if (nextTip) {
+                    this._shownTip = nextTip;
+                    this._storageService.store(
+                        ChatTipStorageKeys.LastTipId,
+                        nextTip.id,
+                        StorageScope.APPLICATION,
+                        StorageTarget.USER
+                    );
+                    const tip = this._createTip(nextTip);
+                    this._onDidNavigateTip.fire(tip);
+                    return tip;
+                }
+                this.hideTip();
+                return undefined;
+            }
+            return this._createTip(this._shownTip);
+        }
+        const tip = this._pickTip("welcome", contextKeyService);
+        return tip;
+    }
+    _findNextEligibleTip(currentTipId, contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        const currentIndex = TIP_CATALOG.findIndex(tip => tip.id === currentTipId);
+        if (currentIndex === -1) {
             return undefined;
         }
-        const eligibleTips = TIP_CATALOG.filter(tip => this._isEligible(tip, contextKeyService));
-        if (eligibleTips.length === 0) {
+        const dismissedIds = ( new Set(this._getDismissedTipIds()));
+        for (let i = 1; i < TIP_CATALOG.length; i++) {
+            const idx = (currentIndex + i) % TIP_CATALOG.length;
+            const candidate = TIP_CATALOG[idx];
+            if (!( dismissedIds.has(candidate.id)) && this._isEligible(candidate, contextKeyService)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    _hideShownTipIfNowIneligible() {
+        if (!this._shownTip || !this._contextKeyService) {
+            return;
+        }
+        if (this._tipsHiddenForSession) {
+            return;
+        }
+        if (this._isEligible(this._shownTip, this._contextKeyService)) {
+            return;
+        }
+        this.hideTip();
+    }
+    _pickTip(sourceId, contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        this._tracker.recordCurrentMode(contextKeyService);
+        const dismissedIds = ( new Set(this._getDismissedTipIds()));
+        const eligibleTips = TIP_CATALOG.filter(tip => !( dismissedIds.has(tip.id)) && this._isEligible(tip, contextKeyService));
+        const selectedTip = this._selectTipByTier(eligibleTips);
+        if (!selectedTip) {
             return undefined;
         }
-        const randomIndex = Math.floor(Math.random() * eligibleTips.length);
-        const selectedTip = eligibleTips[randomIndex];
-        this._hasShownTip = true;
-        this._tipRequestId = requestId;
+        this._storageService.store(
+            ChatTipStorageKeys.LastTipId,
+            selectedTip.id,
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
+        this._tipRequestId = sourceId;
         this._shownTip = selectedTip;
+        this._logTipTelemetry(selectedTip.id, "shown");
+        this._trackTipCommandClicks(selectedTip);
         return this._createTip(selectedTip);
     }
-    _isEligible(tip, contextKeyService) {
-        if (!tip.when) {
+    _selectTipByTier(eligibleTips) {
+        const foundationalTips = eligibleTips.filter(tip => tip.tier === ChatTipTier.Foundational);
+        if (foundationalTips.length) {
+            return this._sortByPriorityAndCatalogOrder(foundationalTips)[0];
+        }
+        const qolTips = eligibleTips.filter(tip => tip.tier === ChatTipTier.Qol);
+        if (!qolTips.length) {
+            return undefined;
+        }
+        const randomIndex = Math.floor(Math.random() * qolTips.length);
+        return qolTips[randomIndex];
+    }
+    navigateToNextTip() {
+        if (!this._contextKeyService) {
+            return undefined;
+        }
+        return this._navigateTip(1, this._contextKeyService);
+    }
+    navigateToPreviousTip() {
+        if (!this._contextKeyService) {
+            return undefined;
+        }
+        return this._navigateTip(-1, this._contextKeyService);
+    }
+    getNextEligibleTip() {
+        if (!this._contextKeyService || !this._shownTip) {
+            return undefined;
+        }
+        const contextKeyService = this._contextKeyService;
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        const currentTipId = this._shownTip.id;
+        const orderedTips = this._getOrderedEligibleTips(contextKeyService, {
+            includeTipId: currentTipId
+        });
+        if (!orderedTips.length) {
+            return undefined;
+        }
+        const currentIndex = orderedTips.findIndex(tip => tip.id === currentTipId);
+        const candidate = this._getNextTipFromOrderedList(orderedTips, currentIndex, currentTipId);
+        if (candidate) {
+            this._shownTip = candidate;
+            this._tipRequestId = "welcome";
+            this._storageService.store(
+                ChatTipStorageKeys.LastTipId,
+                candidate.id,
+                StorageScope.APPLICATION,
+                StorageTarget.USER
+            );
+            this._logTipTelemetry(candidate.id, "shown");
+            this._trackTipCommandClicks(candidate);
+            return this._createTip(candidate);
+        }
+        return undefined;
+    }
+    _getNextTipFromOrderedList(orderedTips, startIndex, currentTipId) {
+        if (!orderedTips.length) {
+            return undefined;
+        }
+        const fallbackIndex = 0;
+        const normalizedStartIndex = startIndex === -1 ? fallbackIndex : startIndex;
+        for (let i = 1; i <= orderedTips.length; i++) {
+            const index = (normalizedStartIndex + i) % orderedTips.length;
+            const candidate = orderedTips[index];
+            if (candidate.id !== currentTipId) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    hasMultipleTips() {
+        if (!this._contextKeyService) {
+            return false;
+        }
+        this._createSlashCommandsUsageTracker.syncContextKey(this._contextKeyService);
+        return this._hasNavigableTip(this._contextKeyService);
+    }
+    _navigateTip(direction, contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        if (!this._shownTip) {
+            return undefined;
+        }
+        const orderedTips = this._getOrderedEligibleTips(contextKeyService);
+        if (!orderedTips.length) {
+            return undefined;
+        }
+        const currentIndex = orderedTips.findIndex(tip => tip.id === this._shownTip.id);
+        if (orderedTips.length === 1 && currentIndex !== -1) {
+            return undefined;
+        }
+        const fallbackIndex = direction === 1 ? 0 : orderedTips.length - 1;
+        const nextIndex = currentIndex === -1 ? fallbackIndex : (currentIndex + direction + orderedTips.length) % orderedTips.length;
+        const candidate = orderedTips[nextIndex];
+        if (candidate) {
+            this._logTipTelemetry(this._shownTip.id, direction === 1 ? "navigateNext" : "navigatePrevious");
+            this._shownTip = candidate;
+            this._tipRequestId = "welcome";
+            this._storageService.store(
+                ChatTipStorageKeys.LastTipId,
+                candidate.id,
+                StorageScope.APPLICATION,
+                StorageTarget.USER
+            );
+            this._logTipTelemetry(candidate.id, "shown");
+            this._trackTipCommandClicks(candidate);
+            const tip = this._createTip(candidate);
+            this._onDidNavigateTip.fire(tip);
+            return tip;
+        }
+        return undefined;
+    }
+    _hasNavigableTip(contextKeyService) {
+        const orderedTips = this._getOrderedEligibleTips(contextKeyService);
+        if (!orderedTips.length) {
+            return false;
+        }
+        if (!this._shownTip) {
+            return orderedTips.length > 1;
+        }
+        if (orderedTips.length > 1) {
             return true;
         }
-        return contextKeyService.contextMatchesRules(tip.when);
+        return orderedTips[0].id !== this._shownTip.id;
+    }
+    _getOrderedEligibleTips(contextKeyService, options) {
+        const dismissedIds = ( new Set(this._getDismissedTipIds()));
+        const eligibleTips = TIP_CATALOG.filter(tip => {
+            if (options?.includeTipId && tip.id === options.includeTipId) {
+                return true;
+            }
+            if (options?.excludeShownTip && this._shownTip && tip.id === this._shownTip.id) {
+                return false;
+            }
+            return !( dismissedIds.has(tip.id)) && this._isEligible(tip, contextKeyService);
+        });
+        const foundationalTips = this._sortByPriorityAndCatalogOrder(eligibleTips.filter(tip => tip.tier === ChatTipTier.Foundational));
+        const qolTips = this._sortByPriorityAndCatalogOrder(eligibleTips.filter(tip => tip.tier === ChatTipTier.Qol));
+        return [...foundationalTips, ...qolTips];
+    }
+    _sortByPriorityAndCatalogOrder(tips) {
+        return [...tips].sort((a, b) => {
+            const aPriority = a.priority ?? Number.POSITIVE_INFINITY;
+            const bPriority = b.priority ?? Number.POSITIVE_INFINITY;
+            if (aPriority !== bPriority) {
+                return aPriority - bPriority;
+            }
+            const aCatalogIndex = TIP_CATALOG.findIndex(tip => tip.id === a.id);
+            const bCatalogIndex = TIP_CATALOG.findIndex(tip => tip.id === b.id);
+            return aCatalogIndex - bCatalogIndex;
+        });
+    }
+    _isEligible(tip, contextKeyService) {
+        if (tip.onlyWhenModelIds?.length) {
+            const currentModelId = this._getCurrentChatModelId(contextKeyService);
+            const isModelMatch = ( tip.onlyWhenModelIds.some(
+                modelId => currentModelId === modelId || currentModelId.startsWith(`${modelId}-`)
+            ));
+            if (!isModelMatch) {
+                return false;
+            }
+        }
+        if (tip.excludeWhenSettingsChanged?.some(setting => this._isSettingModified(setting))) {
+            this._logService.debug(
+                "#ChatTips: tip excluded because setting was modified",
+                tip.id,
+                tip.excludeWhenSettingsChanged
+            );
+            return false;
+        }
+        if (tip.when && !contextKeyService.contextMatchesRules(tip.when)) {
+            this._logService.debug(
+                "#ChatTips: tip is not eligible due to when clause",
+                tip.id,
+                tip.when.serialize()
+            );
+            return false;
+        }
+        if (this._tracker.isExcluded(tip)) {
+            return false;
+        }
+        if (tip.id === "tip.thinkingPhrases" && this._thinkingPhrasesEverModified) {
+            this._logService.debug(
+                "#ChatTips: tip excluded because thinking phrases setting was previously modified",
+                tip.id
+            );
+            return false;
+        }
+        this._logService.debug("#ChatTips: tip is eligible", tip.id);
+        return true;
+    }
+    _isSettingModified(key) {
+        const inspected = this._configurationService.inspect(key);
+        return inspected.userValue !== undefined || inspected.userLocalValue !== undefined || inspected.userRemoteValue !== undefined || inspected.workspaceValue !== undefined || inspected.workspaceFolderValue !== undefined;
+    }
+    _getCurrentChatModelId(contextKeyService) {
+        const normalize = modelId => {
+            const normalizedModelId = modelId?.toLowerCase() ?? "";
+            if (!normalizedModelId) {
+                return "";
+            }
+            if (normalizedModelId.includes("/")) {
+                return normalizedModelId.split("/").at(-1) ?? "";
+            }
+            return normalizedModelId;
+        };
+        const contextKeyModelId = normalize(contextKeyService.getContextKeyValue(ChatContextKeys.chatModelId.key));
+        if (contextKeyModelId) {
+            return contextKeyModelId;
+        }
+        const location = contextKeyService.getContextKeyValue(ChatContextKeys.location.key) ?? ChatAgentLocation.Chat;
+        const sessionType = contextKeyService.getContextKeyValue(ChatContextKeys.chatSessionType.key) ?? "";
+        const candidateStorageKeys = sessionType ? [
+            `chat.currentLanguageModel.${location}.${sessionType}`,
+            `chat.currentLanguageModel.${location}`
+        ] : [`chat.currentLanguageModel.${location}`];
+        for (const storageKey of candidateStorageKeys) {
+            const persistedModelIdentifier = this._storageService.get(storageKey, StorageScope.APPLICATION);
+            const persistedModelId = normalize(persistedModelIdentifier);
+            if (persistedModelId) {
+                return persistedModelId;
+            }
+        }
+        return "";
+    }
+    _isChatLocation(contextKeyService) {
+        const location = contextKeyService.getContextKeyValue(ChatContextKeys.location.key);
+        return !location || location === ChatAgentLocation.Chat;
+    }
+    _isChatQuotaExceeded(contextKeyService) {
+        return contextKeyService.getContextKeyValue(ChatContextKeys.chatQuotaExceeded.key) === true;
     }
     _isCopilotEnabled() {
         const defaultChatAgent = this._productService.defaultChatAgent;
         return !!defaultChatAgent?.chatExtensionId;
     }
     _createTip(tipDef) {
-        const markdown = ( new MarkdownString(tipDef.message, {
-            isTrusted: tipDef.enabledCommands ? {
-                enabledCommands: tipDef.enabledCommands
+        const ctx = {
+            keybindingService: this._keybindingService
+        };
+        const rawMessage = tipDef.buildMessage(ctx);
+        const prefixedMessage = ( localize(6232, "**Tip:** {0}", rawMessage.value));
+        const enabledCommands = extractCommandIds(prefixedMessage);
+        const markdown = ( new MarkdownString(prefixedMessage, {
+            isTrusted: enabledCommands.length > 0 ? {
+                enabledCommands
             } : false
         }));
         return {
             id: tipDef.id,
-            content: markdown
+            content: markdown,
+            enabledCommands
         };
     }
+    _logTipTelemetry(tipId, action, commandId) {
+        this._telemetryService.publicLog2("chatTip", {
+            tipId,
+            action,
+            commandId
+        });
+    }
+    _trackTipCommandClicks(tip) {
+        this._tipCommandListener.clear();
+        const ctx = {
+            keybindingService: this._keybindingService
+        };
+        const rawMessage = tip.buildMessage(ctx);
+        const enabledCommands = extractCommandIds(rawMessage.value);
+        if (!enabledCommands.length) {
+            return;
+        }
+        const enabledCommandSet = ( new Set(enabledCommands));
+        const dismissCommandSet = ( new Set(tip.dismissWhenCommandsClicked));
+        this._tipCommandListener.value = this._commandService.onDidExecuteCommand(e => {
+            if (( enabledCommandSet.has(e.commandId)) && this._shownTip?.id === tip.id) {
+                this._logTipTelemetry(tip.id, "commandClicked", e.commandId);
+                if (( dismissCommandSet.has(e.commandId))) {
+                    this.dismissTip();
+                }
+                this.hideTipsForSession();
+            }
+        });
+    }
+    _readApplicationWithProfileFallback(key) {
+        const applicationValue = this._storageService.get(key, StorageScope.APPLICATION);
+        if (applicationValue) {
+            return applicationValue;
+        }
+        const profileValue = this._storageService.get(key, StorageScope.PROFILE);
+        if (profileValue) {
+            this._storageService.store(key, profileValue, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        }
+        return profileValue;
+    }
 };
-ChatTipService = ( __decorate([( __param(0, IProductService)), ( __param(1, IConfigurationService))], ChatTipService));
+ChatTipService = ( __decorate([( __param(0, IProductService)), ( __param(1, IConfigurationService)), ( __param(2, IStorageService)), ( __param(3, IChatService)), ( __param(4, IInstantiationService)), ( __param(5, ILogService)), ( __param(6, IChatEntitlementService)), ( __param(7, ICommandService)), ( __param(8, ITelemetryService)), ( __param(9, IKeybindingService))], ChatTipService));
 
-export { ChatTipService };
+export { CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND, CREATE_AGENT_TRACKING_COMMAND, CREATE_PROMPT_TRACKING_COMMAND, CREATE_SKILL_TRACKING_COMMAND, ChatTipService, FORK_CONVERSATION_TRACKING_COMMAND, TipEligibilityTracker, TipTrackingCommands };