Enhance Python environment configuration tools with optional interpreter path support for direct setup

Co-authored-by: Copilot <copilot@github.com>

Author: eleanorjboyd

package.json

@@ -1593,7 +1593,7 @@
             {
                 "name": "configure_python_environment",
                 "displayName": "Configure Python Environment",
-                "modelDescription": "This tool configures a Python environment in the given workspace. ALWAYS Use this tool to set up the user's chosen environment and ALWAYS call this tool before using any other Python related tools or running any Python command in the terminal. IMPORTANT: This tool is only for Python environments (venv, virtualenv, conda, pipenv, poetry, pyenv, pixi, or any other Python environment manager). Do not use this tool for npm packages, system packages, Ruby gems, or any other non-Python dependencies.",
+                "modelDescription": "This tool configures a Python environment in the given workspace. ALWAYS Use this tool to set up the user's chosen environment and ALWAYS call this tool before using any other Python related tools or running any Python command in the terminal. If you already know which Python interpreter to use (e.g. from a previous tool call or user message), pass it as 'pythonPath' to skip interactive prompts and configure the environment automatically. IMPORTANT: This tool is only for Python environments (venv, virtualenv, conda, pipenv, poetry, pyenv, pixi, or any other Python environment manager). Do not use this tool for npm packages, system packages, Ruby gems, or any other non-Python dependencies.",
                 "userDescription": "%python.languageModelTools.configure_python_environment.userDescription%",
                 "toolReferenceName": "configurePythonEnvironment",
                 "tags": [
@@ -1609,6 +1609,10 @@
                         "resourcePath": {
                             "type": "string",
                             "description": "The path to the Python file or workspace for which a Python Environment needs to be configured."
+                        },
+                        "pythonPath": {
+                            "type": "string",
+                            "description": "Optional absolute path to a Python interpreter to use. When provided, the environment is configured automatically without any interactive prompts. Use this to avoid blocking the session on user input."
                         }
                     },
                     "required": []
@@ -1642,7 +1646,7 @@
             {
                 "name": "selectEnvironment",
                 "displayName": "Select a Python Environment",
-                "modelDescription": "This tool will prompt the user to select an existing Python Environment",
+                "modelDescription": "This tool will prompt the user to select an existing Python Environment. If pythonPath is provided, it sets that interpreter directly without showing any UI.",
                 "tags": [],
                 "canBeReferencedInPrompt": false,
                 "inputSchema": {
@@ -1651,6 +1655,10 @@
                         "resourcePath": {
                             "type": "string",
                             "description": "The path to the Python file or workspace for which a Python Environment needs to be configured."
+                        },
+                        "pythonPath": {
+                            "type": "string",
+                            "description": "Optional absolute path to a Python interpreter to use. When provided, the interpreter is set directly without showing any UI picker."
                         }
                     },
                     "required": []

src/client/chat/configurePythonEnvTool.ts

@@ -29,9 +29,20 @@ import { IRecommendedEnvironmentService } from '../interpreter/configuration/typ
 import { CreateVirtualEnvTool } from './createVirtualEnvTool';
 import { ISelectPythonEnvToolArguments, SelectPythonEnvTool } from './selectEnvTool';
 import { BaseTool } from './baseTool';
+import { traceVerbose } from '../logging';
 
-export class ConfigurePythonEnvTool extends BaseTool<IResourceReference>
-    implements LanguageModelTool<IResourceReference> {
+export interface IConfigurePythonEnvToolArguments extends IResourceReference {
+    /**
+     * Optional path to a Python interpreter. When provided, the tool sets this
+     * interpreter directly without any user interaction (no Quick Pick, no
+     * create-venv prompt). This is the recommended way for Copilot to call
+     * the tool in autopilot / bypass-approvals mode.
+     */
+    pythonPath?: string;
+}
+
+export class ConfigurePythonEnvTool extends BaseTool<IConfigurePythonEnvToolArguments>
+    implements LanguageModelTool<IConfigurePythonEnvToolArguments> {
     private readonly terminalExecutionService: TerminalCodeExecutionProvider;
     private readonly terminalHelper: ITerminalHelper;
     private readonly recommendedEnvService: IRecommendedEnvironmentService;
@@ -53,7 +64,7 @@ export class ConfigurePythonEnvTool extends BaseTool<IResourceReference>
     }
 
     async invokeImpl(
-        options: LanguageModelToolInvocationOptions<IResourceReference>,
+        options: LanguageModelToolInvocationOptions<IConfigurePythonEnvToolArguments>,
         resource: Uri | undefined,
         token: CancellationToken,
     ): Promise<LanguageModelToolResult> {
@@ -63,6 +74,11 @@ export class ConfigurePythonEnvTool extends BaseTool<IResourceReference>
             return notebookResponse;
         }
 
+        // Fast path: if the caller provided a pythonPath, set it directly without any UI.
+        if (options.input.pythonPath) {
+            return this.setEnvironmentDirectly(options.input.pythonPath, resource, token);
+        }
+
         const workspaceSpecificEnv = await raceCancellationError(
             this.hasAlreadyGotAWorkspaceSpecificEnvironment(resource),
             token,
@@ -107,8 +123,31 @@ export class ConfigurePythonEnvTool extends BaseTool<IResourceReference>
         }
     }
 
+    /**
+     * Sets the given interpreter path directly without user interaction, then
+     * resolves and returns the environment details.
+     */
+    private async setEnvironmentDirectly(
+        pythonPath: string,
+        resource: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        traceVerbose(`${ConfigurePythonEnvTool.toolName}: setting environment directly from pythonPath: ${pythonPath}`);
+        await raceCancellationError(this.api.updateActiveEnvironmentPath(pythonPath, resource), token);
+        const envPath = this.api.getActiveEnvironmentPath(resource);
+        const environment = await raceCancellationError(this.api.resolveEnvironment(envPath), token);
+        return getEnvDetailsForResponse(
+            environment,
+            this.api,
+            this.terminalExecutionService,
+            this.terminalHelper,
+            resource,
+            token,
+        );
+    }
+
     async prepareInvocationImpl(
-        _options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
+        _options: LanguageModelToolInvocationPrepareOptions<IConfigurePythonEnvToolArguments>,
         _resource: Uri | undefined,
         _token: CancellationToken,
     ): Promise<PreparedToolInvocation> {

src/client/chat/createVirtualEnvTool.ts

@@ -45,7 +45,7 @@ import { hideEnvCreation } from '../pythonEnvironments/creation/provider/hideEnv
 import { BaseTool } from './baseTool';
 
 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.
+    packageList?: string[]; // Added only because we have ability to create a virtual env with list of packages same tool within the in Python Env extension.
 }
 
 export class CreateVirtualEnvTool extends BaseTool<ICreateVirtualEnvToolParams>
@@ -92,18 +92,24 @@ export class CreateVirtualEnvTool extends BaseTool<ICreateVirtualEnvToolParams>
 
             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,
-                });
+                const result: PythonEnvironment | undefined = await raceCancellationError(
+                    Promise.resolve(
+                        commands.executeCommand<PythonEnvironment | undefined>('python-envs.createAny', {
+                            quickCreate: true,
+                            additionalPackages: options.input.packageList || [],
+                            uri: workspaceFolder.uri,
+                            selectEnvironment: true,
+                        }),
+                    ),
+                    token,
+                );
                 createdEnvPath = result?.environmentPath.fsPath;
             } else {
                 const created = await raceCancellationError(
                     createVirtualEnvironment({
                         interpreter: preferredGlobalPythonEnv.id,
                         workspaceFolder,
+                        installPackages: false,
                     }),
                     token,
                 );
@@ -120,7 +126,7 @@ export class CreateVirtualEnvTool extends BaseTool<ICreateVirtualEnvToolParams>
 
             const stopWatch = new StopWatch();
             let env: ResolvedEnvironment | undefined;
-            while (stopWatch.elapsedTime < 5_000 || !env) {
+            while (stopWatch.elapsedTime < 5_000 && !env) {
                 env = await this.api.resolveEnvironment(createdEnvPath);
                 if (env) {
                     break;

src/client/chat/selectEnvTool.ts

@@ -25,6 +25,7 @@ import {
     getEnvDetailsForResponse,
     getToolResponseIfNotebook,
     IResourceReference,
+    raceCancellationError,
 } from './utils';
 import { ITerminalHelper } from '../common/terminal/types';
 import { raceTimeout } from '../common/utils/async';
@@ -40,6 +41,13 @@ import { BaseTool } from './baseTool';
 
 export interface ISelectPythonEnvToolArguments extends IResourceReference {
     reason?: 'cancelled';
+    /**
+     * Optional path to a Python interpreter. When provided, the tool sets this
+     * interpreter directly without showing any Quick Pick UI to the user.
+     * This prevents the agent from getting stuck waiting for user input in
+     * autopilot / bypass-approvals mode.
+     */
+    pythonPath?: string;
 }
 
 export class SelectPythonEnvTool extends BaseTool<ISelectPythonEnvToolArguments>
@@ -64,23 +72,59 @@ export class SelectPythonEnvTool extends BaseTool<ISelectPythonEnvToolArguments>
         resource: Uri | undefined,
         token: CancellationToken,
     ): Promise<LanguageModelToolResult> {
+        // Fast path: if the caller provided a pythonPath, set it directly without any UI.
+        if (options.input.pythonPath) {
+            traceVerbose(
+                `${SelectPythonEnvTool.toolName}: setting environment directly from pythonPath: ${options.input.pythonPath}`,
+            );
+            await raceCancellationError(
+                this.api.updateActiveEnvironmentPath(options.input.pythonPath, resource),
+                token,
+            );
+            const env = await raceCancellationError(
+                this.api.resolveEnvironment(this.api.getActiveEnvironmentPath(resource)),
+                token,
+            );
+            if (env) {
+                return getEnvDetailsForResponse(
+                    env,
+                    this.api,
+                    this.terminalExecutionService,
+                    this.terminalHelper,
+                    resource,
+                    token,
+                );
+            }
+            return new LanguageModelToolResult([
+                new LanguageModelTextPart(
+                    `The provided pythonPath '${options.input.pythonPath}' could not be resolved to a valid Python environment.`,
+                ),
+            ]);
+        }
+
         let selected: boolean | undefined = false;
         const hasVenvOrCondaEnvInWorkspaceFolder = doesWorkspaceHaveVenvOrCondaEnv(resource, this.api);
         if (options.input.reason === 'cancelled' || hasVenvOrCondaEnvInWorkspaceFolder) {
-            const result = (await Promise.resolve(
-                commands.executeCommand(Commands.Set_Interpreter, {
-                    hideCreateVenv: false,
-                    showBackButton: false,
-                }),
-            )) as SelectEnvironmentResult | undefined;
+            const result = await raceCancellationError(
+                Promise.resolve(
+                    commands.executeCommand(Commands.Set_Interpreter, {
+                        hideCreateVenv: false,
+                        showBackButton: false,
+                    }),
+                ) as Promise<SelectEnvironmentResult | undefined>,
+                token,
+            );
             if (result?.path) {
                 traceVerbose(`User selected a Python environment ${result.path} in Select Python Tool.`);
                 selected = true;
             } else {
                 traceWarn(`User did not select a Python environment in Select Python Tool.`);
             }
         } else {
-            selected = await showCreateAndSelectEnvironmentQuickPick(resource, this.serviceContainer);
+            selected = await raceCancellationError(
+                showCreateAndSelectEnvironmentQuickPick(resource, this.serviceContainer),
+                token,
+            );
             if (selected) {
                 traceVerbose(`User selected a Python environment ${selected} in Select Python Tool(2).`);
             } else {