@theia/ai-copilot 1.76.0-next.4 → 1.76.0-next.42

package/src/node/copilot-language-models-manager-impl.spec.ts

@@ -0,0 +1,188 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { LanguageModel, LanguageModelStatus } from '@theia/ai-core';
+import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { CopilotAuthState } from '../common/copilot-auth-service';
+import { CopilotLanguageModelsManagerImpl } from './copilot-language-models-manager-impl';
+
+/** A registry that records the models and the patches it received. */
+class FakeRegistry {
+
+    readonly models: LanguageModel[] = [];
+    readonly patches: Array<{ id: string, patch: Partial<LanguageModel> }> = [];
+
+    async getLanguageModel(id: string): Promise<LanguageModel | undefined> {
+        return this.models.find(model => model.id === id);
+    }
+
+    async getLanguageModels(): Promise<LanguageModel[]> {
+        return this.models;
+    }
+
+    addLanguageModels(models: LanguageModel[]): void {
+        this.models.push(...models);
+    }
+
+    removeLanguageModels(ids: string[]): void {
+        for (const id of ids) {
+            const index = this.models.findIndex(model => model.id === id);
+            if (index >= 0) {
+                this.models.splice(index, 1);
+            }
+        }
+    }
+
+    async patchLanguageModel(id: string, patch: Partial<LanguageModel>): Promise<void> {
+        this.patches.push({ id, patch });
+        Object.assign(this.models.find(model => model.id === id) ?? {}, patch);
+    }
+}
+
+class TestableCopilotLanguageModelsManagerImpl extends CopilotLanguageModelsManagerImpl {
+
+    authState: CopilotAuthState = { isAuthenticated: true };
+    listFailure: Error | undefined;
+    modelIds: string[] = ['gpt-5'];
+
+    callVendorOf(id: string): string | undefined {
+        return this.vendorOf(id);
+    }
+
+    constructor(readonly registry: FakeRegistry) {
+        super();
+        Object.assign(this, {
+            logger: new MockLogger(),
+            languageModelRegistry: registry,
+            authService: {
+                getAuthState: async () => this.authState,
+                onAuthStateChanged: () => ({ dispose: () => { } })
+            },
+            sdkClientProvider: {
+                listModelIds: async () => {
+                    if (this.listFailure) {
+                        throw this.listFailure;
+                    }
+                    return this.modelIds;
+                }
+            }
+        });
+    }
+
+    callCalculateStatus(): Promise<LanguageModelStatus> {
+        return this.calculateStatus();
+    }
+}
+
+describe('CopilotLanguageModelsManagerImpl - status', () => {
+
+    let manager: TestableCopilotLanguageModelsManagerImpl;
+
+    beforeEach(() => {
+        manager = new TestableCopilotLanguageModelsManagerImpl(new FakeRegistry());
+    });
+
+    it('should report a model as ready for a user who is signed in', async () => {
+        await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 3 });
+        expect(manager.registry.models[0].status).to.deep.equal({ status: 'ready' });
+    });
+
+    it('should report a model as unavailable while nobody is signed in', async () => {
+        manager.authState = { isAuthenticated: false };
+        expect(await manager.callCalculateStatus()).to.deep.include({ status: 'unavailable' });
+    });
+
+    it('should report models as unavailable when they cannot be listed, rather than as ready', async () => {
+        manager.listFailure = new Error('not authorized to use this Copilot feature');
+        const result = await manager.fetchAvailableModels();
+        expect(result.models).to.be.empty;
+        expect(result.error).to.contain('not authorized');
+        const status = await manager.callCalculateStatus();
+        expect(status.status).to.equal('unavailable');
+        expect(status.message).to.contain('not authorized');
+    });
+
+    it('should reflect a failed listing in the models that are already registered', async () => {
+        await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 3 });
+        manager.listFailure = new Error('socket hang up');
+        await manager.fetchAvailableModels();
+        expect(manager.registry.patches.map(patch => patch.id)).to.deep.equal(['copilot/gpt-5']);
+        expect(manager.registry.models[0].status).to.deep.include({ status: 'unavailable' });
+    });
+
+    it('should report ready again once the models can be listed', async () => {
+        await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 3 });
+        manager.listFailure = new Error('socket hang up');
+        await manager.fetchAvailableModels();
+        manager.listFailure = undefined;
+        expect((await manager.fetchAvailableModels()).models).to.deep.equal([{ id: 'gpt-5', featured: true }]);
+        expect(manager.registry.models[0].status).to.deep.equal({ status: 'ready' });
+    });
+
+    it('nominates auto and one model of each major vendor before a second of any', async () => {
+        manager.modelIds = ['auto', 'gpt-5', 'gpt-4.1', 'claude-sonnet-4.5', 'claude-haiku-4', 'gemini-2.5-pro', 'gpt-5-2026-04-17'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        // Five in total: auto, the newest of each vendor, then the next of the first vendor with one left.
+        expect(featured).to.have.members(['auto', 'gpt-5', 'claude-sonnet-4.5', 'gemini-2.5-pro', 'claude-haiku-4']);
+    });
+
+    it('fills the list to five even when the CLI offers no auto', async () => {
+        manager.modelIds = ['gpt-5', 'gpt-4.1', 'claude-sonnet-4.5', 'claude-haiku-4', 'gemini-3-pro', 'gemini-2.5-pro'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.have.members(['gpt-5', 'claude-sonnet-4.5', 'gemini-3-pro', 'gpt-4.1', 'claude-haiku-4']);
+    });
+
+    it('nominates no more than the five, however much one vendor offers', async () => {
+        manager.modelIds = ['gpt-5', 'gpt-5-mini', 'gpt-4.1', 'gpt-4o', 'o5-preview', 'chatgpt-5-latest'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.have.lengthOf(5);
+    });
+
+    it('counts the reasoning models as OpenAI, rather than as a vendor of their own', () => {
+        expect(manager.callVendorOf('o5-preview')).to.equal('openai');
+        expect(manager.callVendorOf('gpt-4.1')).to.equal('openai');
+        expect(manager.callVendorOf('claude-sonnet-4.5')).to.equal('anthropic');
+        expect(manager.callVendorOf('grok-code-fast-1')).to.equal(undefined);
+    });
+
+    it('nominates nothing for the vendors beyond the three, which stay selectable but not preselected', async () => {
+        manager.modelIds = ['claude-sonnet-4.5', 'grok-code-fast-1', 'mistral-large', 'llama-4-maverick'];
+        const result = await manager.fetchAvailableModels();
+        expect(result.models.map(model => model.id)).to.have.lengthOf(4);
+        expect(result.models.filter(model => model.featured).map(model => model.id)).to.deep.equal(['claude-sonnet-4.5']);
+    });
+
+    it('recognises a vendor-qualified id, in case the CLI reports them that way', async () => {
+        manager.modelIds = ['google/gemini-2.5-pro', 'anthropic/claude-sonnet-4.5'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.have.members(['google/gemini-2.5-pro', 'anthropic/claude-sonnet-4.5']);
+    });
+
+    it('never nominates a release-pinned id, whose undated form is nominated instead', async () => {
+        manager.modelIds = ['gpt-5', 'gpt-5-2026-04-17'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.deep.equal(['gpt-5']);
+    });
+
+    it('should update an existing model instead of registering it twice', async () => {
+        await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 3 });
+        await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 5 });
+        expect(manager.registry.models).to.have.lengthOf(1);
+        expect(manager.registry.patches).to.have.lengthOf(1);
+        expect(manager.registry.patches[0].patch).to.deep.include({ maxRetries: 5 });
+    });
+});

package/src/node/copilot-language-models-manager-impl.ts

@@ -14,12 +14,30 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { LanguageModelRegistry, LanguageModelStatus } from '@theia/ai-core';
-import { Disposable, DisposableCollection, ILogger } from '@theia/core';
-import { inject, injectable, postConstruct, named } from '@theia/core/shared/inversify';
-import { CopilotLanguageModelsManager, CopilotModelDescription, COPILOT_PROVIDER_ID, getCopilotApiBaseUrl } from '../common';
-import { CopilotOAuthConfig } from '../common/copilot-oauth-config';
-import { CopilotLanguageModel } from './copilot-language-model';
+import { DiscoveredModels, LanguageModelRegistry, LanguageModelStatus, ModelDiscoveryResult } from '@theia/ai-core';
+import { DisposableCollection, ILogger, nls } from '@theia/core';
+import { inject, injectable, named, postConstruct, preDestroy } from '@theia/core/shared/inversify';
+import { CopilotLanguageModelsManager, CopilotModelDescription, COPILOT_PROVIDER_ID } from '../common';
+
+/** The id under which Copilot offers its own model selection; always worth showing. */
+const COPILOT_AUTO_MODEL_ID = 'auto';
+
+/** How many models Copilot nominates, matching what the other providers feature. */
+const NOMINATED_MODEL_COUNT = 5;
+
+/**
+ * The vendors one Copilot model each is nominated for, recognised by the prefix of the model id.
+ * Deliberately the three whose models the other providers of this application offer directly: those
+ * are the ones a user coming to the chat input expects to switch between. Copilot carries more, and
+ * they remain registered and selectable — just not preselected.
+ */
+const NOMINATED_VENDORS: ReadonlyArray<{ vendor: string; matches: RegExp }> = [
+    { vendor: 'anthropic', matches: /^claude/i },
+    { vendor: 'openai', matches: /^(gpt|chatgpt|o\d)/i },
+    { vendor: 'google', matches: /^gemini/i }
+];
+import { CopilotSdkLanguageModel } from './copilot-sdk-language-model';
+import { CopilotSdkClientProvider } from './copilot-sdk-client-provider';
 import { CopilotAuthServiceImpl } from './copilot-auth-service-impl';
 
 /**
@@ -27,7 +45,7 @@ import { CopilotAuthServiceImpl } from './copilot-auth-service-impl';
  * Manages registration and lifecycle of Copilot language models in the AI language model registry.
  */
 @injectable()
-export class CopilotLanguageModelsManagerImpl implements CopilotLanguageModelsManager, Disposable {
+export class CopilotLanguageModelsManagerImpl implements CopilotLanguageModelsManager {
 
     @inject(LanguageModelRegistry)
     protected readonly languageModelRegistry: LanguageModelRegistry;
@@ -35,36 +53,51 @@ export class CopilotLanguageModelsManagerImpl implements CopilotLanguageModelsMa
     @inject(CopilotAuthServiceImpl)
     protected readonly authService: CopilotAuthServiceImpl;
 
-    @inject(CopilotOAuthConfig)
-    protected readonly oauthConfig: CopilotOAuthConfig;
+    @inject(CopilotSdkClientProvider)
+    protected readonly sdkClientProvider: CopilotSdkClientProvider;
 
     @inject(ILogger) @named('ai-copilot:CopilotLanguageModelsManagerImpl')
     protected readonly logger: ILogger;
 
-    protected enterpriseUrl: string | undefined;
     protected readonly toDispose = new DisposableCollection();
 
+    /**
+     * Why the last model discovery failed, if it did.
+     *
+     * Being signed in does not imply that requests are accepted: the credentials can lack the Copilot
+     * entitlement, be revoked, or belong to a subscription served by a different API host. Reporting
+     * the models as ready in those cases claims a working setup that is not there, so the failure is
+     * remembered and reflected in the status of the models.
+     */
+    protected discoveryFailure: string | undefined;
+
     @postConstruct()
     protected init(): void {
         this.toDispose.push(this.authService.onAuthStateChanged(() => {
-            this.refreshModelsStatus();
+            // The listener cannot be awaited, so the failure is reported here rather than escaping as
+            // an unhandled rejection.
+            this.refreshModelsStatus().catch(error => this.logger.warn('Copilot: failed to update the status of the models:', error));
         }));
     }
 
-    dispose(): void {
+    /**
+     * Detaches from the auth service when the container this manager lives in goes away.
+     * Unbinding a container runs `@preDestroy` rather than `dispose`, see the client provider.
+     */
+    @preDestroy()
+    protected stop(): void {
         this.toDispose.dispose();
     }
 
-    setEnterpriseUrl(url: string | undefined): void {
-        this.enterpriseUrl = url;
-    }
-
     protected async calculateStatus(): Promise<LanguageModelStatus> {
         const authState = await this.authService.getAuthState();
-        if (authState.isAuthenticated) {
-            return { status: 'ready' };
+        if (!authState.isAuthenticated) {
+            return { status: 'unavailable', message: nls.localize('theia/ai/copilot/notSignedIn', 'Not signed in to GitHub Copilot') };
         }
-        return { status: 'unavailable', message: 'Not signed in to GitHub Copilot' };
+        if (this.discoveryFailure) {
+            return { status: 'unavailable', message: this.discoveryFailure };
+        }
+        return { status: 'ready' };
     }
 
     async createOrUpdateLanguageModels(...modelDescriptions: CopilotModelDescription[]): Promise<void> {
@@ -74,29 +107,24 @@ export class CopilotLanguageModelsManagerImpl implements CopilotLanguageModelsMa
             const model = await this.languageModelRegistry.getLanguageModel(modelDescription.id);
 
             if (model) {
-                if (!(model instanceof CopilotLanguageModel)) {
+                if (!(model instanceof CopilotSdkLanguageModel)) {
                     this.logger.warn(`Copilot: model ${modelDescription.id} is not a Copilot model`);
                     continue;
                 }
-                await this.languageModelRegistry.patchLanguageModel<CopilotLanguageModel>(modelDescription.id, {
+                await this.languageModelRegistry.patchLanguageModel<CopilotSdkLanguageModel>(modelDescription.id, {
                     model: modelDescription.model,
-                    enableStreaming: modelDescription.enableStreaming,
-                    supportsStructuredOutput: modelDescription.supportsStructuredOutput,
                     status,
                     maxRetries: modelDescription.maxRetries
                 });
             } else {
                 this.languageModelRegistry.addLanguageModels([
-                    new CopilotLanguageModel(
+                    new CopilotSdkLanguageModel(
                         modelDescription.id,
                         modelDescription.model,
                         status,
-                        modelDescription.enableStreaming,
-                        modelDescription.supportsStructuredOutput,
                         modelDescription.maxRetries,
-                        () => this.authService.getAccessToken(),
-                        () => this.enterpriseUrl,
-                        () => this.oauthConfig.userAgent
+                        () => this.sdkClientProvider.getClient(),
+                        this.logger
                     )
                 ]);
             }
@@ -112,79 +140,98 @@ export class CopilotLanguageModelsManagerImpl implements CopilotLanguageModelsMa
         const allModels = await this.languageModelRegistry.getLanguageModels();
 
         for (const model of allModels) {
-            if (model instanceof CopilotLanguageModel && model.id.startsWith(`${COPILOT_PROVIDER_ID}/`)) {
-                await this.languageModelRegistry.patchLanguageModel<CopilotLanguageModel>(model.id, {
+            if (model instanceof CopilotSdkLanguageModel && model.id.startsWith(`${COPILOT_PROVIDER_ID}/`)) {
+                await this.languageModelRegistry.patchLanguageModel<CopilotSdkLanguageModel>(model.id, {
                     status
                 });
             }
         }
     }
 
-    async fetchAvailableModelIds(): Promise<string[]> {
-        const accessToken = await this.authService.getAccessToken();
-        if (!accessToken) {
-            return [];
-        }
-
-        const baseURL = getCopilotApiBaseUrl(this.enterpriseUrl);
-
+    async fetchAvailableModels(): Promise<ModelDiscoveryResult> {
         try {
-            const response = await fetch(`${baseURL}/models`, {
-                headers: {
-                    'Authorization': `Bearer ${accessToken}`,
-                    'User-Agent': this.oauthConfig.userAgent,
-                    'Accept': 'application/json'
-                }
-            });
-
-            if (!response.ok) {
-                this.logger.warn(`Copilot: failed to fetch available models: ${response.status} ${response.statusText}`);
-                return [];
-            }
-
-            const data = await response.json() as {
-                data?: Array<{ id: string; capabilities?: { family?: string } }>
-            };
-            const models = data.data ?? [];
-            const modelIds = this.deduplicateModels(models);
-            this.logger.info(`Copilot: discovered ${modelIds.length} available models: ${modelIds.join(', ')}`);
-            return modelIds;
+            const modelIds = await this.sdkClientProvider.listModelIds();
+            this.logger.info(`Copilot: discovered ${modelIds.length} models [${modelIds.join(', ')}]`);
+            await this.setDiscoveryFailure(undefined);
+            // The CLI reports nothing but the id: no display name, and no release date to order by.
+            const featured = this.selectFeaturedModelIds(modelIds);
+            return { models: modelIds.map(id => ({ id, featured: featured.has(id) })), fromCache: false };
         } catch (error) {
-            this.logger.warn('Copilot: failed to fetch available models:', error);
-            return [];
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn('Copilot: failed to fetch available models via the Copilot CLI:', error);
+            await this.setDiscoveryFailure(message);
+            return { models: [], fromCache: false, error: message };
         }
     }
 
     /**
-     * Deduplicates models returned by the Copilot API.
-     * The API returns both alias IDs (e.g., `gpt-4o`) and versioned IDs
-     * (e.g., `gpt-4o-2024-11-20`) for the same model family.
-     * We keep only the family alias when it exists, falling back to
-     * the versioned ID otherwise.
+     * Nominates the models the chat input should show without the user asking, up to
+     * {@link NOMINATED_MODEL_COUNT}. Copilot serves models of several vendors under one provider, so
+     * ranking them against each other by the numbers in their ids would show several models of
+     * whichever vendor counts highest and none of the others. The list is therefore filled vendor by
+     * vendor: `auto` first, which lets Copilot itself choose and is the entry most users want, then the
+     * newest model of each major vendor, then the next of each in turn until the list is full.
+     *
+     * Everything else Copilot carries is left to be chosen deliberately: the list is meant to be the
+     * handful of models one switches between while chatting, not a survey of the catalogue.
+     *
+     * Release-pinned ids are left out: the undated id of the same model is nominated, and pinning a
+     * release is the deliberate choice the check on its row makes.
      */
-    protected deduplicateModels(models: Array<{ id: string; capabilities?: { family?: string } }>): string[] {
-        const allIds = new Set(models.map(m => m.id));
-        const result: string[] = [];
-        const seenFamilies = new Set<string>();
-
-        for (const model of models) {
-            const family = model.capabilities?.family;
-            if (family && seenFamilies.has(family)) {
+    protected selectFeaturedModelIds(modelIds: string[]): Set<string> {
+        const featured = new Set<string>();
+        const byVendor = new Map<string, string[]>();
+        for (const id of modelIds) {
+            if (id === COPILOT_AUTO_MODEL_ID) {
+                featured.add(id);
                 continue;
             }
-            if (family) {
-                seenFamilies.add(family);
-                // Prefer the family alias if it exists as a model ID
-                if (allIds.has(family)) {
-                    result.push(family);
-                } else {
-                    result.push(model.id);
+            if (DiscoveredModels.undatedId(id) !== undefined) {
+                continue;
+            }
+            const vendor = this.vendorOf(id);
+            if (!vendor) {
+                continue;
+            }
+            byVendor.set(vendor, [...byVendor.get(vendor) ?? [], id]);
+        }
+        // Newest first within each vendor, the vendors themselves in the order they are named.
+        const ranked = NOMINATED_VENDORS.map(({ vendor }) =>
+            [...byVendor.get(vendor) ?? []].sort((left, right) => DiscoveredModels.compareByVersion(left, right)));
+        for (let rank = 0; featured.size < NOMINATED_MODEL_COUNT && ranked.some(ids => ids.length > rank); rank++) {
+            for (const ids of ranked) {
+                if (featured.size >= NOMINATED_MODEL_COUNT) {
+                    break;
+                }
+                if (ids[rank] !== undefined) {
+                    featured.add(ids[rank]);
                 }
-            } else {
-                result.push(model.id);
             }
         }
+        return featured;
+    }
+
+    /**
+     * The vendor a Copilot model id belongs to, or `undefined` for a vendor that is not nominated.
+     * Matching on the id is all there is — the CLI reports nothing else — and it is deliberately narrow:
+     * a model of a vendor this does not name is still registered and still selectable, it is simply not
+     * one of the few the chat input starts with.
+     */
+    protected vendorOf(id: string): string | undefined {
+        // Matched against the last segment, so that an id the CLI qualifies with its vendor
+        // (`google/gemini-2.5-pro`) is recognised as readily as a bare one.
+        const name = id.substring(id.lastIndexOf('/') + 1);
+        return NOMINATED_VENDORS.find(candidate => candidate.matches.test(name))?.vendor;
+    }
 
-        return result;
+    /**
+     * Records the outcome of the last model discovery and reflects it in the status of the models.
+     */
+    protected async setDiscoveryFailure(failure: string | undefined): Promise<void> {
+        if (this.discoveryFailure === failure) {
+            return;
+        }
+        this.discoveryFailure = failure;
+        await this.refreshModelsStatus();
     }
 }

package/src/node/copilot-runtime-env.ts

@@ -0,0 +1,46 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/**
+ * The environment of the processes this integration starts, which are the Copilot CLI of a sign-in
+ * and the one that serves the requests.
+ */
+export namespace CopilotRuntimeEnv {
+
+    /**
+     * The variables the Copilot CLI accepts a token from. None of them is a sign-in of this
+     * application, so a token this application does not own must not reach the CLI through them.
+     */
+    export const TOKEN_VARIABLES = ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'];
+
+    /**
+     * The given environment without the variables that carry a token.
+     *
+     * They are dropped by name and regardless of their case, rather than masked with `undefined`.
+     * Environment variables are case-insensitive on Windows, so a `Github_Token` of the backend would
+     * survive a `GITHUB_TOKEN: undefined` next to it and would still be read by the CLI.
+     */
+    export function withoutTokens(env: NodeJS.ProcessEnv): Record<string, string | undefined> {
+        const dropped = new Set(TOKEN_VARIABLES.map(name => name.toLowerCase()));
+        const result: Record<string, string | undefined> = {};
+        for (const [name, value] of Object.entries(env)) {
+            if (!dropped.has(name.toLowerCase())) {
+                result[name] = value;
+            }
+        }
+        return result;
+    }
+}