CopilotHoverProvider.ts

/* --------------------------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All Rights Reserved.
 * See 'LICENSE' in the project root for license information.
 * ------------------------------------------------------------------------------------------ */
import * as vscode from 'vscode';
import { Position, ResponseError } from 'vscode-languageclient';
import * as nls from 'vscode-nls';
import { getVSCodeLanguageModel } from '../../common';
import { modelSelector } from '../../constants';
import * as telemetry from '../../telemetry';
import { DefaultClient, GetCopilotHoverInfoParams, GetCopilotHoverInfoRequest, GetCopilotHoverInfoResult } from '../client';
import { RequestCancelled, ServerCancelled } from '../protocolFilter';
import { CppSettings } from '../settings';

nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
const localize: nls.LocalizeFunc = nls.loadMessageBundle();

export class CopilotHoverProvider implements vscode.HoverProvider {
    private client: DefaultClient;
    private currentDocument: vscode.TextDocument | undefined;
    private currentPosition: vscode.Position | undefined;
    private currentCancellationToken: vscode.CancellationToken | undefined;
    private waiting: boolean = false;
    private ready: boolean = false;
    private cancelled: boolean = false;
    private cancelledDocument: vscode.TextDocument | undefined;
    private cancelledPosition: vscode.Position | undefined;
    private content: string | undefined;
    private chatModel: vscode.LanguageModelChat | undefined;
    private chatModelId: string | undefined; // Save the selected model ID to avoid trying the same unavailable model repeatedly.
    // Flag to avoid querying the LanguageModelChat repeatedly if no model is found
    private checkedChatModel: boolean = false;
    constructor(client: DefaultClient) {
        this.client = client;
    }

    public async getCachedChatModel(): Promise<vscode.LanguageModelChat | undefined> {
        if (this.checkedChatModel) {
            return this.chatModel;
        }

        const vscodelm = getVSCodeLanguageModel();
        if (vscodelm) {
            try {
                let model: vscode.LanguageModelChat | undefined;
                if (this.chatModelId === undefined) {
                    // First look for GPT-4o which should be available to all
                    // users and have a 0x multiplier on paid plans.
                    // GPT-4o is faster than the x0 GPT-5-mini (which seems too slow for hover, e.g. 10+ seconds).
                    this.chatModelId = 'gpt-4o';
                    [model] = await vscodelm.selectChatModels({ ...modelSelector, id: this.chatModelId });
                    if (!model) {
                        // If GPT-4o is not available, fallback to GPT-5.4-mini (x0.33 and fast).
                        this.chatModelId = 'gpt-5.4-mini';
                        [model] = await vscodelm.selectChatModels({ ...modelSelector, id: this.chatModelId });
                    }
                    if (!model) {
                        // If GPT-5.4-mini is not available, fallback to the first available model.
                        this.chatModelId = 'default';
                        [model] = await vscodelm.selectChatModels(modelSelector);
                    }
                } else {
                    if (this.chatModelId === 'default') {
                        [model] = await vscodelm.selectChatModels(modelSelector);
                    } else {
                        [model] = await vscodelm.selectChatModels({ ...modelSelector, id: this.chatModelId });
                    }
                }
                if (!model) {
                    telemetry.logLanguageServerEvent('CopilotHoverNoModelSelected', { remoteName: vscode.env.remoteName || 'local' });
                } else {
                    this.chatModel = model;
                }
            } catch (e: any) {
                const exceptionType = e?.name || e?.constructor?.name || typeof e;
                telemetry.logLanguageServerEvent('CopilotHoverSelectModelFailed', {
                    remoteName: vscode.env.remoteName || 'local',
                    exceptionType: String(exceptionType)
                });
            }
        }
        this.checkedChatModel = true;
        return this.chatModel;
    }

    public async refreshCachedChatModel(): Promise<vscode.LanguageModelChat | undefined> {
        this.chatModel = undefined;
        this.checkedChatModel = false;
        return this.getCachedChatModel();
    }

    public async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Hover | undefined> {
        await this.client.ready;

        const settings: CppSettings = new CppSettings(vscode.workspace.getWorkspaceFolder(document.uri)?.uri);
        const workspaceSettings: CppSettings = new CppSettings();
        if (settings.hover === "disabled" ||
            workspaceSettings.copilotHover === "disabled" ||
            (workspaceSettings.copilotHover === "default" && await telemetry.isFlightEnabled("CppCopilotHoverDisabled"))) {
            // Either disabled by the user or by the flight.
            return undefined;
        }

        // Ensure the user has access to Copilot.
        const model = await this.getCachedChatModel();
        if (!model) {
            return undefined;
        }

        const newHover = this.isNewHover(document, position);
        if (newHover) {
            this.reset();
        }

        // Wait for the main hover provider to finish and confirm it has content.
        const hoverProvider = this.client.getHoverProvider();
        if (!await hoverProvider?.contentReady) {
            return undefined;
        }

        if (token.isCancellationRequested) {
            throw new vscode.CancellationError();
        }
        this.currentCancellationToken = token;

        if (!newHover) {
            if (this.ready) {
                const contentMarkdown = new vscode.MarkdownString(`$(sparkle) Copilot\n\n${this.content}`, true);
                return new vscode.Hover(contentMarkdown);
            }
            if (this.waiting) {
                const loadingMarkdown = new vscode.MarkdownString("$(sparkle) $(loading~spin)", true);
                return new vscode.Hover(loadingMarkdown);
            }
        }

        this.currentDocument = document;
        this.currentPosition = position;
        const commandString = "$(sparkle) [" + localize("generate.copilot.description", "Generate Copilot summary") + "](command:C_Cpp.ShowCopilotHover \"" + localize("copilot.disclaimer", "AI-generated content may be incorrect.") + "\")";
        const commandMarkdown = new vscode.MarkdownString(commandString);
        commandMarkdown.supportThemeIcons = true;
        commandMarkdown.isTrusted = { enabledCommands: ["C_Cpp.ShowCopilotHover"] };
        return new vscode.Hover(commandMarkdown);
    }

    public showWaiting(): void {
        this.waiting = true;
    }

    public showContent(content: string): void {
        this.ready = true;
        this.content = content;
    }

    public getCurrentHoverDocument(): vscode.TextDocument | undefined {
        return this.currentDocument;
    }

    public getCurrentHoverPosition(): vscode.Position | undefined {
        return this.currentPosition;
    }

    public getCurrentHoverCancellationToken(): vscode.CancellationToken | undefined {
        return this.currentCancellationToken;
    }

    public async getRequestInfo(document: vscode.TextDocument, position: vscode.Position): Promise<GetCopilotHoverInfoResult> {
        let response: GetCopilotHoverInfoResult;
        const params: GetCopilotHoverInfoParams = {
            textDocument: { uri: document.uri.toString() },
            position: Position.create(position.line, position.character)
        };

        await this.client.ready;
        if (this.currentCancellationToken?.isCancellationRequested) {
            throw new vscode.CancellationError();
        }

        try {
            response = await this.client.languageClient.sendRequest(GetCopilotHoverInfoRequest, params, this.currentCancellationToken);
        } catch (e: any) {
            if (e instanceof ResponseError && (e.code === RequestCancelled || e.code === ServerCancelled)) {
                throw new vscode.CancellationError();
            }
            throw e;
        }

        return response;
    }

    public isCancelled(document: vscode.TextDocument, position: vscode.Position): boolean {
        if (this.cancelled && this.cancelledDocument === document && this.cancelledPosition === position) {
            // Cancellation is being acknowledged.
            this.cancelled = false;
            this.cancelledDocument = undefined;
            this.cancelledPosition = undefined;
            return true;
        }
        return false;
    }

    public reset(): void {
        // If there was a previous call, cancel it.
        if (this.waiting) {
            this.cancelled = true;
            this.cancelledDocument = this.currentDocument;
            this.cancelledPosition = this.currentPosition;
        }
        this.waiting = false;
        this.ready = false;
        this.content = undefined;
        this.currentDocument = undefined;
        this.currentPosition = undefined;
        this.currentCancellationToken = undefined;
    }

    public isNewHover(document: vscode.TextDocument, position: vscode.Position): boolean {
        return !(this.currentDocument === document && this.currentPosition?.line === position.line && (this.currentPosition?.character === position.character || this.currentPosition?.character === position.character - 1));
    }
}