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

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

@@ -0,0 +1,245 @@
+
+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 '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatConfiguration, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { TipTrackingCommands } from './chatTipStorageKeys.js';
+import { GENERATE_AGENT_INSTRUCTIONS_COMMAND_ID, GENERATE_PROMPT_COMMAND_ID, GENERATE_AGENT_COMMAND_ID, GENERATE_SKILL_COMMAND_ID, INSERT_FORK_CONVERSATION_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+
+var ChatTipTier;
+(function(ChatTipTier) {
+    ChatTipTier["Foundational"] = "foundational";
+    ChatTipTier["Qol"] = "qol";
+})(ChatTipTier || (ChatTipTier = {}));
+function formatKeybinding(ctx, commandId) {
+    const kb = ctx.keybindingService.lookupKeybinding(commandId);
+    return kb ? ` (${kb.getLabel()})` : "";
+}
+function extractCommandIds(markdown) {
+    const commandPattern = /\[.*?\]\(command:([^?\s)]+)/g;
+    const commands = ( new Set());
+    let match;
+    while ((match = commandPattern.exec(markdown)) !== null) {
+        commands.add(match[1]);
+    }
+    return [...commands];
+}
+const TIP_CATALOG = [{
+    id: "tip.switchToAuto",
+    tier: ChatTipTier.Foundational,
+    priority: 0,
+    buildMessage(_ctx) {
+        return (new MarkdownString(localize(
+            6217,
+            "Using GPT-4.1? Try switching to [Auto](command:workbench.action.chat.openModelPicker) in the model picker for better coding performance."
+        )));
+    },
+    onlyWhenModelIds: ["gpt-4.1"]
+}, {
+    id: "tip.init",
+    tier: ChatTipTier.Foundational,
+    priority: 50,
+    buildMessage(ctx) {
+        const kb = formatKeybinding(ctx, GENERATE_AGENT_INSTRUCTIONS_COMMAND_ID);
+        return (new MarkdownString(localize(
+            6218,
+            "Use [{0}](command:{1}){2} to generate or update a workspace instructions file for AI coding agents.",
+            "/init",
+            GENERATE_AGENT_INSTRUCTIONS_COMMAND_ID,
+            kb
+        )));
+    },
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    excludeWhenCommandsExecuted: [
+        GENERATE_AGENT_INSTRUCTIONS_COMMAND_ID,
+        TipTrackingCommands.CreateAgentInstructionsUsed
+    ]
+}, {
+    id: "tip.createPrompt",
+    tier: ChatTipTier.Foundational,
+    buildMessage(ctx) {
+        const kb = formatKeybinding(ctx, GENERATE_PROMPT_COMMAND_ID);
+        return (new MarkdownString(localize(
+            6219,
+            "Use [{0}](command:{1}){2} to generate a reusable prompt file with the agent.",
+            "/create-prompt",
+            GENERATE_PROMPT_COMMAND_ID,
+            kb
+        )));
+    },
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    excludeWhenCommandsExecuted: [GENERATE_PROMPT_COMMAND_ID, TipTrackingCommands.CreatePromptUsed]
+}, {
+    id: "tip.createAgent",
+    tier: ChatTipTier.Foundational,
+    priority: 30,
+    buildMessage(ctx) {
+        const kb = formatKeybinding(ctx, GENERATE_AGENT_COMMAND_ID);
+        return (new MarkdownString(localize(
+            6220,
+            "Use [{0}](command:{1}){2} to scaffold a custom agent for your workflow.",
+            "/create-agent",
+            GENERATE_AGENT_COMMAND_ID,
+            kb
+        )));
+    },
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    excludeWhenCommandsExecuted: [GENERATE_AGENT_COMMAND_ID, TipTrackingCommands.CreateAgentUsed]
+}, {
+    id: "tip.createSkill",
+    tier: ChatTipTier.Foundational,
+    priority: 40,
+    buildMessage(ctx) {
+        const kb = formatKeybinding(ctx, GENERATE_SKILL_COMMAND_ID);
+        return (new MarkdownString(localize(
+            6221,
+            "Use [{0}](command:{1}){2} to create a skill the agent can load when relevant.",
+            "/create-skill",
+            GENERATE_SKILL_COMMAND_ID,
+            kb
+        )));
+    },
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    excludeWhenCommandsExecuted: [GENERATE_SKILL_COMMAND_ID, TipTrackingCommands.CreateSkillUsed]
+}, {
+    id: "tip.planMode",
+    tier: ChatTipTier.Foundational,
+    priority: 20,
+    buildMessage(ctx) {
+        const kb = formatKeybinding(ctx, "workbench.action.chat.openPlan");
+        return (new MarkdownString(localize(
+            6222,
+            "Try the [{0}](command:workbench.action.chat.openPlan){1} to research and plan before implementing changes.",
+            "Plan agent",
+            kb
+        )));
+    },
+    when: ( ChatContextKeys.chatModeName.notEqualsTo("Plan")),
+    excludeWhenCommandsExecuted: ["workbench.action.chat.openPlan"],
+    excludeWhenModesUsed: ["Plan"]
+}, {
+    id: "tip.attachFiles",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(localize(
+            6223,
+            "Reference files or folders with # to give the agent more context about the task."
+        )));
+    },
+    excludeWhenCommandsExecuted: [
+        "workbench.action.chat.attachContext",
+        "workbench.action.chat.attachFile",
+        "workbench.action.chat.attachFolder",
+        "workbench.action.chat.attachSelection",
+        TipTrackingCommands.AttachFilesReferenceUsed
+    ]
+}, {
+    id: "tip.codeActions",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(localize(
+            6224,
+            "Select a code block in the editor and right-click to access more AI actions."
+        )));
+    },
+    excludeWhenCommandsExecuted: ["inlineChat.start"]
+}, {
+    id: "tip.undoChanges",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(localize(
+            6225,
+            "Hover a previous request and select \"Restore Checkpoint\" to undo changes after that point in the chat conversation."
+        )));
+    },
+    when: ( ContextKeyExpr.and(( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)), ( ContextKeyExpr.or(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Edit)))))),
+    excludeWhenCommandsExecuted: [
+        "workbench.action.chat.restoreCheckpoint",
+        "workbench.action.chat.restoreLastCheckpoint"
+    ]
+}, {
+    id: "tip.messageQueueing",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(localize(
+            6226,
+            "Steer the agent mid-task by sending follow-up messages. They queue and apply in order."
+        )));
+    },
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    excludeWhenCommandsExecuted: [
+        "workbench.action.chat.queueMessage",
+        "workbench.action.chat.steerWithMessage"
+    ]
+}, {
+    id: "tip.forkConversation",
+    tier: ChatTipTier.Qol,
+    buildMessage(ctx) {
+        const kb = formatKeybinding(ctx, INSERT_FORK_CONVERSATION_COMMAND_ID);
+        return (new MarkdownString(localize(
+            6227,
+            "Use [{0}](command:{1}){2} to branch the conversation. Explore a different approach without losing the original context.",
+            "/fork",
+            INSERT_FORK_CONVERSATION_COMMAND_ID,
+            kb
+        )));
+    },
+    excludeWhenCommandsExecuted: [
+        INSERT_FORK_CONVERSATION_COMMAND_ID,
+        "workbench.action.chat.forkConversation",
+        TipTrackingCommands.ForkConversationUsed
+    ]
+}, {
+    id: "tip.agenticBrowser",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(localize(
+            6228,
+            "Enable [{0}](command:workbench.action.openSettings?%5B%22workbench.browser.enableChatTools%22%5D) to let the agent open and interact with pages in the Integrated Browser.",
+            "agentic browser integration"
+        )));
+    },
+    when: ( ContextKeyExpr.and(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ContextKeyExpr.notEquals("config.workbench.browser.enableChatTools", true)))),
+    excludeWhenSettingsChanged: ["workbench.browser.enableChatTools"],
+    dismissWhenCommandsClicked: ["workbench.action.openSettings"]
+}, {
+    id: "tip.mermaid",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(localize(
+            6229,
+            "Ask the agent to draw an architectural diagram or flow chart. It can render Mermaid diagrams directly in chat."
+        )));
+    },
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    excludeWhenToolsInvoked: ["renderMermaidDiagram"]
+}, {
+    id: "tip.subagents",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(
+            localize(6230, "Ask the agent to work in parallel to complete large tasks faster.")
+        ));
+    },
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    excludeWhenToolsInvoked: ["runSubagent"]
+}, {
+    id: "tip.thinkingPhrases",
+    tier: ChatTipTier.Qol,
+    buildMessage() {
+        return (new MarkdownString(localize(
+            6231,
+            "Customize the loading messages shown while the agent works with [{0}](command:workbench.action.openSettings?%5B%22{1}%22%5D).",
+            "thinking phrases",
+            ChatConfiguration.ThinkingPhrases
+        )));
+    },
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    excludeWhenSettingsChanged: [ChatConfiguration.ThinkingPhrases],
+    dismissWhenCommandsClicked: ["workbench.action.openSettings"]
+}];
+
+export { ChatTipTier, TIP_CATALOG, extractCommandIds };

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

@@ -0,0 +1,78 @@
+import { Disposable } 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 { 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 { AgentFileType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+/**
+ * Interface for tip definitions that have exclusion criteria tracked by this class.
+ * This subset is all TipEligibilityTracker needs to know about tip definitions.
+ */
+export interface ITipExclusionConfig {
+    readonly id: string;
+    /** Command IDs that, if ever executed, make this tip ineligible. */
+    readonly excludeWhenCommandsExecuted?: readonly string[];
+    /** Chat mode names that, if ever used, make this tip ineligible. */
+    readonly excludeWhenModesUsed?: readonly string[];
+    /** Tool IDs that, if ever invoked, make this tip ineligible. */
+    readonly excludeWhenToolsInvoked?: readonly string[];
+    /** File-based exclusion configuration. */
+    readonly excludeWhenPromptFilesExist?: {
+        readonly promptType: PromptsType;
+        readonly agentFileType?: AgentFileType;
+        readonly excludeUntilChecked?: boolean;
+    };
+}
+/**
+ * Tracks user-level signals that determine whether certain tips should be
+ * excluded. Persists state to application storage and disposes listeners once all
+ * signals of interest have been observed.
+ */
+export declare class TipEligibilityTracker extends Disposable {
+    private readonly _storageService;
+    private readonly _promptsService;
+    private readonly _languageModelToolsService;
+    private readonly _logService;
+    private readonly _executedCommands;
+    private readonly _usedModes;
+    private readonly _invokedTools;
+    private readonly _pendingCommands;
+    private readonly _pendingModes;
+    private readonly _pendingTools;
+    private readonly _commandListener;
+    private readonly _toolListener;
+    /**
+     * Tip IDs excluded because prompt files of the required type exist in the workspace.
+     * Tips with `excludeUntilChecked` are pre-added and removed if no files are found.
+     */
+    private readonly _excludedByFiles;
+    /** Tips that have file-based exclusions, kept for re-checks. */
+    private readonly _tipsWithFileExclusions;
+    /** Generation counter per tip ID to discard stale async file-check results. */
+    private readonly _fileCheckGeneration;
+    private readonly _fileChecksInFlight;
+    constructor(tips: readonly ITipExclusionConfig[], commandService: ICommandService, _storageService: IStorageService, _promptsService: IPromptsService, _languageModelToolsService: ILanguageModelToolsService, _logService: ILogService);
+    recordCommandExecuted(commandId: string): void;
+    /**
+     * Records the current chat mode (kind + name) so future tip eligibility
+     * checks can exclude mode-related tips. No-ops once all tracked modes
+     * have been observed.
+     */
+    recordCurrentMode(contextKeyService: IContextKeyService): void;
+    /**
+     * Returns `true` when the tip should be **excluded** from the eligible set.
+     */
+    isExcluded(tip: ITipExclusionConfig): boolean;
+    /**
+     * Revalidates all file-based tip exclusions. Tips with `excludeUntilChecked`
+     * are conservatively hidden until the re-check completes.
+     */
+    refreshPromptFileExclusions(): void;
+    private _checkForPromptFiles;
+    private _doCheckForPromptFiles;
+    private _persistSet;
+    private _readApplicationWithProfileFallback;
+}

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

@@ -0,0 +1,234 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.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 { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { TipEligibilityStorageKeys } from './chatTipStorageKeys.js';
+
+let TipEligibilityTracker = class TipEligibilityTracker extends Disposable {
+    constructor(
+        tips,
+        commandService,
+        _storageService,
+        _promptsService,
+        _languageModelToolsService,
+        _logService
+    ) {
+        super();
+        this._storageService = _storageService;
+        this._promptsService = _promptsService;
+        this._languageModelToolsService = _languageModelToolsService;
+        this._logService = _logService;
+        this._commandListener = this._register(( new MutableDisposable()));
+        this._toolListener = this._register(( new MutableDisposable()));
+        this._excludedByFiles = ( new Set());
+        this._fileCheckGeneration = ( new Map());
+        this._fileChecksInFlight = ( new Map());
+        const storedCmds = this._readApplicationWithProfileFallback(TipEligibilityStorageKeys.ExecutedCommands);
+        this._executedCommands = ( new Set(storedCmds ? JSON.parse(storedCmds) : []));
+        const storedModes = this._readApplicationWithProfileFallback(TipEligibilityStorageKeys.UsedModes);
+        this._usedModes = ( new Set(storedModes ? JSON.parse(storedModes) : []));
+        const storedTools = this._readApplicationWithProfileFallback(TipEligibilityStorageKeys.InvokedTools);
+        this._invokedTools = ( new Set(storedTools ? JSON.parse(storedTools) : []));
+        this._pendingCommands = ( new Set());
+        for (const tip of tips) {
+            for (const cmd of tip.excludeWhenCommandsExecuted ?? []) {
+                if (!( this._executedCommands.has(cmd))) {
+                    this._pendingCommands.add(cmd);
+                }
+            }
+        }
+        this._pendingModes = ( new Set());
+        for (const tip of tips) {
+            for (const mode of tip.excludeWhenModesUsed ?? []) {
+                if (!( this._usedModes.has(mode))) {
+                    this._pendingModes.add(mode);
+                }
+            }
+        }
+        this._pendingTools = ( new Set());
+        for (const tip of tips) {
+            for (const toolId of tip.excludeWhenToolsInvoked ?? []) {
+                if (!( this._invokedTools.has(toolId))) {
+                    this._pendingTools.add(toolId);
+                }
+            }
+        }
+        if (this._pendingCommands.size > 0) {
+            this._commandListener.value = commandService.onDidExecuteCommand(e => {
+                this.recordCommandExecuted(e.commandId);
+            });
+        }
+        if (this._pendingTools.size > 0) {
+            this._toolListener.value = this._languageModelToolsService.onDidInvokeTool(e => {
+                if (( this._pendingTools.has(e.toolId))) {
+                    this._invokedTools.add(e.toolId);
+                    this._pendingTools.delete(e.toolId);
+                    this._persistSet(TipEligibilityStorageKeys.InvokedTools, this._invokedTools);
+                }
+                if (this._pendingTools.size === 0) {
+                    this._toolListener.clear();
+                }
+            });
+        }
+        this._tipsWithFileExclusions = tips.filter(t => t.excludeWhenPromptFilesExist);
+        for (const tip of this._tipsWithFileExclusions) {
+            if (tip.excludeWhenPromptFilesExist.excludeUntilChecked) {
+                this._excludedByFiles.add(tip.id);
+            }
+            this._checkForPromptFiles(tip);
+        }
+        this._register(this._promptsService.onDidChangeCustomAgents(() => {
+            for (const tip of this._tipsWithFileExclusions) {
+                if (tip.excludeWhenPromptFilesExist.promptType === PromptsType.agent) {
+                    this._checkForPromptFiles(tip);
+                }
+            }
+        }));
+    }
+    recordCommandExecuted(commandId) {
+        if (!( this._pendingCommands.has(commandId))) {
+            return;
+        }
+        this._executedCommands.add(commandId);
+        this._persistSet(TipEligibilityStorageKeys.ExecutedCommands, this._executedCommands);
+        this._pendingCommands.delete(commandId);
+        if (this._pendingCommands.size === 0) {
+            this._commandListener.clear();
+        }
+    }
+    recordCurrentMode(contextKeyService) {
+        if (this._pendingModes.size === 0) {
+            return;
+        }
+        let changed = false;
+        const kind = contextKeyService.getContextKeyValue(ChatContextKeys.chatModeKind.key);
+        if (kind && !( this._usedModes.has(kind))) {
+            this._usedModes.add(kind);
+            this._pendingModes.delete(kind);
+            changed = true;
+        }
+        const name = contextKeyService.getContextKeyValue(ChatContextKeys.chatModeName.key);
+        if (name && !( this._usedModes.has(name))) {
+            this._usedModes.add(name);
+            this._pendingModes.delete(name);
+            changed = true;
+        }
+        if (changed) {
+            this._persistSet(TipEligibilityStorageKeys.UsedModes, this._usedModes);
+        }
+    }
+    isExcluded(tip) {
+        if (tip.excludeWhenCommandsExecuted) {
+            for (const cmd of tip.excludeWhenCommandsExecuted) {
+                if (( this._executedCommands.has(cmd))) {
+                    this._logService.debug("#ChatTips: tip excluded because command was executed", tip.id, cmd);
+                    return true;
+                }
+            }
+        }
+        if (tip.excludeWhenModesUsed) {
+            for (const mode of tip.excludeWhenModesUsed) {
+                if (( this._usedModes.has(mode))) {
+                    this._logService.debug("#ChatTips: tip excluded because mode was used", tip.id, mode);
+                    return true;
+                }
+            }
+        }
+        if (tip.excludeWhenToolsInvoked) {
+            for (const toolId of tip.excludeWhenToolsInvoked) {
+                if (( this._invokedTools.has(toolId))) {
+                    this._logService.debug("#ChatTips: tip excluded because tool was invoked", tip.id, toolId);
+                    return true;
+                }
+            }
+        }
+        if (tip.excludeWhenPromptFilesExist && ( this._excludedByFiles.has(tip.id))) {
+            this._logService.debug("#ChatTips: tip excluded because prompt files exist", tip.id);
+            return true;
+        }
+        return false;
+    }
+    refreshPromptFileExclusions() {
+        for (const tip of this._tipsWithFileExclusions) {
+            if (tip.excludeWhenPromptFilesExist.excludeUntilChecked) {
+                this._excludedByFiles.add(tip.id);
+            }
+            this._checkForPromptFiles(tip);
+        }
+    }
+    async _checkForPromptFiles(tip) {
+        const inFlight = this._fileChecksInFlight.get(tip.id);
+        if (inFlight) {
+            await inFlight;
+            return;
+        }
+        const checkPromise = this._doCheckForPromptFiles(tip);
+        this._fileChecksInFlight.set(tip.id, checkPromise);
+        try {
+            await checkPromise;
+        } finally {
+            if (this._fileChecksInFlight.get(tip.id) === checkPromise) {
+                this._fileChecksInFlight.delete(tip.id);
+            }
+        }
+    }
+    async _doCheckForPromptFiles(tip) {
+        const config = tip.excludeWhenPromptFilesExist;
+        const generation = (this._fileCheckGeneration.get(tip.id) ?? 0) + 1;
+        this._fileCheckGeneration.set(tip.id, generation);
+        try {
+            const [promptFiles, agentInstructions] = await Promise.all([
+                this._promptsService.listPromptFiles(config.promptType, CancellationToken.None),
+                config.agentFileType ? this._promptsService.listAgentInstructions(CancellationToken.None) : Promise.resolve([])
+            ]);
+            if (this._fileCheckGeneration.get(tip.id) !== generation) {
+                return;
+            }
+            const hasPromptFiles = promptFiles.length > 0;
+            const hasAgentFile = config.agentFileType ? ( agentInstructions.some(f => f.type === config.agentFileType)) : false;
+            const hasPromptFilesOrAgentFile = hasPromptFiles || hasAgentFile;
+            if (hasPromptFilesOrAgentFile) {
+                this._excludedByFiles.add(tip.id);
+            } else {
+                this._excludedByFiles.delete(tip.id);
+            }
+        } catch {
+            if (this._fileCheckGeneration.get(tip.id) !== generation) {
+                return;
+            }
+            if (config.excludeUntilChecked) {
+                this._excludedByFiles.add(tip.id);
+            }
+        }
+    }
+    _persistSet(key, set) {
+        this._storageService.store(
+            key,
+            JSON.stringify([...set]),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+    _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;
+    }
+};
+TipEligibilityTracker = ( __decorate([( __param(1, ICommandService)), ( __param(2, IStorageService)), ( __param(3, IPromptsService)), ( __param(4, ILanguageModelToolsService)), ( __param(5, ILogService))], TipEligibilityTracker));
+
+export { TipEligibilityTracker };