Add C++ configuration as a language model tool

Extension/package.json

@@ -38,7 +38,8 @@
         "Snippets"
     ],
     "enabledApiProposals": [
-        "terminalDataWriteEvent"
+        "terminalDataWriteEvent",
+        "lmTools"
     ],
     "capabilities": {
         "untrustedWorkspaces": {
@@ -6458,6 +6459,18 @@
                     "description": "%c_cpp.codeActions.refactor.extract.function.description%"
                 }
             }
+        ],
+        "languageModelTools": [
+            {
+                "id": "cpptools-lmtool-configuration",
+                "name": "cpp",
+                "displayName": "%c_cpp.languageModelTools.configuration.displayName%",
+                "canBeInvokedManually": true,
+                "userDescription": "%c_cpp.languageModelTools.configuration.userDescription%",
+                "modelDescription": "For the active C or C++ file, this tool provides: the language (C, C++, or CUDA), the language standard version (such as C++11, C++14, C++17, or C++20), the compiler (such as GCC, Clang, or MSVC), the target platform (such as x86, x64, or ARM), and the target architecture (such as 32-bit or 64-bit).",
+                "icon": "$(file-code)",
+                "parametersSchema": {}
+            }
         ]
     },
     "scripts": {

Extension/package.nls.json

@@ -1013,5 +1013,7 @@
     "c_cpp.configuration.refactoring.includeHeader.markdownDescription": "Controls whether to include the header file of a refactored function/symbol to its corresponding source file when doing a refactoring action, such as create declaration/definition.",
     "c_cpp.configuration.refactoring.includeHeader.always.description": "Always include the header file if it is not included explicitly in its source file.",
     "c_cpp.configuration.refactoring.includeHeader.ifNeeded.description": "Only include the header file if it is not included explicitly in its source file or through implicit inclusion.",
-    "c_cpp.configuration.refactoring.includeHeader.never.description": "Never include the header file."
+    "c_cpp.configuration.refactoring.includeHeader.never.description": "Never include the header file.",
+    "c_cpp.languageModelTools.configuration.displayName": "C/C++ configuration",
+    "c_cpp.languageModelTools.configuration.userDescription": "Configuration of the active C or C++ file, like language standard version and target platform."
 }

Extension/src/LanguageServer/client.ts

@@ -61,7 +61,7 @@ import * as refs from './references';
 import { CppSettings, OtherSettings, SettingsParams, WorkspaceFolderSettingsParams, getEditorConfigSettings } from './settings';
 import { SettingsTracker } from './settingsTracker';
 import { ConfigurationType, LanguageStatusUI, getUI } from './ui';
-import { handleChangedFromCppToC, makeLspRange, makeVscodeLocation, makeVscodeRange } from './utils';
+import { handleChangedFromCppToC, makeLspRange, makeVscodeLocation, makeVscodeRange, withCancellation } from './utils';
 import minimatch = require("minimatch");
 
 function deepCopy(obj: any) {
@@ -541,6 +541,14 @@ interface GetIncludesResult {
     includedFiles: string[];
 }
 
+export interface ChatContextResult {
+    language: string;
+    standardVersion: string;
+    compiler: string;
+    targetPlatform: string;
+    targetArchitecture: string;
+}
+
 // Requests
 const PreInitializationRequest: RequestType<void, string, void> = new RequestType<void, string, void>('cpptools/preinitialize');
 const InitializationRequest: RequestType<CppInitializationParams, void, void> = new RequestType<CppInitializationParams, void, void>('cpptools/initialize');
@@ -560,6 +568,7 @@ const GoToDirectiveInGroupRequest: RequestType<GoToDirectiveInGroupParams, Posit
 const GenerateDoxygenCommentRequest: RequestType<GenerateDoxygenCommentParams, GenerateDoxygenCommentResult | undefined, void> = new RequestType<GenerateDoxygenCommentParams, GenerateDoxygenCommentResult, void>('cpptools/generateDoxygenComment');
 const ChangeCppPropertiesRequest: RequestType<CppPropertiesParams, void, void> = new RequestType<CppPropertiesParams, void, void>('cpptools/didChangeCppProperties');
 const IncludesRequest: RequestType<GetIncludesParams, GetIncludesResult, void> = new RequestType<GetIncludesParams, GetIncludesResult, void>('cpptools/getIncludes');
+const CppContextRequest: RequestType<void, ChatContextResult, void> = new RequestType<void, ChatContextResult, void>('cpptools/getChatContext');
 
 // Notifications to the server
 const DidOpenNotification: NotificationType<DidOpenTextDocumentParams> = new NotificationType<DidOpenTextDocumentParams>('textDocument/didOpen');
@@ -790,6 +799,7 @@ export interface Client {
     setShowConfigureIntelliSenseButton(show: boolean): void;
     addTrustedCompiler(path: string): Promise<void>;
     getIncludes(maxDepth: number): Promise<GetIncludesResult>;
+    getChatContext(token: vscode.CancellationToken): Promise<ChatContextResult | undefined>;
 }
 
 export function createClient(workspaceFolder?: vscode.WorkspaceFolder): Client {
@@ -2204,6 +2214,19 @@ export class DefaultClient implements Client {
         return this.languageClient.sendRequest(IncludesRequest, params);
     }
 
+    public async getChatContext(token: vscode.CancellationToken): Promise<ChatContextResult | undefined> {
+        await withCancellation(this.ready, token);
+        const result = await this.languageClient.sendRequest(CppContextRequest, null, token);
+
+        // sendRequest() won't throw on cancellation, but will return an
+        // unexpected object with an error code and message.
+        if (token.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+
+        return result;
+    }
+
     /**
      * a Promise that can be awaited to know when it's ok to proceed.
      *
@@ -4084,4 +4107,5 @@ class NullClient implements Client {
     setShowConfigureIntelliSenseButton(show: boolean): void { }
     addTrustedCompiler(path: string): Promise<void> { return Promise.resolve(); }
     getIncludes(): Promise<GetIncludesResult> { return Promise.resolve({} as GetIncludesResult); }
+    getChatContext(token: vscode.CancellationToken): Promise<ChatContextResult> { return Promise.resolve({} as ChatContextResult); }
 }

Extension/src/LanguageServer/extension.ts

@@ -26,6 +26,7 @@ import { CodeActionDiagnosticInfo, CodeAnalysisDiagnosticIdentifiersAndUri, code
 import { CppBuildTaskProvider } from './cppBuildTaskProvider';
 import { getCustomConfigProviders } from './customProviders';
 import { getLanguageConfig } from './languageConfig';
+import { CppConfigurationLanguageModelTool } from './lmTool';
 import { PersistentState } from './persistentState';
 import { NodeType, TreeNode } from './referencesModel';
 import { CppSettings } from './settings';
@@ -248,6 +249,11 @@ export async function activate(): Promise<void> {
         clients.timeTelemetryCollector.setFirstFile(activeEditor.document.uri);
         activeDocument = activeEditor.document;
     }
+
+    if (util.extensionContext) {
+        const tool = vscode.lm.registerTool('cpptools-lmtool-configuration', new CppConfigurationLanguageModelTool());
+        disposables.push(tool);
+    }
 }
 
 export function updateLanguageConfigurations(): void {

Extension/src/LanguageServer/lmTool.ts

@@ -0,0 +1,88 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+
+import * as vscode from 'vscode';
+import * as util from '../common';
+import * as telemetry from '../telemetry';
+import { ChatContextResult } from './client';
+import { getClients } from './extension';
+
+const knownValues: { [Property in keyof ChatContextResult]?: { [id: string]: string } } = {
+    language: {
+        'c': 'C',
+        'cpp': 'C++',
+        'cuda-cpp': 'CUDA C++'
+    },
+    compiler: {
+        'msvc': 'MSVC',
+        'clang': 'Clang',
+        'gcc': 'GCC'
+    },
+    standardVersion: {
+        'c++98': 'C++98',
+        'c++03': 'C++03',
+        'c++11': 'C++11',
+        'c++14': 'C++14',
+        'c++17': 'C++17',
+        'c++20': 'C++20',
+        'c++23': 'C++23',
+        'c90': "C90",
+        'c99': "C99",
+        'c11': "C11",
+        'c17': "C17",
+        'c23': "C23"
+    },
+    targetPlatform: {
+        'windows': 'Windows',
+        'Linux': 'Linux',
+        'macos': 'macOS'
+    }
+};
+
+class StringLanguageModelToolResult implements vscode.LanguageModelToolResult
+{
+    public constructor(public readonly value: string) {}
+    public toString(): string { return this.value; }
+}
+
+export class CppConfigurationLanguageModelTool implements vscode.LanguageModelTool
+{
+    public async invoke(_parameters: any, token: vscode.CancellationToken): Promise<vscode.LanguageModelToolResult> {
+        return new StringLanguageModelToolResult(await this.getContext(token));
+    }
+
+    private async getContext(token: vscode.CancellationToken): Promise<string> {
+        const currentDoc = vscode.window.activeTextEditor?.document;
+        if (!currentDoc || (!util.isCpp(currentDoc) && !util.isHeaderFile(currentDoc.uri))) {
+            return 'The active document is not a C, C++, or CUDA file.';
+        }
+
+        const chatContext: ChatContextResult | undefined = await (getClients()?.ActiveClient?.getChatContext(token) ?? undefined);
+        if (!chatContext) {
+            return 'No configuration information is available for the active document.';
+        }
+
+        telemetry.logLanguageModelToolEvent(
+            'cpp',
+            {
+                "language": chatContext.language,
+                "compiler": chatContext.compiler,
+                "standardVersion": chatContext.standardVersion,
+                "targetPlatform": chatContext.targetPlatform,
+                "targetArchitecture": chatContext.targetArchitecture
+            });
+
+        for (const key in knownValues) {
+            const knownKey = key as keyof ChatContextResult;
+            if (knownValues[knownKey] && chatContext[knownKey])
+            {
+                chatContext[knownKey] = knownValues[knownKey][chatContext[knownKey]] || chatContext[knownKey];
+            }
+        }
+
+        return `The user is working on a ${chatContext.language} project. The project uses language version ${chatContext.standardVersion}, compiles using the ${chatContext.compiler} compiler, targets the ${chatContext.targetPlatform} platform, and targets the ${chatContext.targetArchitecture} architecture.`;
+    }
+}