Merge branch 'microsoft:main' into tgrue-openai/support-activated-env-w-workspacefile

Author: tgrue-openai

build/azure-pipeline.stable.yml

@@ -128,7 +128,7 @@ extends:
             project: 'Monaco'
             definition: 593
             buildVersionToDownload: 'latestFromBranch'
-            branchName: 'refs/heads/release/2025.4'
+            branchName: 'refs/heads/release/2025.8'
             targetPath: '$(Build.SourcesDirectory)/python-env-tools/bin'
             artifactName: 'bin-$(buildTarget)'
             itemPattern: |

package-lock.json

@@ -2,7 +2,7 @@
     "name": "python",
     "displayName": "Python",
     "description": "Python language support with extension access points for IntelliSense (Pylance), Debugging (Python Debugger), linting, formatting, refactoring, unit tests, and more.",
-    "version": "2025.7.0-dev",
+    "version": "2025.9.0-dev",
     "featureFlags": {
         "usingNewInterpreterStorage": true
     },
@@ -1474,9 +1474,10 @@
                 "displayName": "Get Python Environment Info",
                 "userDescription": "%python.languageModelTools.get_python_environment_details.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. ALWAYS call configure_python_environment before using this tool.",
-                "toolReferenceName": "pythonGetEnvironmentInfo",
+                "toolReferenceName": "getPythonEnvironmentInfo",
                 "tags": [
                     "python",
+                    "python environment",
                     "extension_installed_by_tool",
                     "enable_other_tool_configure_python_environment"
                 ],
@@ -1491,17 +1492,17 @@
                         }
                     },
                     "required": []
-                },
-                "when": "!pythonEnvExtensionInstalled"
+                }
             },
             {
                 "name": "get_python_executable_details",
                 "displayName": "Get Python Executable",
                 "userDescription": "%python.languageModelTools.get_python_executable_details.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)'`. ALWAYS call configure_python_environment before using this tool.",
-                "toolReferenceName": "pythonExecutableCommand",
+                "toolReferenceName": "getPythonExecutableCommand",
                 "tags": [
                     "python",
+                    "python environment",
                     "extension_installed_by_tool",
                     "enable_other_tool_configure_python_environment"
                 ],
@@ -1516,17 +1517,17 @@
                         }
                     },
                     "required": []
-                },
-                "when": "!pythonEnvExtensionInstalled"
+                }
             },
             {
                 "name": "install_python_packages",
                 "displayName": "Install Python Package",
                 "userDescription": "%python.languageModelTools.install_python_packages.userDescription%",
                 "modelDescription": "Installs Python packages in the given workspace. Use this tool to install packages in the user's chosen environment. ALWAYS call configure_python_environment before using this tool.",
-                "toolReferenceName": "pythonInstallPackage",
+                "toolReferenceName": "installPythonPackage",
                 "tags": [
                     "python",
+                    "python environment",
                     "install python package",
                     "extension_installed_by_tool",
                     "enable_other_tool_configure_python_environment"
@@ -1551,8 +1552,7 @@
                     "required": [
                         "packageList"
                     ]
-                },
-                "when": "!pythonEnvExtensionInstalled"
+                }
             },
             {
                 "name": "configure_python_environment",
@@ -1562,6 +1562,7 @@
                 "toolReferenceName": "configurePythonEnvironment",
                 "tags": [
                     "python",
+                    "python environment",
                     "extension_installed_by_tool"
                 ],
                 "icon": "$(gear)",
@@ -1575,8 +1576,7 @@
                         }
                     },
                     "required": []
-                },
-                "when": "!pythonEnvExtensionInstalled"
+                }
             },
             {
                 "name": "create_virtual_environment",

package.json

@@ -19,6 +19,7 @@ import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/termin
 import {
     getEnvDetailsForResponse,
     getToolResponseIfNotebook,
+    getUntrustedWorkspaceResponse,
     IResourceReference,
     isCancellationError,
     raceCancellationError,
@@ -28,7 +29,6 @@ import { ITerminalHelper } from '../common/terminal/types';
 import { IRecommendedEnvironmentService } from '../interpreter/configuration/types';
 import { CreateVirtualEnvTool } from './createVirtualEnvTool';
 import { ISelectPythonEnvToolArguments, SelectPythonEnvTool } from './selectEnvTool';
-import { useEnvExtension } from '../envExt/api.internal';
 
 export class ConfigurePythonEnvTool implements LanguageModelTool<IResourceReference> {
     private readonly terminalExecutionService: TerminalCodeExecutionProvider;
@@ -54,6 +54,9 @@ export class ConfigurePythonEnvTool implements LanguageModelTool<IResourceRefere
         options: LanguageModelToolInvocationOptions<IResourceReference>,
         token: CancellationToken,
     ): Promise<LanguageModelToolResult> {
+        if (!workspace.isTrusted) {
+            return getUntrustedWorkspaceResponse();
+        }
         const resource = resolveFilePath(options.input.resourcePath);
         const notebookResponse = getToolResponseIfNotebook(resource);
         if (notebookResponse) {
@@ -78,10 +81,7 @@ export class ConfigurePythonEnvTool implements LanguageModelTool<IResourceRefere
 
         if (await this.createEnvTool.shouldCreateNewVirtualEnv(resource, token)) {
             try {
-                // If the Python Env extension is available, then use that.
-                // create_quick_virtual_environment
-                const toolName = useEnvExtension() ? 'create_quick_virtual_environment' : CreateVirtualEnvTool.toolName;
-                return await lm.invokeTool(toolName, options, token);
+                return await lm.invokeTool(CreateVirtualEnvTool.toolName, options, token);
             } catch (ex) {
                 if (isCancellationError(ex)) {
                     const input: ISelectPythonEnvToolArguments = {

src/client/chat/configurePythonEnvTool.ts

@@ -4,6 +4,7 @@
 import {
     CancellationError,
     CancellationToken,
+    commands,
     l10n,
     LanguageModelTool,
     LanguageModelToolInvocationOptions,
@@ -21,6 +22,7 @@ import {
     doesWorkspaceHaveVenvOrCondaEnv,
     getDisplayVersion,
     getEnvDetailsForResponse,
+    getUntrustedWorkspaceResponse,
     IResourceReference,
     isCancellationError,
     raceCancellationError,
@@ -39,6 +41,9 @@ import { isStableVersion } from '../pythonEnvironments/info/pythonVersion';
 import { createVirtualEnvironment } from '../pythonEnvironments/creation/createEnvApi';
 import { traceError, traceVerbose, traceWarn } from '../logging';
 import { StopWatch } from '../common/utils/stopWatch';
+import { useEnvExtension } from '../envExt/api.internal';
+import { PythonEnvironment } from '../envExt/types';
+import { hideEnvCreation } from '../pythonEnvironments/creation/provider/hideEnvCreation';
 
 interface ICreateVirtualEnvToolParams extends IResourceReference {
     packageList?: string[]; // Added only becausewe have ability to create a virtual env with list of packages same tool within the in Python Env extension.
@@ -66,9 +71,12 @@ export class CreateVirtualEnvTool implements LanguageModelTool<ICreateVirtualEnv
     }
 
     async invoke(
-        options: LanguageModelToolInvocationOptions<IResourceReference>,
+        options: LanguageModelToolInvocationOptions<ICreateVirtualEnvToolParams>,
         token: CancellationToken,
     ): Promise<LanguageModelToolResult> {
+        if (!workspace.isTrusted) {
+            return getUntrustedWorkspaceResponse();
+        }
         const resource = resolveFilePath(options.input.resourcePath);
         let info = await this.getPreferredEnvForCreation(resource);
         if (!info) {
@@ -79,18 +87,31 @@ export class CreateVirtualEnvTool implements LanguageModelTool<ICreateVirtualEnv
         const interpreterPathService = this.serviceContainer.get<IInterpreterPathService>(IInterpreterPathService);
         const disposables = new DisposableStore();
         try {
+            disposables.add(hideEnvCreation());
             const interpreterChanged = new Promise<void>((resolve) => {
                 disposables.add(interpreterPathService.onDidChange(() => resolve()));
             });
 
-            const created = await raceCancellationError(
-                createVirtualEnvironment({
-                    interpreter: preferredGlobalPythonEnv.id,
-                    workspaceFolder,
-                }),
-                token,
-            );
-            if (!created?.path) {
+            let createdEnvPath: string | undefined = undefined;
+            if (useEnvExtension()) {
+                const result: PythonEnvironment | undefined = await commands.executeCommand('python-envs.createAny', {
+                    quickCreate: true,
+                    additionalPackages: options.input.packageList || [],
+                    uri: workspaceFolder.uri,
+                    selectEnvironment: true,
+                });
+                createdEnvPath = result?.environmentPath.fsPath;
+            } else {
+                const created = await raceCancellationError(
+                    createVirtualEnvironment({
+                        interpreter: preferredGlobalPythonEnv.id,
+                        workspaceFolder,
+                    }),
+                    token,
+                );
+                createdEnvPath = created?.path;
+            }
+            if (!createdEnvPath) {
                 traceWarn(`${CreateVirtualEnvTool.toolName} tool not invoked, virtual env not created.`);
                 throw new CancellationError();
             }
@@ -102,7 +123,7 @@ export class CreateVirtualEnvTool implements LanguageModelTool<ICreateVirtualEnv
             const stopWatch = new StopWatch();
             let env: ResolvedEnvironment | undefined;
             while (stopWatch.elapsedTime < 5_000 || !env) {
-                env = await this.api.resolveEnvironment(created.path);
+                env = await this.api.resolveEnvironment(createdEnvPath);
                 if (env) {
                     break;
                 } else {
@@ -150,7 +171,7 @@ export class CreateVirtualEnvTool implements LanguageModelTool<ICreateVirtualEnv
     }
 
     async prepareInvocation?(
-        options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
+        options: LanguageModelToolInvocationPrepareOptions<ICreateVirtualEnvToolParams>,
         token: CancellationToken,
     ): Promise<PreparedToolInvocation> {
         const resource = resolveFilePath(options.input.resourcePath);

src/client/chat/createVirtualEnvTool.ts

@@ -10,6 +10,7 @@ import {
     LanguageModelToolInvocationPrepareOptions,
     LanguageModelToolResult,
     PreparedToolInvocation,
+    workspace,
 } from 'vscode';
 import { PythonExtension } from '../api/types';
 import { IServiceContainer } from '../ioc/types';
@@ -19,6 +20,7 @@ import {
     getEnvDisplayName,
     getEnvironmentDetails,
     getToolResponseIfNotebook,
+    getUntrustedWorkspaceResponse,
     IResourceReference,
     raceCancellationError,
 } from './utils';
@@ -45,6 +47,10 @@ export class GetExecutableTool implements LanguageModelTool<IResourceReference>
         options: LanguageModelToolInvocationOptions<IResourceReference>,
         token: CancellationToken,
     ): Promise<LanguageModelToolResult> {
+        if (!workspace.isTrusted) {
+            return getUntrustedWorkspaceResponse();
+        }
+
         const resourcePath = resolveFilePath(options.input.resourcePath);
         const notebookResponse = getToolResponseIfNotebook(resourcePath);
         if (notebookResponse) {

src/client/chat/getExecutableTool.ts

@@ -10,16 +10,24 @@ import {
     LanguageModelToolInvocationPrepareOptions,
     LanguageModelToolResult,
     PreparedToolInvocation,
+    workspace,
 } from 'vscode';
 import { PythonExtension } from '../api/types';
 import { IServiceContainer } from '../ioc/types';
 import { ICodeExecutionService } from '../terminals/types';
 import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
 import { IProcessServiceFactory, IPythonExecutionFactory } from '../common/process/types';
-import { getEnvironmentDetails, getToolResponseIfNotebook, IResourceReference, raceCancellationError } from './utils';
+import {
+    getEnvironmentDetails,
+    getToolResponseIfNotebook,
+    getUntrustedWorkspaceResponse,
+    IResourceReference,
+    raceCancellationError,
+} from './utils';
 import { resolveFilePath } from './utils';
 import { getPythonPackagesResponse } from './listPackagesTool';
 import { ITerminalHelper } from '../common/terminal/types';
+import { getEnvExtApi, useEnvExtension } from '../envExt/api.internal';
 
 export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceReference> {
     private readonly terminalExecutionService: TerminalCodeExecutionProvider;
@@ -44,6 +52,10 @@ export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceRefere
         options: LanguageModelToolInvocationOptions<IResourceReference>,
         token: CancellationToken,
     ): Promise<LanguageModelToolResult> {
+        if (!workspace.isTrusted) {
+            return getUntrustedWorkspaceResponse();
+        }
+
         const resourcePath = resolveFilePath(options.input.resourcePath);
         const notebookResponse = getToolResponseIfNotebook(resourcePath);
         if (notebookResponse) {
@@ -56,14 +68,33 @@ export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceRefere
         if (!environment || !environment.version) {
             throw new Error('No environment found for the provided resource path: ' + resourcePath?.fsPath);
         }
-        const packages = await getPythonPackagesResponse(
-            environment,
-            this.pythonExecFactory,
-            this.processServiceFactory,
-            resourcePath,
-            token,
-        );
 
+        let packages = '';
+        if (useEnvExtension()) {
+            const api = await getEnvExtApi();
+            const env = await api.getEnvironment(resourcePath);
+            const pkgs = env ? await api.getPackages(env) : [];
+            if (pkgs && pkgs.length > 0) {
+                // 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.
+                const response = [
+                    'Below is a list of the Python packages, each in the format <name> or <name> (<version>). The version may be omitted if unknown: ',
+                ];
+                pkgs.forEach((pkg) => {
+                    const version = pkg.version;
+                    response.push(version ? `- ${pkg.name} (${version})` : `- ${pkg.name}`);
+                });
+                packages = response.join('\n');
+            }
+        }
+        if (!packages) {
+            packages = await getPythonPackagesResponse(
+                environment,
+                this.pythonExecFactory,
+                this.processServiceFactory,
+                resourcePath,
+                token,
+            );
+        }
         const message = await getEnvironmentDetails(
             resourcePath,
             this.api,