Skip to content

More specific llm tools #25072

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 11 commits into from
May 16, 2025
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
63 changes: 52 additions & 11 deletions package.json
Original file line number Diff line number Diff line change
Expand Up @@ -1465,10 +1465,10 @@
],
"languageModelTools": [
{
"name": "get_python_environment",
"displayName": "Get Python Environment Information",
"userDescription": "%python.languageModelTools.python_environment.userDescription%",
"modelDescription": "Provides details about the Python environment for a specified file or workspace, including environment type, Python version, run command, and installed packages with their versions. Use this tool to determine the correct command for executing Python code in this workspace.",
"name": "get_python_environment_info",
"displayName": "Get Python Environment Info",
"userDescription": "%python.languageModelTools.get_python_environment_info.userDescription%",
"modelDescription": "This tool will retrieve the details of the Python Environment for the specified file or workspace. The details returned include the 1. Type of Environment (conda, venv, etec), 2. Version of Python, 3. List of all installed packages with their versions. ",
"toolReferenceName": "pythonGetEnvironmentInfo",
"tags": [
"ms-python.python"
Expand All @@ -1483,11 +1483,53 @@
}
},
"description": "The path to the Python file or workspace to get the environment information for.",
"required": [
"resourcePath"
]
"required": []
}
},
{
"name": "get_python_executable",
"displayName": "Get Python Executable",
"userDescription": "%python.languageModelTools.get_python_executable.userDescription%",
"modelDescription": "This tool will retrieve the details of the Python Environment for the specified file or workspace. ALWAYS use this tool before executing any Python command in the terminal. This tool returns the details of how to construct the fully qualified path and or command including details such as arguments required to run Python in a terminal. Note: Instead of executing `python --version` or `python -c 'import sys; print(sys.executable)'`, use this tool to get the Python executable path to replace the `python` command. E.g. instead of using `python -c 'import sys; print(sys.executable)'`, use this tool to build the command `conda run -n <env_name> -c 'import sys; print(sys.executable)'`.",
"toolReferenceName": "pythonExecutableCommand",
"tags": [
"ms-python.python"
],
"icon": "$(files)",
"canBeReferencedInPrompt": true,
"inputSchema": {
"type": "object",
"properties": {
"resourcePath": {
"type": "string"
}
},
"description": "The path to the Python file or workspace to get the executable information for. If not provided, the current workspace will be used. Where possible pass the path to the file or workspace.",
"required": []
}
},
{
"name": "list_python_packages",
"displayName": "List Python Packages",
"userDescription": "%python.languageModelTools.list_python_packages.userDescription%",
"modelDescription": "This tool will retrieve the list of all installed packages installed in a Python Environment for the specified file or workspace. ALWAYS use this tool instead of executing Python command in the terminal to fetch the list of installed packages. WARNING: Packages installed can change over time, hence the list of packages returned by this tool may not be accurate. Use this tool to get the list of installed packages in a Python environment.",
"toolReferenceName": "listPythonPackages",
"tags": [
"ms-python.python"
],
"icon": "$(files)",
"canBeReferencedInPrompt": true,
"inputSchema": {
"type": "object",
"properties": {
"resourcePath": {
"type": "string"
}
},
"description": "The path to the Python file or workspace to list the packages. If not provided, the current workspace will be used. Where possible pass the path to the file or workspace.",
"required": []
},
"when": "!pythonEnvExtensionInstalled"
Copy link
Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Will disable listPythonPackages for now

"when": "false"
},
{
"name": "install_python_package",
Expand All @@ -1512,12 +1554,11 @@
},
"resourcePath": {
"type": "string",
"description": "The path to the Python file or workspace to get the environment information for."
"description": "The path to the Python file or workspace into which the packages are installed. If not provided, the current workspace will be used. Where possible pass the path to the file or workspace."
}
},
"required": [
"packageList",
"resourcePath"
"packageList"
]
},
"when": "!pythonEnvExtensionInstalled"
Expand Down
6 changes: 4 additions & 2 deletions package.nls.json
Original file line number Diff line number Diff line change
@@ -1,7 +1,9 @@
{
"python.command.python.startTerminalREPL.title": "Start Terminal REPL",
"python.languageModelTools.python_environment.userDescription": "Get Python environment info for a file or path, including version, packages, and the command to run it.",
"python.languageModelTools.python_install_package.userDescription": "Installs Python packages in the given workspace.",
"python.languageModelTools.get_python_environment_info.userDescription": "Get information for a Python Environment, such as Type, Version, Packages, and more.",
"python.languageModelTools.python_install_package.userDescription": "Installs Python packages in a Python Environment.",
"python.languageModelTools.get_python_executable.userDescription": "Get executable info for a Python Environment",
"python.languageModelTools.list_python_packages.userDescription": "Get a list of all installed packages in a Python Environment.",
"python.command.python.startNativeREPL.title": "Start Native Python REPL",
"python.command.python.createEnvironment.title": "Create Environment...",
"python.command.python.createNewFile.title": "New Python File",
Expand Down
82 changes: 82 additions & 0 deletions src/client/chat/getExecutableTool.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,82 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

import {
CancellationError,
CancellationToken,
l10n,
LanguageModelTextPart,
LanguageModelTool,
LanguageModelToolInvocationOptions,
LanguageModelToolInvocationPrepareOptions,
LanguageModelToolResult,
PreparedToolInvocation,
} from 'vscode';
import { PythonExtension } from '../api/types';
import { IServiceContainer } from '../ioc/types';
import { ICodeExecutionService } from '../terminals/types';
import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
import { getEnvDisplayName, getEnvironmentDetails, raceCancellationError } from './utils';
import { resolveFilePath } from './utils';
import { traceError } from '../logging';
import { ITerminalHelper } from '../common/terminal/types';
import { IDiscoveryAPI } from '../pythonEnvironments/base/locator';

export interface IResourceReference {
resourcePath?: string;
}

export class GetExecutableTool implements LanguageModelTool<IResourceReference> {
private readonly terminalExecutionService: TerminalCodeExecutionProvider;
private readonly terminalHelper: ITerminalHelper;
public static readonly toolName = 'get_python_executable';
constructor(
private readonly api: PythonExtension['environments'],
private readonly serviceContainer: IServiceContainer,
private readonly discovery: IDiscoveryAPI,
) {
this.terminalExecutionService = this.serviceContainer.get<TerminalCodeExecutionProvider>(
ICodeExecutionService,
'standard',
);
this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
}
async invoke(
options: LanguageModelToolInvocationOptions<IResourceReference>,
token: CancellationToken,
): Promise<LanguageModelToolResult> {
const resourcePath = resolveFilePath(options.input.resourcePath);

try {
const message = await getEnvironmentDetails(
resourcePath,
this.api,
this.terminalExecutionService,
this.terminalHelper,
undefined,
token,
);
return new LanguageModelToolResult([new LanguageModelTextPart(message)]);
} catch (error) {
if (error instanceof CancellationError) {
throw error;
}
traceError('Error while getting environment information', error);
const errorMessage: string = `An error occurred while fetching environment information: ${error}`;
return new LanguageModelToolResult([new LanguageModelTextPart(errorMessage)]);
}
}

async prepareInvocation?(
options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
token: CancellationToken,
): Promise<PreparedToolInvocation> {
const resourcePath = resolveFilePath(options.input.resourcePath);
const envName = await raceCancellationError(getEnvDisplayName(this.discovery, resourcePath, this.api), token);
return {
invocationMessage: envName
? l10n.t('Fetching Python executable information for {0}', envName)
: l10n.t('Fetching Python executable information'),
};
}
}
148 changes: 25 additions & 123 deletions src/client/chat/getPythonEnvTool.ts
Original file line number Diff line number Diff line change
Expand Up @@ -11,38 +11,27 @@ import {
LanguageModelToolInvocationPrepareOptions,
LanguageModelToolResult,
PreparedToolInvocation,
Uri,
} from 'vscode';
import { PythonExtension, ResolvedEnvironment } from '../api/types';
import { PythonExtension } from '../api/types';
import { IServiceContainer } from '../ioc/types';
import { ICodeExecutionService } from '../terminals/types';
import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
import { IProcessService, IProcessServiceFactory, IPythonExecutionFactory } from '../common/process/types';
import { raceCancellationError } from './utils';
import { IProcessServiceFactory, IPythonExecutionFactory } from '../common/process/types';
import { getEnvironmentDetails, raceCancellationError } from './utils';
import { resolveFilePath } from './utils';
import { parsePipList } from './pipListUtils';
import { Conda } from '../pythonEnvironments/common/environmentManagers/conda';
import { traceError } from '../logging';
import { getPythonPackagesResponse } from './listPackagesTool';
import { ITerminalHelper } from '../common/terminal/types';

export interface IResourceReference {
resourcePath: string;
resourcePath?: string;
}

interface EnvironmentInfo {
type: string; // e.g. conda, venv, virtualenv, sys
version: string;
runCommand: string;
packages: string[] | string; //include versions too
}

/**
* A tool to get the information about the Python environment.
*/
export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceReference> {
private readonly terminalExecutionService: TerminalCodeExecutionProvider;
private readonly pythonExecFactory: IPythonExecutionFactory;
private readonly processServiceFactory: IProcessServiceFactory;
public static readonly toolName = 'get_python_environment';
private readonly terminalHelper: ITerminalHelper;
public static readonly toolName = 'get_python_environment_info';
constructor(
private readonly api: PythonExtension['environments'],
private readonly serviceContainer: IServiceContainer,
Expand All @@ -53,6 +42,7 @@ export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceRefere
);
this.pythonExecFactory = this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
this.processServiceFactory = this.serviceContainer.get<IProcessServiceFactory>(IProcessServiceFactory);
this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
}
/**
* Invokes the tool to get the information about the Python environment.
Expand All @@ -66,53 +56,37 @@ export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceRefere
): Promise<LanguageModelToolResult> {
const resourcePath = resolveFilePath(options.input.resourcePath);

// environment info set to default values
const envInfo: EnvironmentInfo = {
type: 'no type found',
version: 'no version found',
packages: 'no packages found',
runCommand: 'no run command found',
};

try {
// environment
const envPath = this.api.getActiveEnvironmentPath(resourcePath);
const environment = await raceCancellationError(this.api.resolveEnvironment(envPath), token);
if (!environment || !environment.version) {
throw new Error('No environment found for the provided resource path: ' + resourcePath.fsPath);
throw new Error('No environment found for the provided resource path: ' + resourcePath?.fsPath);
}
const cmd = await raceCancellationError(
this.terminalExecutionService.getExecutableInfo(resourcePath),
const packages = await getPythonPackagesResponse(
environment,
this.pythonExecFactory,
this.processServiceFactory,
resourcePath,
token,
);
const executable = cmd.pythonExecutable;
envInfo.runCommand = cmd.args.length > 0 ? `${cmd.command} ${cmd.args.join(' ')}` : executable;
envInfo.version = environment.version.sysVersion;

const isConda = (environment.environment?.type || '').toLowerCase() === 'conda';
envInfo.packages = isConda
? await raceCancellationError(
listCondaPackages(
this.pythonExecFactory,
environment,
resourcePath,
await raceCancellationError(this.processServiceFactory.create(resourcePath), token),
),
token,
)
: await raceCancellationError(listPipPackages(this.pythonExecFactory, resourcePath), token);
const message = await getEnvironmentDetails(
resourcePath,
this.api,
this.terminalExecutionService,
this.terminalHelper,
packages,
token,
);

// format and return
return new LanguageModelToolResult([BuildEnvironmentInfoContent(envInfo)]);
return new LanguageModelToolResult([new LanguageModelTextPart(message)]);
} catch (error) {
if (error instanceof CancellationError) {
throw error;
}
const errorMessage: string = `An error occurred while fetching environment information: ${error}`;
const partialContent = BuildEnvironmentInfoContent(envInfo);
return new LanguageModelToolResult([
new LanguageModelTextPart(`${errorMessage}\n\n${partialContent.value}`),
]);
return new LanguageModelToolResult([new LanguageModelTextPart(errorMessage)]);
}
}

Expand All @@ -125,75 +99,3 @@ export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceRefere
};
}
}

function BuildEnvironmentInfoContent(envInfo: EnvironmentInfo): LanguageModelTextPart {
// Create a formatted string that looks like JSON but preserves comments
let envTypeDescriptor: string = `This environment is managed by ${envInfo.type} environment manager. Use the install tool to install packages into this environment.`;

// TODO: If this is setup as python.defaultInterpreterPath, then do not include this message.
if (envInfo.type === 'system') {
envTypeDescriptor =
'System pythons are pythons that ship with the OS or are installed globally. These python installs may be used by the OS for running services and core functionality. Confirm with the user before installing packages into this environment, as it can lead to issues with any services on the OS.';
}
const content = `{
// ${JSON.stringify(envTypeDescriptor)}
"environmentType": ${JSON.stringify(envInfo.type)},
// Python version of the environment
"pythonVersion": ${JSON.stringify(envInfo.version)},
// Use this command to run Python script or code in the terminal.
"runCommand": ${JSON.stringify(envInfo.runCommand)},
// Installed Python packages, each in the format <name> or <name> (<version>). The version may be omitted if unknown. Returns an empty array if no packages are installed.
"packages": ${JSON.stringify(Array.isArray(envInfo.packages) ? envInfo.packages : envInfo.packages, null, 2)}
}`;

return new LanguageModelTextPart(content);
}

async function listPipPackages(execFactory: IPythonExecutionFactory, resource: Uri) {
// Add option --format to subcommand list of pip cache, with abspath choice to output the full path of a wheel file. (#8355)
// Added in 202. Thats almost 5 years ago. When Python 3.8 was released.
const exec = await execFactory.createActivatedEnvironment({ allowEnvironmentFetchExceptions: true, resource });
const output = await exec.execModule('pip', ['list'], { throwOnStdErr: false, encoding: 'utf8' });
return parsePipList(output.stdout).map((pkg) => (pkg.version ? `${pkg.name} (${pkg.version})` : pkg.name));
}

async function listCondaPackages(
execFactory: IPythonExecutionFactory,
env: ResolvedEnvironment,
resource: Uri,
processService: IProcessService,
) {
const conda = await Conda.getConda();
if (!conda) {
traceError('Conda is not installed, falling back to pip packages');
return listPipPackages(execFactory, resource);
}
if (!env.executable.uri) {
traceError('Conda environment executable not found, falling back to pip packages');
return listPipPackages(execFactory, resource);
}
const condaEnv = await conda.getCondaEnvironment(env.executable.uri.fsPath);
if (!condaEnv) {
traceError('Conda environment not found, falling back to pip packages');
return listPipPackages(execFactory, resource);
}
const cmd = await conda.getListPythonPackagesArgs(condaEnv, true);
if (!cmd) {
traceError('Conda list command not found, falling back to pip packages');
return listPipPackages(execFactory, resource);
}
const output = await processService.exec(cmd[0], cmd.slice(1), { shell: true });
if (!output.stdout) {
traceError('Unable to get conda packages, falling back to pip packages');
return listPipPackages(execFactory, resource);
}
const content = output.stdout.split(/\r?\n/).filter((l) => !l.startsWith('#'));
const packages: string[] = [];
content.forEach((l) => {
const parts = l.split(' ').filter((p) => p.length > 0);
if (parts.length === 3) {
packages.push(`${parts[0]} (${parts[1]})`);
}
});
return packages;
}
Loading