Tighten non-interactive environment configuration

eleanorjboyd · eleanorjboyd · commit 42a887dfb640 · 2026-07-20T11:41:18.000-07:00
Avoid stale environment results and cross-workspace event races when a tool receives a Python path. Propagate cancellation through interactive and post-creation waits, and strengthen focused unit coverage.\n\nCo-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/src/client/chat/configurePythonEnvTool.ts b/src/client/chat/configurePythonEnvTool.ts
@@ -31,6 +31,7 @@ import { CreateVirtualEnvTool } from './createVirtualEnvTool';
 import { ISelectPythonEnvToolArguments, SelectPythonEnvTool } from './selectEnvTool';
 import { BaseTool } from './baseTool';
 import { traceVerbose } from '../logging';
+import { ErrorWithTelemetrySafeReason } from '../common/errors/errorUtils';
 
 export interface IConfigurePythonEnvToolArguments extends IResourceReference {
     /**
@@ -137,15 +138,25 @@ export class ConfigurePythonEnvTool extends BaseTool<IConfigurePythonEnvToolArgu
         const result = await setEnvironmentDirectlyByPath(
             pythonPath,
             this.api,
-            this.terminalExecutionService,
-            this.terminalHelper,
             resource,
             token,
         );
         if (result) {
-            return result;
+            this.extraTelemetryProperties.resolveOutcome = 'providedEnv';
+            this.extraTelemetryProperties.envType = getEnvTypeForTelemetry(result);
+            return getEnvDetailsForResponse(
+                result,
+                this.api,
+                this.terminalExecutionService,
+                this.terminalHelper,
+                resource,
+                token,
+            );
         }
-        throw new Error(`No environment found for the provided pythonPath '${pythonPath}'.`);
+        throw new ErrorWithTelemetrySafeReason(
+            `No environment found for the provided pythonPath '${pythonPath}'.`,
+            'noEnvFound',
+        );
     }
 
     async prepareInvocationImpl(
diff --git a/src/client/chat/createVirtualEnvTool.ts b/src/client/chat/createVirtualEnvTool.ts
@@ -122,19 +122,19 @@ export class CreateVirtualEnvTool extends BaseTool<ICreateVirtualEnvToolParams>
 
             // Wait a few secs to ensure the env is selected as the active environment..
             // If this doesn't work, then something went wrong.
-            await raceTimeout(5_000, interpreterChanged);
+            await raceCancellationError(raceTimeout(5_000, interpreterChanged), token);
 
             const stopWatch = new StopWatch();
             let env: ResolvedEnvironment | undefined;
             while (stopWatch.elapsedTime < 5_000 && !env) {
-                env = await this.api.resolveEnvironment(createdEnvPath);
+                env = await raceCancellationError(this.api.resolveEnvironment(createdEnvPath), token);
                 if (env) {
                     break;
                 } else {
                     traceVerbose(
                         `${CreateVirtualEnvTool.toolName} tool invoked, env created but not yet resolved, waiting...`,
                     );
-                    await sleep(200);
+                    await raceCancellationError(sleep(200), token);
                 }
             }
             if (!env) {
diff --git a/src/client/chat/selectEnvTool.ts b/src/client/chat/selectEnvTool.ts
@@ -86,13 +86,18 @@ export class SelectPythonEnvTool extends BaseTool<ISelectPythonEnvToolArguments>
             const result = await setEnvironmentDirectlyByPath(
                 options.input.pythonPath,
                 this.api,
-                this.terminalExecutionService,
-                this.terminalHelper,
                 resource,
                 token,
             );
             if (result) {
-                return result;
+                return getEnvDetailsForResponse(
+                    result,
+                    this.api,
+                    this.terminalExecutionService,
+                    this.terminalHelper,
+                    resource,
+                    token,
+                );
             }
             return new LanguageModelToolResult([
                 new LanguageModelTextPart(
@@ -121,7 +126,7 @@ export class SelectPythonEnvTool extends BaseTool<ISelectPythonEnvToolArguments>
             }
         } else {
             selected = await raceCancellationError(
-                showCreateAndSelectEnvironmentQuickPick(resource, this.serviceContainer),
+                showCreateAndSelectEnvironmentQuickPick(resource, this.serviceContainer, token),
                 token,
             );
             if (selected) {
@@ -201,6 +206,7 @@ export class SelectPythonEnvTool extends BaseTool<ISelectPythonEnvToolArguments>
 async function showCreateAndSelectEnvironmentQuickPick(
     uri: Uri | undefined,
     serviceContainer: IServiceContainer,
+    token: CancellationToken,
 ): Promise<boolean | undefined> {
     const createLabel = `${Octicons.Add} ${InterpreterQuickPickList.create.label}`;
     const selectLabel = l10n.t('Select an existing Python Environment');
@@ -210,11 +216,15 @@ async function showCreateAndSelectEnvironmentQuickPick(
         { label: selectLabel },
     ];
 
-    const selectedItem = await showQuickPick(items, {
-        placeHolder: l10n.t('Configure a Python Environment'),
-        matchOnDescription: true,
-        ignoreFocusOut: true,
-    });
+    const selectedItem = await showQuickPick(
+        items,
+        {
+            placeHolder: l10n.t('Configure a Python Environment'),
+            matchOnDescription: true,
+            ignoreFocusOut: true,
+        },
+        token,
+    );
 
     if (selectedItem && !Array.isArray(selectedItem) && selectedItem.label === createLabel) {
         const disposables = new DisposableStore();
@@ -236,7 +246,7 @@ async function showCreateAndSelectEnvironmentQuickPick(
             );
 
             if (created?.action === 'Back') {
-                return showCreateAndSelectEnvironmentQuickPick(uri, serviceContainer);
+                return showCreateAndSelectEnvironmentQuickPick(uri, serviceContainer, token);
             }
             if (created?.action === 'Cancel') {
                 return undefined;
@@ -255,7 +265,7 @@ async function showCreateAndSelectEnvironmentQuickPick(
             commands.executeCommand(Commands.Set_Interpreter, { hideCreateVenv: true, showBackButton: true }),
         )) as SelectEnvironmentResult | undefined;
         if (result?.action === 'Back') {
-            return showCreateAndSelectEnvironmentQuickPick(uri, serviceContainer);
+            return showCreateAndSelectEnvironmentQuickPick(uri, serviceContainer, token);
         }
         if (result?.action === 'Cancel') {
             return undefined;
diff --git a/src/client/chat/utils.ts b/src/client/chat/utils.ts
@@ -20,6 +20,7 @@ import { dirname, join } from 'path';
 import { resolveEnvironment, useEnvExtension } from '../envExt/api.internal';
 import { ErrorWithTelemetrySafeReason } from '../common/errors/errorUtils';
 import { getWorkspaceFolders } from '../common/vscodeApis/workspaceApis';
+import { arePathsSame } from '../common/platform/fs-paths';
 
 export interface IResourceReference {
     resourcePath?: string;
@@ -49,12 +50,24 @@ export function resolveFilePath(filepath?: string): Uri | undefined {
  * @see {@link raceCancellation}
  */
 export function raceCancellationError<T>(promise: Promise<T>, token: CancellationToken): Promise<T> {
+    if (token.isCancellationRequested) {
+        return Promise.reject(new CancellationError());
+    }
     return new Promise((resolve, reject) => {
         const ref = token.onCancellationRequested(() => {
             ref.dispose();
             reject(new CancellationError());
         });
-        promise.then(resolve, reject).finally(() => ref.dispose());
+        promise.then(
+            (value) => {
+                ref.dispose();
+                resolve(value);
+            },
+            (error) => {
+                ref.dispose();
+                reject(error);
+            },
+        );
     });
 }
 
@@ -68,13 +81,17 @@ export function raceCancellationError<T>(promise: Promise<T>, token: Cancellatio
 export function waitForActiveEnvironmentChange(
     api: PythonExtension['environments'],
     pythonPath: string,
+    resource: Uri | undefined,
     token: CancellationToken,
     timeoutMs = 5000,
 ): Promise<void> {
+    if (token.isCancellationRequested) {
+        return Promise.resolve();
+    }
     return new Promise<void>((resolve) => {
         let settled = false;
         const listener = api.onDidChangeActiveEnvironmentPath((e) => {
-            if (e.path === pythonPath || e.id === pythonPath) {
+            if (isEnvironmentPathMatch(e, pythonPath) && isResourceMatch(e.resource, resource)) {
                 settle();
             }
         });
@@ -93,49 +110,63 @@ export function waitForActiveEnvironmentChange(
     });
 }
 
+function isResourceMatch(
+    eventResource: { uri: Uri } | Uri | undefined,
+    requestedResource: Uri | undefined,
+): boolean {
+    const eventUri = eventResource && 'uri' in eventResource ? eventResource.uri : eventResource;
+    const requestedUri = requestedResource
+        ? workspace.getWorkspaceFolder(requestedResource)?.uri ?? requestedResource
+        : undefined;
+    return eventUri === undefined
+        ? requestedUri === undefined
+        : requestedUri !== undefined && arePathsSame(eventUri.fsPath, requestedUri.fsPath);
+}
+
+function isEnvironmentPathMatch(environment: { path: string; id: string }, pythonPath: string): boolean {
+    return arePathsSame(environment.path, pythonPath) || environment.id === pythonPath;
+}
+
 /**
  * Sets the active Python interpreter to `pythonPath` without any UI, waits for the
  * asynchronous environment switch to settle (via `onDidChangeActiveEnvironmentPath`),
- * resolves the environment, and returns a tool result describing it.
+ * resolves the environment, and returns it.
  *
  * Returns `undefined` if the path cannot be resolved to a valid environment so callers
  * can produce a tool-specific error message.
  */
 export async function setEnvironmentDirectlyByPath(
     pythonPath: string,
     api: PythonExtension['environments'],
-    terminalExecutionService: TerminalCodeExecutionProvider,
-    terminalHelper: ITerminalHelper,
     resource: Uri | undefined,
     token: CancellationToken,
-): Promise<LanguageModelToolResult | undefined> {
+): Promise<ResolvedEnvironment | undefined> {
     // Validate the path resolves to a real environment BEFORE mutating user settings.
     // updateActiveEnvironmentPath persists unconditionally, so an invalid path would
     // permanently overwrite the user's selected interpreter.
     const candidate = await raceCancellationError(api.resolveEnvironment(pythonPath), token);
     if (!candidate) {
         return undefined;
     }
+    if (isEnvironmentPathMatch(api.getActiveEnvironmentPath(resource), pythonPath)) {
+        return candidate;
+    }
 
     // Subscribe to the change event BEFORE triggering the update so we don't miss it.
     // updateActiveEnvironmentPath only persists the setting; the active interpreter switch
     // is asynchronous, so we wait for the event before resolving env details to avoid
     // returning details for the previously-active interpreter.
-    const activeChanged = waitForActiveEnvironmentChange(api, pythonPath, token);
+    const activeChanged = waitForActiveEnvironmentChange(api, pythonPath, resource, token);
     await raceCancellationError(api.updateActiveEnvironmentPath(pythonPath, resource), token);
     await raceCancellationError(activeChanged, token);
 
     // Verify the active env actually switched. If the change event timed out and the
     // active path is still the previous one, don't report success for the wrong env.
     const envPath = api.getActiveEnvironmentPath(resource);
-    if (envPath.path !== pythonPath && envPath.id !== pythonPath) {
-        return undefined;
-    }
-    const environment = await raceCancellationError(api.resolveEnvironment(envPath), token);
-    if (!environment) {
+    if (!isEnvironmentPathMatch(envPath, pythonPath)) {
         return undefined;
     }
-    return getEnvDetailsForResponse(environment, api, terminalExecutionService, terminalHelper, resource, token);
+    return raceCancellationError(api.resolveEnvironment(envPath), token);
 }
 
 export async function getEnvDisplayName(
diff --git a/src/test/chat/setEnvironmentFastPath.unit.test.ts b/src/test/chat/setEnvironmentFastPath.unit.test.ts
